Throws

AspireAzureOpenAIClientBuilderChatClientExtensionsTests.cs (2)

122var ex = Assert.Throws<InvalidOperationException>(() => 153var ex = Assert.Throws<InvalidOperationException>(() =>

AspireAzureOpenAIClientBuilderEmbeddingGeneratorExtensionsTests.cs (2)

122var ex = Assert.Throws<InvalidOperationException>(() => 153var ex = Assert.Throws<InvalidOperationException>(() =>

AspireConfigurableOpenAIExtensionsTests.cs (1)

25Assert.Throws<InvalidOperationException>(() =>

AspireWebPubSubExtensionsTests.cs (1)

163Assert.Throws<ArgumentException>(() => builder.AddKeyedAzureWebPubSubServiceClient("wps", ""));

ElasticsearchClientPublicApiTests.cs (6)

20var exception = Assert.Throws<ArgumentNullException>(action); 33var exception = Assert.Throws<ArgumentNullException>(action); 46var exception = Assert.Throws<ArgumentException>(action); 59var exception = Assert.Throws<ArgumentNullException>(action); 72var exception = Assert.Throws<ArgumentNullException>(action); 85var exception = Assert.Throws<ArgumentException>(action);

AzureBicepProvisionerTests.cs (1)

109Assert.Throws<ArgumentException>(() =>

WithDockerfileTests.cs (3)

485var ex = Assert.Throws<ArgumentException>(() => 499var ex = Assert.Throws<ArgumentException>(() => 516var ex = Assert.Throws<InvalidOperationException>(() =>

DistributedApplicationTests.cs (1)

213var ex = Assert.Throws<AggregateException>(testProgram.Run);

ProjectResourceTests.cs (1)

23var ex = Assert.Throws<DistributedApplicationException>(() =>

WaitForTests.cs (4)

46var waitForEx = Assert.Throws<DistributedApplicationException>(() => 53var waitForCompletionEx = Assert.Throws<DistributedApplicationException>(() => 68var waitForEx = Assert.Throws<DistributedApplicationException>(() => 75var waitForCompletionEx = Assert.Throws<DistributedApplicationException>(() =>

WithEndpointTests.cs (3)

159var ex = Assert.Throws<DistributedApplicationException>(() => 174var ex = Assert.Throws<DistributedApplicationException>(() => 189var ex = Assert.Throws<DistributedApplicationException>(() =>

AspireAzureEfCoreCosmosDBExtensionsTests.cs (1)

173var exception = Assert.Throws<InvalidOperationException>(() => builder.AddCosmosDbContext<TestDbContext>("cosmos", "databaseName"));

EnrichCosmosDbTests.cs (1)

32var exception = Assert.Throws<InvalidOperationException>(() => builder.EnrichCosmosDbContext<TestDbContext>());

AspireSqlServerEFCoreSqlClientExtensionsTests.cs (1)

274var exception = Assert.Throws<InvalidOperationException>(() => builder.AddSqlServerDbContext<TestDbContext>("sqlconnection"));

EnrichSqlServerTests.cs (1)

36var exception = Assert.Throws<InvalidOperationException>(() => builder.EnrichSqlServerDbContext<TestDbContext>());

MilvusClientPublicApiTests.cs (6)

20var exception = Assert.Throws<ArgumentNullException>(action); 33var exception = Assert.Throws<ArgumentNullException>(action); 46var exception = Assert.Throws<ArgumentException>(action); 59var exception = Assert.Throws<ArgumentNullException>(action); 72var exception = Assert.Throws<ArgumentNullException>(action); 85var exception = Assert.Throws<ArgumentException>(action);

MongoDBDriverPublicApiTests.cs (6)

19var exception = Assert.Throws<ArgumentNullException>(action); 31var exception = Assert.Throws<ArgumentNullException>(action); 43var exception = Assert.Throws<ArgumentException>(action); 55var exception = Assert.Throws<ArgumentNullException>(action); 67var exception = Assert.Throws<ArgumentNullException>(action); 79var exception = Assert.Throws<ArgumentException>(action);

tests\Aspire.MongoDB.Driver.Tests\MongoDBDriverPublicApiTests.cs (6)

19var exception = Assert.Throws<ArgumentNullException>(action); 31var exception = Assert.Throws<ArgumentNullException>(action); 43var exception = Assert.Throws<ArgumentException>(action); 55var exception = Assert.Throws<ArgumentNullException>(action); 67var exception = Assert.Throws<ArgumentNullException>(action); 79var exception = Assert.Throws<ArgumentException>(action);

NatsClientPublicApiTests.cs (7)

23var exception = Assert.Throws<ArgumentNullException>(action); 36var exception = Assert.Throws<ArgumentNullException>(action); 49var exception = Assert.Throws<ArgumentException>(action); 62var exception = Assert.Throws<ArgumentNullException>(action); 75var exception = Assert.Throws<ArgumentNullException>(action); 88var exception = Assert.Throws<ArgumentException>(action); 99var exception = Assert.Throws<ArgumentNullException>(action);

AspireEFPostgreSqlExtensionsTests.cs (1)

281var exception = Assert.Throws<InvalidOperationException>(() => builder.AddNpgsqlDbContext<TestDbContext>("npgsql"));

EnrichNpgsqlTests.cs (1)

37var exception = Assert.Throws<InvalidOperationException>(() => builder.EnrichNpgsqlDbContext<TestDbContext>());

AspireOpenAIClientBuilderChatClientExtensionsTests.cs (2)

123var ex = Assert.Throws<InvalidOperationException>(() => 154var ex = Assert.Throws<InvalidOperationException>(() =>

AspireOpenAIClientBuilderEmbeddingGeneratorExtensionsTests.cs (2)

123var ex = Assert.Throws<InvalidOperationException>(() => 154var ex = Assert.Throws<InvalidOperationException>(() =>

AspireOracleEFCoreDatabaseExtensionsTests.cs (1)

275var exception = Assert.Throws<InvalidOperationException>(() => builder.AddOracleDatabaseDbContext<TestDbContext>("orclconnection"));

EnrichOracleDatabaseTests.cs (1)

37var exception = Assert.Throws<InvalidOperationException>(() => builder.EnrichOracleDatabaseDbContext<TestDbContext>());

AspireEFMySqlExtensionsTests.cs (1)

269var exception = Assert.Throws<InvalidOperationException>(() => builder.AddMySqlDbContext<TestDbContext>("mysql"));

EnrichMySqlTests.cs (1)

50var exception = Assert.Throws<InvalidOperationException>(() => builder.EnrichMySqlDbContext<TestDbContext>());

BasicHttpBindingTests.4.0.0.cs (1)

308Assert.Throws<FormatException>(() =>

NetHttpsBindingTests.4.1.0.cs (1)

62Assert.Throws<PlatformNotSupportedException>(() =>

OperationContextTests.cs (1)

52Assert.Throws<InvalidOperationException>(() => scope.Dispose());

UDSBindingTests.cs (1)

197Assert.Throws<EndpointNotFoundException>(() => ((IChannel)serviceProxy).Open());

DuplexClientBaseTests.4.1.0.cs (2)

33var exception = Assert.Throws<InvalidOperationException>(() => 43Assert.Throws<CommunicationObjectFaultedException>(() =>

SessionTests.cs (4)

107Assert.Throws<InvalidOperationException>(() => 131Assert.Throws<InvalidOperationException>(() => 155Assert.Throws<InvalidOperationException>(() => 441Assert.Throws<CommunicationException>(() =>

ExpectedExceptionTests.4.0.0.cs (5)

28ActionNotSupportedException exception = Assert.Throws<ActionNotSupportedException>(() => 68TimeoutException exception = Assert.Throws<TimeoutException>(() => 115TimeoutException exception = Assert.Throws<TimeoutException>(() => 158FaultException<FaultDetail> exception = Assert.Throws<FaultException<FaultDetail>>(() => 193FaultException<ExceptionDetail> exception = Assert.Throws<FaultException<ExceptionDetail>>(() =>

ExpectedExceptionTests.4.1.0.cs (6)

28EndpointNotFoundException exception = Assert.Throws<EndpointNotFoundException>(() => 130CommunicationException exception = Assert.Throws<CommunicationException>(() => 160EndpointNotFoundException exception = Assert.Throws<EndpointNotFoundException>(() => 198ProtocolException exception = Assert.Throws<ProtocolException>(() => 238FaultException<FaultDetail> exception = Assert.Throws<FaultException<FaultDetail>>(() => 290FaultException<FaultDetail> exception = Assert.Throws<FaultException<FaultDetail>>(() =>

ExpectedExceptionTests.4.1.1.cs (1)

27var exception = Assert.Throws<Exception>(() =>

FaultExceptionTests.4.0.0.cs (6)

24FaultException<FaultDetail> exception = Assert.Throws<FaultException<FaultDetail>>(() => 58FaultException<ExceptionDetail> exception = Assert.Throws<FaultException<ExceptionDetail>>(() => 101thrownException = Assert.Throws<FaultException<int>>(() => 130var exception = Assert.Throws<FaultException<FaultDetail>>(() => 167var exception = Assert.Throws<FaultException<FaultDetail2>>(() => 204var exception = Assert.Throws<FaultException<FaultDetail>>(() =>

MessageContractTests.cs (1)

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

ServiceContractTests.4.1.0.cs (2)

276Assert.Throws<TimeoutException>(() => 332Assert.Throws<TimeoutException>(() =>

TextEncodingTests.4.1.0.cs (1)

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

Http2\Http2StreamTests.cs (12)

Http3\Http3StreamTests.cs (11)

RequestTests.cs (2)

1701var ioEx2 = Assert.Throws<InvalidOperationException>(() => context.Request.Body.CopyTo(Stream.Null)); 1794var ioEx2 = Assert.Throws<InvalidOperationException>(() => context.Request.Body.CopyTo(Stream.Null));

ResponseHeaderTests.cs (5)

23Assert.Throws<InvalidOperationException>(() => context.Response.Headers.Append("Custom你好Name", "Custom Value")); 26Assert.Throws<InvalidOperationException>(() => context.Response.Headers.Append("CustomName", "Custom 你好 Value")); 27Assert.Throws<InvalidOperationException>(() => context.Response.Headers.Append("CustomName", "Custom \r Value")); 54Assert.Throws<InvalidOperationException>(() => context.Response.Headers.Append("Custom你好Name", "Custom Value")); 55Assert.Throws<InvalidOperationException>(() => context.Response.Headers.Append("CustomName", "Custom \r Value"));

ResponseTests.cs (10)

Http3\Http3TlsTests.cs (2)

393Assert.Throws<InvalidOperationException>(host.Run); 426Assert.Throws<InvalidOperationException>(host.Run);

InternalReferencedInPublicDocAnalyzerTests.cs (1)

89Assert.Throws<ArgumentNullException>(() => a.Initialize(null!));

AsyncContextHttpContextOfTTests.cs (1)

71Assert.Throws<InvalidOperationException>(() => _context.Set(value));

LdapSettingsValidationTests.cs (2)

16Assert.Throws<ArgumentNullException>(() => settings.Validate()); 28Assert.Throws<ArgumentNullException>(() => settings.Validate());

AuthorizationAppBuilderExtensionsTests.cs (1)

52var ex = Assert.Throws<InvalidOperationException>(() =>

AuthorizeViewTest.cs (2)

244var ex = Assert.Throws<InvalidOperationException>(() => 492var ex = Assert.Throws<NotSupportedException>(rootComponent.TriggerRender);

CascadingAuthenticationStateTest.cs (1)

28var ex = Assert.Throws<InvalidOperationException>(() => component.TriggerRender());

Buffering\BufferedTextWriterTest.cs (1)

12Assert.Throws<NotSupportedException>(writer.Flush);

Circuits\RemoteJSRuntimeTest.cs (3)

33var ex = Assert.Throws<ArgumentOutOfRangeException>(() => jsRuntime.TestReceiveByteArray(id: 0, data)); 73var ex = Assert.Throws<ArgumentOutOfRangeException>(() => jsRuntime.TestReceiveByteArray(5, new byte[] { 0 })); 85var ex = Assert.Throws<ArgumentOutOfRangeException>(() => jsRuntime.TestReceiveByteArray(1, new byte[5000]));

ElementReferenceJsonConverterTest.cs (2)

84var ex = Assert.Throws<JsonException>(() => 103var ex = Assert.Throws<JsonException>(() =>

CascadingParameterTest.cs (2)

325var ex = Assert.Throws<InvalidOperationException>(() => component.TriggerRender()); 350var ex = Assert.Throws<InvalidOperationException>(() => component.TriggerRender());

DependencyInjectionTest.cs (3)

44var ex = Assert.Throws<InvalidOperationException>(() => 57var ex = Assert.Throws<InvalidOperationException>(() => 73var ex = Assert.Throws<InvalidOperationException>(() =>

DynamicComponentTest.cs (2)

14var ex = Assert.Throws<InvalidOperationException>(() => 35var ex = Assert.Throws<InvalidOperationException>(

Lifetime\ComponentApplicationStateTest.cs (1)

96Assert.Throws<ArgumentException>(() => applicationState.PersistAsJson("MyState", myState));

NavigationManagerTest.cs (2)

56var ex = Assert.Throws<ArgumentException>(() => 74var ex = Assert.Throws<ArgumentException>(() =>

ParameterViewTest.Assignment.cs (15)

ParameterViewTest.cs (2)

232Assert.Throws<InvalidCastException>(() => 338Assert.Throws<InvalidOperationException>(() => parameterView.SetParameterProperties(new object()));

RendererTest.cs (8)

2924var ex = Assert.Throws<InvalidOperationException>(component.TriggerRender); 4430var ex = Assert.Throws<InvalidOperationException>( 4460Assert.Throws<InvalidOperationException>(() => parameterView.SetParameterProperties(new object())); 4828var ex = Assert.Throws<ArgumentException>(() => 4854var ex = Assert.Throws<ArgumentException>(() => 4883var ex = Assert.Throws<InvalidOperationException>(() => 5043var ex = Assert.Throws<NotSupportedException>(() => component.TriggerRender()); 5061var ex = Assert.Throws<NotSupportedException>(component.TriggerRender);

Rendering\RendererSynchronizationContextTest.cs (1)

316Assert.Throws<InvalidTimeZoneException>(() => context.Send((_) =>

Rendering\RenderTreeBuilderTest.cs (27)

RouteViewTest.cs (1)

35var ex = Assert.Throws<InvalidOperationException>(() =>

Forms\InputBaseTest.cs (1)

21var ex = Assert.Throws<InvalidOperationException>(() => rootComponent.TriggerRender());

Forms\Mapping\FormMappingScopeTest.cs (3)

91var exception = Assert.Throws<InvalidOperationException>(() => _renderer.RenderRootComponent(id)); 106var exception = Assert.Throws<InvalidOperationException>(() => _renderer.RenderRootComponent(id)); 129var exception = Assert.Throws<InvalidOperationException>(testComponent.TriggerRender);

HtmlRendering\HtmlRendererTest.cs (2)

42var ex = Assert.Throws<InvalidOperationException>(() => htmlContent.WriteHtmlTo(new StringWriter())); 935var ex = Assert.Throws<InvalidTimeZoneException>(() =>

CookieConsentTests.cs (1)

331Assert.Throws<InvalidOperationException>(() => context.Response.Cookies.Append("Test", "Value"));

CookiePolicyTests.cs (4)

338Assert.Throws<NotImplementedException>(() => context.Response.Cookies.Delete("A")); 339Assert.Throws<NotImplementedException>(() => context.Response.Cookies.Delete("A", new CookieOptions())); 340Assert.Throws<NotImplementedException>(() => context.Response.Cookies.Append("A", "A")); 341Assert.Throws<NotImplementedException>(() => context.Response.Cookies.Append("A", "A", new CookieOptions()));

CorsPolicyTests.cs (1)

48var exception = Assert.Throws<ArgumentOutOfRangeException>(() =>

CorsResultTests.cs (1)

30var exception = Assert.Throws<ArgumentOutOfRangeException>(() =>

src\DataProtection\shared\test\ExceptionAssert2.cs (1)

20return Assert.Throws<CryptographicException>(testCode);

src\DataProtection\shared\test\ExceptionAssert2.cs (1)

20return Assert.Throws<CryptographicException>(testCode);

DataProtectionCommonExtensionsTests.cs (3)

250var ex = Assert.Throws<CryptographicException>(() => 278var ex = Assert.Throws<CryptographicException>(() => 292var ex = Assert.Throws<CryptographicException>(() =>

src\DataProtection\shared\test\ExceptionAssert2.cs (1)

20return Assert.Throws<CryptographicException>(testCode);

Internal\KeyManagementOptionsPostSetupTest.cs (1)

168Assert.Throws<InvalidOperationException>(() => repository.StoreElement(xElement, friendlyName: null));

SecretTests.cs (2)

218Assert.Throws<ObjectDisposedException>( 259Assert.Throws<ObjectDisposedException>(

ServiceCollectionTests.cs (1)

102Assert.Throws<InvalidOperationException>(() => repository.StoreElement(xElement, friendlyName: null));

src\DataProtection\shared\test\ExceptionAssert2.cs (1)

20return Assert.Throws<CryptographicException>(testCode);

HealthCheckEndpointRouteBuilderExtensionsTest.cs (1)

38var ex = Assert.Throws<InvalidOperationException>(() => host.Start());

HealthCheckMiddlewareTests.cs (1)

33var ex = Assert.Throws<InvalidOperationException>(() => host.Start());

ExceptionHandlerTest.cs (1)

526var exception = Assert.Throws<InvalidOperationException>(() => host.Start());

ConfigureBuilderTests.cs (1)

26var ex = Assert.Throws<InvalidOperationException>(() => action.Invoke(applicationBuilder));

WebHostBuilderTests.cs (6)

233Assert.Throws<InvalidOperationException>(() => host.Start()); 261Assert.Throws<InvalidOperationException>(() => host.Start()); 714var ex = Assert.Throws<InvalidOperationException>(() => 1012var exception = Assert.Throws<NotSupportedException>(() => 1033var exception = Assert.Throws<NotSupportedException>(() => 1251Assert.Throws<InvalidOperationException>(() => host.Start());

RouteValueDictionaryTests.cs (1)

352var exception = Assert.Throws<InvalidOperationException>(() =>

UseWhenExtensionsTests.cs (2)

21Assert.Throws<ArgumentNullException>(nullPredicate); 22Assert.Throws<ArgumentNullException>(nullConfiguration);

ResponseExtensionTests.cs (1)

31Assert.Throws<InvalidOperationException>(() => context.Response.Clear());

UriHelperTests.cs (1)

192Assert.Throws<ArgumentNullException>(() => UriHelper.FromAbsolute(null, out resScheme, out resHost, out resPath, out resQuery, out resFragment));

HeaderDictionaryTests.cs (3)

96Assert.Throws<InvalidOperationException>(() => headers.Add(new KeyValuePair<string, StringValues>("header1", "value1"))); 97Assert.Throws<InvalidOperationException>(() => headers.Add("header1", "value1")); 98Assert.Throws<InvalidOperationException>(() => headers.Clear());

Internal\ReferenceReadStreamTests.cs (3)

35Assert.Throws<NotSupportedException>(() => stream.SetLength(0)); 42Assert.Throws<NotSupportedException>(() => stream.Write(new byte[1], 0, 1)); 49Assert.Throws<NotSupportedException>(() => stream.WriteByte(0));

HstsMiddlewareTests.cs (2)

24Assert.Throws<ArgumentNullException>(() => 33Assert.Throws<ArgumentNullException>(() =>

PasswordHasherTest.cs (2)

29var ex = Assert.Throws<InvalidOperationException>(() => 42var ex = Assert.Throws<InvalidOperationException>(() =>

LogValuesAssertTest.cs (2)

119var equalException = Assert.Throws<EqualException>( 207var equalException = Assert.Throws<EqualException>(

IntegrationTests\AnonymousObjectIntegrationTest.cs (7)

21var exception = Assert.Throws<JsonPatchException>(() => 45var exception = Assert.Throws<JsonPatchException>(() => 68var exception = Assert.Throws<JsonPatchException>(() => 91var exception = Assert.Throws<JsonPatchException>(() => 115var exception = Assert.Throws<JsonPatchException>(() => 139var exception = Assert.Throws<JsonPatchException>(() => 180var exception = Assert.Throws<JsonPatchException>(() =>

IntegrationTests\DictionaryIntegrationTest.cs (1)

168var exception = Assert.Throws<JsonPatchException>(() =>

IntegrationTests\DynamicObjectIntegrationTest.cs (3)

60var exception = Assert.Throws<JsonPatchException>(() => 160var exception = Assert.Throws<JsonPatchException>(() => 225var exception = Assert.Throws<JsonPatchException>(() =>

IntegrationTests\ExpandoObjectIntegrationTest.cs (5)

147var exception = Assert.Throws<JsonPatchException>(() => 168var exception = Assert.Throws<JsonPatchException>(() => 272var exception = Assert.Throws<JsonPatchException>(() => 312var exception = Assert.Throws<JsonPatchException>(() => 354var exception = Assert.Throws<JsonPatchException>(() =>

IntegrationTests\ListIntegrationTest.cs (3)

48var exception = Assert.Throws<JsonPatchException>(() => { patchDocument.ApplyTo(targetObject); }); 160var exception = Assert.Throws<JsonPatchException>(() => 248var exception = Assert.Throws<JsonPatchException>(() => { patchDocument.ApplyTo(targetObject); });

IntegrationTests\SimpleObjectIntegrationTest.cs (1)

164var ex = Assert.Throws<JsonPatchException>(() => document.ApplyTo(target));

Internal\ParsedPathTests.cs (1)

36Assert.Throws<JsonPatchException>(() =>

JsonPatchDocumentJObjectTest.cs (1)

43Assert.Throws<JsonPatchException>(() => patch.ApplyTo(model));

JsonPatchDocumentTest.cs (4)

19var exception = Assert.Throws<JsonPatchException>(() => 37var exception = Assert.Throws<JsonPatchException>(() => 135var exception = Assert.Throws<JsonSerializationException>(() => 152var exception = Assert.Throws<JsonSerializationException>(() =>

ModelBinding\ModelStateDictionaryTest.cs (5)

193var exception = Assert.Throws<InvalidOperationException>(() => source.MarkFieldSkipped("key")); 252var exception = Assert.Throws<InvalidOperationException>(() => source.MarkFieldValid("key")); 1687var invalidException = Assert.Throws<InvalidOperationException>(() => dictionary.SetModelValue(key, string.Empty, string.Empty)); 1705var exception = Assert.Throws<InvalidOperationException>(() => source.MarkFieldValid(key)); 1723var exception = Assert.Throws<InvalidOperationException>(() => source.MarkFieldSkipped(key));

ApplicationModels\AttributeRouteModelTests.cs (2)

170var ex = Assert.Throws<InvalidOperationException>( 197var ex = Assert.Throws<InvalidOperationException>(

Builder\MvcApplicationBuilderExtensionsTest.cs (1)

71var ex = Assert.Throws<InvalidOperationException>(() =>

ModelBinding\Validation\DefaultObjectValidatorTests.cs (2)

1095Assert.Throws<InvalidTimeZoneException>( 1279var ex = Assert.Throws<InvalidOperationException>(() => validator.Validate(actionContext, validationState, prefix: string.Empty, model));

XmlAssertTest.cs (3)

20var equalException = Assert.Throws<EqualException>(() => XmlAssert.Equal(input1, input2)); 72Assert.Throws<EqualException>(() => XmlAssert.Equal(input1, input2)); 113var equalException = Assert.Throws<EqualException>(() => XmlAssert.Equal(expected, actual));

HtmlLocalizerTest.cs (1)

148var exception = Assert.Throws<FormatException>(

RazorPageActivatorTest.cs (1)

166Assert.Throws<InvalidCastException>(() => activator.Activate(instance, viewContext));

RazorPageTest.cs (2)

665var ex = Assert.Throws<InvalidOperationException>(() => page.EnsureRenderedBodyOrSections()); 704var ex = Assert.Throws<InvalidOperationException>(() => page.EnsureRenderedBodyOrSections());

TagHelpers\UrlResolutionTagHelperTest.cs (1)

380var exception = Assert.Throws<InvalidOperationException>(

InputTagHelperTest.cs (2)

149var ex = Assert.Throws<InvalidOperationException>(() => tagHelper.Process(context, output)); 196var ex = Assert.Throws<InvalidOperationException>(() => tagHelper.Process(context, output));

TagHelperOutputExtensionsTest.cs (2)

1053var exceptionAdd = Assert.Throws<ArgumentException>(() => tagHelperOutput.AddClass(classValue, htmlEncoder)); 1054var exceptionRemove = Assert.Throws<ArgumentException>(() => tagHelperOutput.RemoveClass(classValue, htmlEncoder));

AttributeDictionaryTest.cs (1)

59Assert.Throws<InvalidOperationException>(() => attributes.Add("one", "15"));

Rendering\HtmlHelperPartialExtensionsTest.cs (1)

176var actual = Assert.Throws<InvalidOperationException>(() => partialMethod(helper.Object));

SessionStateTempDataProviderTest.cs (2)

26Assert.Throws<InvalidOperationException>(() => 39Assert.Throws<InvalidOperationException>(() =>

ViewComponents\ViewViewComponentResultTest.cs (3)

175var ex = Assert.Throws<InvalidOperationException>(() => result.Execute(viewComponentContext)); 213var ex = Assert.Throws<InvalidOperationException>(() => result.Execute(viewComponentContext)); 253var ex = Assert.Throws<InvalidOperationException>(() => result.Execute(viewComponentContext));

ViewDataDictionaryTest.cs (2)

141var exception = Assert.Throws<InvalidOperationException>(() => viewData.SetModelPublic(model)); 402var exception = Assert.Throws<InvalidOperationException>(() => viewData.SetModelPublic(value: null));

OwinEnvironmentTests.cs (3)

148Assert.Throws<ArgumentNullException>(() => collection.CopyTo(null, 0)); // array is null 149Assert.Throws<ArgumentOutOfRangeException>(() => collection.CopyTo(kvp, -1)); // arrayIndex is less than 0 150Assert.Throws<ArgumentException>(() => collection.CopyTo(kvp, 1)); // The number of elements in the source ICollection<T> is greater than the available space from arrayIndex to the end of the destination array.

Runtime\TagHelpers\TagHelperScopeManagerTest.cs (1)

215var ex = Assert.Throws<InvalidOperationException>(() =>

RequestDecompressionBuilderExtensionsTests.cs (1)

17Assert.Throws<ArgumentNullException>(() =>

RequestDecompressionServiceExtensionsTests.cs (2)

18Assert.Throws<ArgumentNullException>(() => 32Assert.Throws<ArgumentNullException>(() =>

Builder\RequestDelegateEndpointRouteBuilderExtensionsTest.cs (1)

470Assert.Throws<InvalidOperationException>(() => endpointBuilder.Finally(b => b.Metadata.Add(new RouteNameMetadata("Foo"))));

Builder\RouteHandlerEndpointRouteBuilderExtensionsTest.cs (1)

500Assert.Throws<InvalidOperationException>(() => endpointBuilder.Finally(b => b.Metadata.Add(new RouteNameMetadata("Foo"))));

DefaultInlineConstraintResolverTest.cs (1)

290var ex = Assert.Throws<InvalidOperationException>(() => routeOptions.SetParameterPolicy("custom", typeof(string)));

Matching\CandidateSetTest.cs (1)

321var ex = Assert.Throws<InvalidOperationException>(() => candidateSet.ExpandEndpoint(0, Array.Empty<Endpoint>(), comparer));

Matching\DataSourceDependentMatcherTest.cs (1)

225var exception = Assert.Throws<AggregateException>(

Matching\HostMatcherPolicyTest.cs (2)

97Assert.Throws<InvalidOperationException>(() => 189Assert.Throws<InvalidOperationException>(() =>

Patterns\RoutePatternFactoryTest.cs (2)

305Assert.Throws<InvalidOperationException>(() => 608var exception = Assert.Throws<InvalidOperationException>(() =>

Template\RoutePrecedenceTestsBase.cs (2)

101var ex = Assert.Throws<InvalidOperationException>(() => 114var ex = Assert.Throws<InvalidOperationException>(() =>

TemplateParserDefaultValuesTests.cs (1)

108var ex = Assert.Throws<RouteCreationException>(() =>

DelegateTests.cs (2)

88Assert.Throws<InvalidOperationException>(() => delegateFeature.DelegateRequest(destination)); 154Assert.Throws<InvalidOperationException>(() => delegateFeature.DelegateRequest(destination));

Listener\ResponseHeaderTests.cs (5)

305Assert.Throws<InvalidOperationException>(() => 310Assert.Throws<InvalidOperationException>(() => 315Assert.Throws<InvalidOperationException>(() => 320Assert.Throws<InvalidOperationException>(() => 326Assert.Throws<InvalidOperationException>(() =>

RequestBodyLimitTests.cs (2)

190var ex = Assert.Throws<BadHttpRequestException>(() => { var t = httpContext.Request.Body.ReadAsync(input, 0, input.Length); }); 193ex = Assert.Throws<BadHttpRequestException>(() => { var t = httpContext.Request.Body.ReadAsync(input, 0, input.Length); });

ResponseHeaderTests.cs (2)

229Assert.Throws<InvalidOperationException>(() => responseHeaders.Add("Custom3", new string[] { "value3a, value3b", "value3c" })); 260Assert.Throws<InvalidOperationException>(() => responseHeaders.Add("Custom3", new string[] { "value3a, value3b", "value3c" }));

ResponseTests.cs (1)

205Assert.Throws<InvalidTimeZoneException>(() => httpContext.Response.Body.Write(new byte[10], 0, 10));

ResponseTrailersTests.cs (2)

66Assert.Throws<InvalidOperationException>(() => httpContext.Response.AppendTrailer(header, "value")); 128Assert.Throws<InvalidOperationException>(() => httpContext.Response.AppendTrailer("TrailerName", "Trailer Value"));

BodyControlTests.cs (12)

DiagnosticMemoryPoolTests.cs (5)

21var exception = Assert.Throws<InvalidOperationException>(() => memoryPool.Dispose()); 32var exception = Assert.Throws<InvalidOperationException>(() => block.Dispose()); 42var exception = Assert.Throws<InvalidOperationException>(() => block.Dispose()); 217var exception = Assert.Throws<InvalidOperationException>(() => memoryPool.Dispose()); 223var exception = Assert.Throws<AggregateException>(() => memoryPool.Dispose());

Http1\Http1ConnectionTests.cs (1)

325Assert.Throws<InvalidOperationException>(() => ((IHttpResponseFeature)_http1Connection).OnStarting(_ => Task.CompletedTask, null));

HttpParserTests.cs (3)

332Assert.Throws<BadHttpRequestException>(() => VerifyRawHeaders(rawHeaders, expectedHeaderNames, expectedHeaderValues, disableHttp1LineFeedTerminators: true)); 384Assert.Throws<BadHttpRequestException>(() => VerifyRawHeaders(rawHeaders, expectedHeaderNames, expectedHeaderValues, disableHttp1LineFeedTerminators: true)); 586var badHttpRequestException = Assert.Throws<BadHttpRequestException>(() =>

HttpRequestHeadersTests.cs (5)

299Assert.Throws<ArgumentException>(() => headers.Add("host", new[] { "localhost" })); 300Assert.Throws<ArgumentException>(() => headers.Add("custom", new[] { "value" })); 301Assert.Throws<ArgumentException>(() => headers.Add("Content-Length", new[] { "0" })); 562Assert.Throws<InvalidOperationException>((Action)(() => 654Assert.Throws<InvalidOperationException>(() =>

HttpRequestStreamTests.cs (4)

57Assert.Throws<NotSupportedException>(() => stream.SetLength(0)); 72Assert.Throws<NotSupportedException>(() => stream.Write(new byte[1], 0, 1)); 79Assert.Throws<NotSupportedException>(() => stream.WriteByte(0)); 123var ioEx2 = Assert.Throws<InvalidOperationException>(() => stream.CopyTo(Stream.Null));

HttpResponseHeadersTests.cs (16)

HttpResponsePipeWriterTests.cs (6)

19var ex = Assert.Throws<ObjectDisposedException>(() => { pipeWriter.Advance(1); }); 29var ex = Assert.Throws<ObjectDisposedException>(() => { pipeWriter.GetMemory(); }); 39var ex = Assert.Throws<ObjectDisposedException>(() => { pipeWriter.GetSpan(); }); 49var ex = Assert.Throws<ObjectDisposedException>(() => { pipeWriter.Complete(); }); 59var ex = Assert.Throws<ObjectDisposedException>(() => { pipeWriter.FlushAsync(); }); 69var ex = Assert.Throws<ObjectDisposedException>(() => { pipeWriter.WriteAsync(new Memory<byte>()); });

HttpResponseStreamTests.cs (2)

85Assert.Throws<NotSupportedException>(() => stream.SetLength(0)); 123var ioEx = Assert.Throws<InvalidOperationException>(() => stream.Write(new byte[1], 0, 1));

KestrelServerLimitsTests.cs (4)

23Assert.Throws<ArgumentOutOfRangeException>(() => 52Assert.Throws<ArgumentOutOfRangeException>(() => 80Assert.Throws<ArgumentOutOfRangeException>(() => 134Assert.Throws<ArgumentOutOfRangeException>(() =>

KestrelServerTests.cs (5)

55var exception = Assert.Throws<FormatException>(() => StartDummyApplication(server)); 87var ex = Assert.Throws<InvalidOperationException>(() => StartDummyApplication(server)); 126var exception = Assert.Throws<InvalidOperationException>(() => StartDummyApplication(server)); 232var exception = Assert.Throws<InvalidOperationException>(() => StartDummyApplication(server)); 259var exception = Assert.Throws<InvalidOperationException>(() => StartDummyApplication(server));

ThrowingWasUpgradedWriteOnlyStreamTests.cs (2)

22Assert.Equal(CoreStrings.ResponseStreamWasUpgraded, Assert.Throws<InvalidOperationException>(() => stream.Write(new byte[1], 0, 1)).Message); 24Assert.Equal(CoreStrings.ResponseStreamWasUpgraded, Assert.Throws<InvalidOperationException>(() => stream.Flush()).Message);

HttpsConfigurationTests.cs (4)

46Assert.Throws<InvalidOperationException>(host.Run); 73Assert.Throws<InvalidOperationException>(host.Run); 106Assert.Throws<InvalidOperationException>(host.Run); 176Assert.Throws<InvalidOperationException>(host.Run);

KestrelConfigurationLoaderTests.cs (9)

572var ex = Assert.Throws<ArgumentException>(() => 597var ex = Assert.Throws<ArgumentException>(() => 622var ex = Assert.Throws<CryptographicException>(() => 646var ex = Assert.Throws<InvalidOperationException>(() => 775var ex = Assert.Throws<InvalidOperationException>(() => serverOptions.Configure(config).Load()); 784ex = Assert.Throws<InvalidOperationException>(() => serverOptions.Configure(config).Load()); 793ex = Assert.Throws<InvalidOperationException>(() => serverOptions.Configure(config).Load()); 802ex = Assert.Throws<InvalidOperationException>(() => serverOptions.Configure(config).Load()); 811ex = Assert.Throws<InvalidOperationException>(() => serverOptions.Configure(config).Load());

runtime\Http2\HPackDecoderTest.cs (15)

runtime\Http3\QPackDecoderTest.cs (1)

295QPackDecodingException exception = Assert.Throws<QPackDecodingException>(() => _decoder.Decode(encoded, endHeaders: true, handler: _handler));

WebEncodersTests.cs (1)

33Assert.Throws<FormatException>(() =>

Internal\Formatters\BinaryMessageParserTests.cs (1)

68var ex = Assert.Throws<FormatException>(() =>

Internal\Protocol\HandshakeProtocolTests.cs (1)

91var exception = Assert.Throws<InvalidDataException>(() =>

MapSignalRTests.cs (2)

21var ex = Assert.Throws<NotSupportedException>(() => 50var ex = Assert.Throws<InvalidOperationException>(() =>

SpaServicesExtensionsTests.cs (1)

35var exception = Assert.Throws<InvalidOperationException>(

WebApplicationTests.cs (2)

1818Assert.Throws<InvalidOperationException>(() => builder.Services.TryAddSingleton(new Service())); 1820Assert.Throws<InvalidOperationException>(() => builder.Services.TryAddScoped<IService, Service>());

FileBufferingWriteStreamTests.cs (2)

255var exception = Assert.Throws<IOException>(() => bufferingStream.Write(input, 0, input.Length)); 270var exception = Assert.Throws<IOException>(() => bufferingStream.Write(input, 0, input.Length));

HttpRequestStreamReaderTest.cs (4)

346Assert.Throws<ArgumentNullException>(() => 357Assert.Throws<ArgumentOutOfRangeException>(() => 368Assert.Throws<ArgumentException>(() => 381Assert.Throws<ObjectDisposedException>(() =>

HttpResponseStreamWriterTest.cs (4)

734Assert.Throws<ArgumentNullException>(() => 745Assert.Throws<ArgumentOutOfRangeException>(() => 756Assert.Throws<ArgumentException>(() => 769Assert.Throws<ObjectDisposedException>(() =>

MultipartReaderTests.cs (1)

312Assert.Throws<ArgumentOutOfRangeException>(() =>

CommandLineSwitches_Tests.cs (1)

1150Assert.Throws<InitializationException>(() =>

Construction\ConstructionEditing_Tests.cs (31)

Construction\ProjectChooseElement_Tests.cs (9)

29Assert.Throws<InvalidProjectFileException>(() => 47Assert.Throws<InvalidProjectFileException>(() => 64Assert.Throws<InvalidProjectFileException>(() => 83Assert.Throws<InvalidProjectFileException>(() => 107Assert.Throws<InvalidProjectFileException>(() => 126Assert.Throws<InvalidProjectFileException>(() => 146Assert.Throws<InvalidProjectFileException>(() => 169Assert.Throws<InvalidProjectFileException>(() => 237Assert.Throws<InvalidProjectFileException>(() =>

Construction\ProjectExtensionsElement_Tests.cs (3)

47Assert.Throws<InvalidProjectFileException>(() => 64Assert.Throws<InvalidProjectFileException>(() => 98Assert.Throws<ArgumentNullException>(() =>

Construction\ProjectImportElement_Tests.cs (4)

40Assert.Throws<InvalidProjectFileException>(() => 57Assert.Throws<InvalidProjectFileException>(() => 74Assert.Throws<InvalidProjectFileException>(() => 136Assert.Throws<ArgumentException>(() =>

Construction\ProjectImportGroupElement_Tests.cs (5)

179Assert.Throws<InvalidProjectFileException>(() => 199Assert.Throws<InvalidProjectFileException>(() => 219Assert.Throws<InvalidProjectFileException>(() => 238Assert.Throws<InvalidProjectFileException>(() => 346Assert.Throws<ArgumentException>(() =>

Construction\ProjectItemDefinitionElement_Tests.cs (1)

194Assert.Throws<InvalidProjectFileException>(() =>

Construction\ProjectItemDefinitionGroupElement_Tests.cs (1)

36Assert.Throws<InvalidProjectFileException>(() =>

Construction\ProjectItemElement_Tests.cs (20)

Construction\ProjectMetadataElement_Tests.cs (14)

Construction\ProjectOnErrorElement_Tests.cs (9)

70Assert.Throws<InvalidProjectFileException>(() => 96Assert.Throws<InvalidProjectFileException>(() => 119Assert.Throws<InvalidProjectFileException>(() => 138Assert.Throws<InvalidProjectFileException>(() => 159Assert.Throws<InvalidProjectFileException>(() => 179Assert.Throws<InvalidProjectFileException>(() => 199Assert.Throws<InvalidProjectFileException>(() => 232Assert.Throws<ArgumentNullException>(() => 245Assert.Throws<ArgumentException>(() =>

Construction\ProjectOutputElement_Tests.cs (9)

56Assert.Throws<InvalidProjectFileException>(() => 78Assert.Throws<InvalidProjectFileException>(() => 100Assert.Throws<InvalidProjectFileException>(() => 122Assert.Throws<InvalidProjectFileException>(() => 144Assert.Throws<InvalidProjectFileException>(() => 168Assert.Throws<InvalidProjectFileException>(() => 190Assert.Throws<InvalidProjectFileException>(() => 240Assert.Throws<InvalidOperationException>(() => 267Assert.Throws<InvalidOperationException>(() =>

Construction\ProjectPropertyElement_Tests.cs (7)

62Assert.Throws<InvalidProjectFileException>(() => 81Assert.Throws<InvalidProjectFileException>(() => 100Assert.Throws<InvalidProjectFileException>(() => 119Assert.Throws<InvalidProjectFileException>(() => 138Assert.Throws<InvalidProjectFileException>(() => 216Assert.Throws<ArgumentException>(() => 243Assert.Throws<ArgumentNullException>(() =>

Construction\ProjectRootElement_Tests.cs (16)

Construction\ProjectTargetElement_Tests.cs (8)

31Assert.Throws<ArgumentException>(() => 106Assert.Throws<ArgumentNullException>(() => 118Assert.Throws<ArgumentNullException>(() => 130Assert.Throws<ArgumentNullException>(() => 142Assert.Throws<ArgumentNullException>(() => 166Assert.Throws<InvalidProjectFileException>(() => 183Assert.Throws<InvalidProjectFileException>(() => 358var error = Assert.Throws<InvalidProjectFileException>(() =>

Construction\ProjectTaskElement_Tests.cs (5)

86Assert.Throws<InvalidProjectFileException>(() => 172Assert.Throws<ArgumentNullException>(() => 185Assert.Throws<ArgumentException>(() => 198Assert.Throws<ArgumentException>(() => 211Assert.Throws<ArgumentNullException>(() =>

Construction\ProjectUsingTaskElement_Tests.cs (16)

Construction\SolutionFile_Tests.cs (2)

58Assert.Throws<InvalidProjectFileException>(() => 138Assert.Throws<InvalidProjectFileException>(() =>

Construction\UsingTaskBodyElement_Tests.cs (3)

38Assert.Throws<InvalidProjectFileException>(() => 58Assert.Throws<InvalidProjectFileException>(() => 105Assert.Throws<ArgumentNullException>(() =>

Construction\UsingTaskParameterElement_Tests.cs (1)

80Assert.Throws<InvalidProjectFileException>(() =>

Construction\UsingTaskParameterGroup_Tests.cs (2)

107Assert.Throws<InvalidProjectFileException>(() => 119Assert.Throws<InvalidProjectFileException>(() =>

Definition\DefinitionEditing_Tests.cs (10)

Definition\Project_Tests.cs (1)

4274Assert.Throws<InvalidProjectFileException>(() => project.ReevaluateIfNecessary());

Definition\ProjectCollection_Tests.cs (8)

373Assert.Throws<InvalidOperationException>(() => 740Assert.Throws<InvalidOperationException>(() => 755Assert.Throws<InvalidOperationException>(() => 1017Assert.Throws<ArgumentNullException>(() => 1061Assert.Throws<ArgumentNullException>(() => 1073Assert.Throws<ArgumentException>(() => 1121Assert.Throws<ArgumentException>(() => 1133Assert.Throws<InvalidOperationException>(() =>

Definition\ProjectItem_Tests.cs (11)

234Assert.Throws<ArgumentException>(() => 247Assert.Throws<ArgumentException>(() => 260Assert.Throws<InvalidOperationException>(() => 1630Assert.Throws<InvalidProjectFileException>(() => 1913Assert.Throws<InvalidOperationException>(() => 1946Assert.Throws<ArgumentException>(() => 2037Assert.Throws<ArgumentException>(() => 2052Assert.Throws<InvalidOperationException>(() => 2083Assert.Throws<InvalidOperationException>(() => 2114Assert.Throws<InvalidOperationException>(() => 2997var exception = Assert.Throws<InvalidProjectFileException>(() =>

Definition\ProjectItemDefinition_Tests.cs (9)

Definition\ProjectMetadata_Tests.cs (1)

459Assert.Throws<InvalidOperationException>(() =>

Definition\ProjectProperty_Tests.cs (2)

136Assert.Throws<InvalidOperationException>(() => 259Assert.Throws<InvalidOperationException>(() =>

Definition\ProtectImports_Tests.cs (12)

Instance\ProjectInstance_Tests.cs (6)

155Assert.Throws<ArgumentNullException>(() => 167Assert.Throws<ArgumentException>(() => 179Assert.Throws<ArgumentNullException>(() => 344Assert.Throws<ArgumentNullException>(() => 356Assert.Throws<ArgumentNullException>(() => 368Assert.Throws<ArgumentNullException>(() =>

Instance\ProjectItemInstance_Tests.cs (5)

227Assert.Throws<ArgumentException>(() => 239Assert.Throws<ArgumentNullException>(() => 301Assert.Throws<ArgumentNullException>(() => 313Assert.Throws<ArgumentException>(() => 735Assert.Throws<InvalidProjectFileException>(() =>

Instance\ProjectPropertyInstance_Tests.cs (1)

69Assert.Throws<ArgumentNullException>(() =>

ObjectModelRemoting\LinkedEvaluationModify_Tests.cs (4)

166Assert.Throws<ArgumentException>(() => 183Assert.Throws<ArgumentException>(() => 203Assert.Throws<ArgumentException>(() => 221Assert.Throws<ArgumentException>(() =>

AssemblyNameEx_Tests.cs (2)

327Assert.Throws<FileLoadException>(() => 339Assert.Throws<FileLoadException>(() =>

BackEnd\AssemblyTaskFactory_Tests.cs (8)

56Assert.Throws<ArgumentNullException>(() => 68Assert.Throws<InvalidProjectFileException>(() => 80Assert.Throws<InvalidProjectFileException>(() => 92Assert.Throws<InvalidProjectFileException>(() => 106Assert.Throws<InternalErrorException>(() => 120Assert.Throws<InternalErrorException>(() => 152Assert.Throws<InvalidProjectFileException>(() => 163Assert.Throws<InvalidProjectFileException>(() =>

BackEnd\BatchingEngine_Tests.cs (2)

161Assert.Throws<InvalidProjectFileException>(() => 198Assert.Throws<InvalidProjectFileException>(() =>

BackEnd\BuildEventArgTransportSink_Tests.cs (2)

41Assert.Throws<InternalErrorException>(() => 52Assert.Throws<InternalErrorException>(() =>

BackEnd\BuildManager_Tests.cs (6)

113Assert.Throws<ArgumentNullException>(() => { new BuildParameters(null); }); 1139Assert.Throws<InvalidOperationException>(() => 1178Assert.Throws<InvalidOperationException>(() => _buildManager.BeginBuild(new BuildParameters())); 1209Assert.Throws<InvalidOperationException>(() => _buildManager.EndBuild()); 1250Assert.Throws<InvalidOperationException>(() => { _buildManager.Build(new BuildParameters(), data); }); 1312Assert.Throws<InvalidOperationException>(() => _buildManager.EndBuild());

BackEnd\BuildRequest_Tests.cs (3)

30Assert.Throws<ArgumentNullException>(() => 99Assert.Throws<InternalErrorException>(() => 109Assert.Throws<InternalErrorException>(() =>

BackEnd\BuildRequestConfiguration_Tests.cs (8)

42Assert.Throws<ArgumentNullException>(() => 50Assert.Throws<ArgumentNullException>(() => 64Assert.Throws<InternalErrorException>(() => 88Assert.Throws<ArgumentNullException>(() => 97Assert.Throws<ArgumentNullException>(() => 137Assert.Throws<InternalErrorException>(() => 497var exception = Assert.Throws<InternalErrorException>( 507var exception = Assert.Throws<InternalErrorException>(

BackEnd\BuildRequestEntry_Tests.cs (5)

35Assert.Throws<ArgumentNullException>(() => 179Assert.Throws<InternalErrorException>(() => 195Assert.Throws<InternalErrorException>(() => 212Assert.Throws<InternalErrorException>(() => 236Assert.Throws<InternalErrorException>(() =>

BackEnd\BuildResult_Tests.cs (8)

62Assert.Throws<NullReferenceException>(() => 137Assert.Throws<KeyNotFoundException>(() => 148Assert.Throws<KeyNotFoundException>(() => 160Assert.Throws<ArgumentNullException>(() => 171Assert.Throws<ArgumentNullException>(() => 182Assert.Throws<ArgumentNullException>(() => 217Assert.Throws<ArgumentNullException>(() => 230Assert.Throws<InternalErrorException>(() =>

BackEnd\CentralForwardingLogger_Tests.cs (2)

55Assert.Throws<InternalErrorException>(() => 68Assert.Throws<InternalErrorException>(() =>

BackEnd\ConfigurationMetadata_Tests.cs (2)

38Assert.Throws<ArgumentNullException>(() => 50Assert.Throws<ArgumentNullException>(() =>

BackEnd\EventRedirectorToSink_Tests.cs (3)

24Assert.Throws<InternalErrorException>(() => 37Assert.Throws<InternalErrorException>(() => 82Assert.Throws<InternalErrorException>(() =>

BackEnd\EventSourceSink_Tests.cs (1)

125Assert.Throws<InternalErrorException>(() =>

BackEnd\FullyQualifiedBuildRequest_Tests.cs (2)

31Assert.Throws<ArgumentNullException>(() => 40Assert.Throws<ArgumentNullException>(() =>

BackEnd\IntrinsicTask_Tests.cs (10)

BackEnd\LoggingContext_Tests.cs (1)

60Assert.Throws<InternalErrorException>(() =>

BackEnd\LoggingService_Tests.cs (15)

BackEnd\LoggingServicesLogMethod_Tests.cs (33)

BackEnd\Lookup_Tests.cs (1)

1012Assert.Throws<InternalErrorException>(() =>

BackEnd\NodeEndpointInProc_Tests.cs (2)

186Assert.Throws<ArgumentNullException>(() => 196Assert.Throws<ArgumentNullException>(() =>

BackEnd\NodePackets_Tests.cs (1)

35Assert.Throws<InternalErrorException>(() =>

BackEnd\OnError_Tests.cs (1)

556Assert.Throws<InvalidProjectFileException>(() =>

BackEnd\ResultsCache_Tests.cs (1)

141Assert.Throws<InternalErrorException>(() =>

BackEnd\TargetEntry_Tests.cs (5)

80Assert.Throws<ArgumentNullException>(() => 95Assert.Throws<ArgumentNullException>(() => 109Assert.Throws<ArgumentNullException>(() => 136Assert.Throws<InternalErrorException>(() => 150Assert.Throws<InternalErrorException>(() =>

BackEnd\TargetResult_Tests.cs (1)

53Assert.Throws<ArgumentNullException>(() =>

BackEnd\TaskExecutionHost_Tests.cs (7)

157Assert.Throws<InvalidProjectFileException>(() => 490Assert.Throws<InvalidProjectFileException>(() => 640Assert.Throws<IndexOutOfRangeException>(() => 930Assert.Throws<InvalidProjectFileException>(() => 941Assert.Throws<InvalidProjectFileException>(() => 952Assert.Throws<InvalidProjectFileException>(() => 979Assert.Throws<InvalidProjectFileException>(() =>

BackEnd\TaskHost_Tests.cs (8)

236Assert.Throws<ArgumentNullException>(() => 247Assert.Throws<ArgumentNullException>(() => 258Assert.Throws<ArgumentNullException>(() => 269Assert.Throws<ArgumentNullException>(() => 765Assert.Throws<ArgumentOutOfRangeException>(() => 770Assert.Throws<ArgumentOutOfRangeException>(() => 805Assert.Throws<ArgumentOutOfRangeException>(() => 810Assert.Throws<ArgumentOutOfRangeException>(() =>

BackEnd\TaskHostConfiguration_Tests.cs (3)

40Assert.Throws<InternalErrorException>(() => 75Assert.Throws<InternalErrorException>(() => 110Assert.Throws<InternalErrorException>(() =>

BackEnd\TaskRegistry_Tests.cs (8)

1375Assert.Throws<InvalidProjectFileException>(() => 1417Assert.Throws<InvalidProjectFileException>(() => 1459Assert.Throws<InvalidProjectFileException>(() => 1481Assert.Throws<InvalidProjectFileException>(() => 1552Assert.Throws<InvalidProjectFileException>(() => 1600Assert.Throws<InvalidProjectFileException>(() => 1647Assert.Throws<InvalidProjectFileException>(() => 1807Assert.Throws<InvalidProjectFileException>(() =>

Collections\MSBuildNameIgnoreCaseComparer_Tests.cs (3)

83Assert.Throws<InternalErrorException>(() => 94Assert.Throws<InternalErrorException>(() => 105Assert.Throws<InternalErrorException>(() =>

Collections\OMcollections_tests.cs (1)

241Assert.Throws<InternalErrorException>(() =>

Construction\ElementLocation_Tests.cs (6)

212Assert.Throws<InternalErrorException>(() => 223Assert.Throws<InternalErrorException>(() => 350Assert.Throws<InvalidOperationException>(() => 370Assert.Throws<InvalidOperationException>(() => 387Assert.Throws<InvalidOperationException>(() => 406Assert.Throws<InvalidOperationException>(() =>

Construction\SolutionProjectGenerator_Tests.cs (1)

2304Assert.Throws<InvalidProjectFileException>(() =>

CopyOnWriteDictionary_Tests.cs (1)

46Assert.Throws<KeyNotFoundException>(() =>

Definition\ItemDefinitionGroup_Tests.cs (7)

163Assert.Throws<InvalidProjectFileException>(() => 192Assert.Throws<InvalidProjectFileException>(() => 220Assert.Throws<InvalidProjectFileException>(() => 812Assert.Throws<InvalidProjectFileException>(() => 831Assert.Throws<InvalidProjectFileException>(() => 847Assert.Throws<InvalidProjectFileException>(() => 1059Assert.Throws<InvalidProjectFileException>(() =>

Definition\Toolset_Tests.cs (3)

26Assert.Throws<ArgumentNullException>(() => 35Assert.Throws<ArgumentNullException>(() => 44Assert.Throws<ArgumentException>(() =>

Definition\ToolsetConfigurationReader_Tests.cs (9)

Definition\ToolsVersion_Tests.cs (1)

404Assert.Throws<InvalidProjectFileException>(() =>

Evaluation\Evaluator_Tests.cs (4)

990InvalidProjectFileException ex = Assert.Throws<InvalidProjectFileException>(() => 1065Assert.Throws<InvalidProjectFileException>(() => 3158Assert.Throws<InvalidProjectFileException>(() => 4570InvalidProjectFileException ex = Assert.Throws<InvalidProjectFileException>(() =>

Evaluation\Expander_Tests.cs (15)

Evaluation\ProjectRootElementCache_Tests.cs (2)

50Assert.Throws<InternalErrorException>(() => 61Assert.Throws<InternalErrorException>(() =>

Evaluation\ProjectSdkImplicitImport_Tests.cs (2)

296InvalidProjectFileException exception = Assert.Throws<InvalidProjectFileException>(() => 412InvalidProjectFileException exception = Assert.Throws<InvalidProjectFileException>(() =>

FileLogger_Tests.cs (4)

84Assert.Throws<LoggerException>(() => 172Assert.Throws<LoggerException>(() => 186Assert.Throws<LoggerException>(() => 531Assert.Throws<LoggerException>(() =>

FileUtilities_Tests.cs (12)

156Assert.Throws<InvalidOperationException>(() => 167Assert.Throws<InvalidOperationException>(() => 294Assert.Throws<ArgumentException>(() => 425Assert.Throws<PathTooLongException>(() => 450Assert.Throws<ArgumentNullException>(() => 459Assert.Throws<ArgumentException>(() => 468Assert.Throws<ArgumentException>(() => 477Assert.Throws<ArgumentException>(() => 486Assert.Throws<ArgumentException>(() => 529Assert.Throws<ArgumentException>(() => 860Assert.Throws<IOException>(() => 874Assert.Throws<IOException>(() =>

Instance\HostServices_Tests.cs (6)

60Assert.Throws<ArgumentNullException>(() => 73Assert.Throws<ArgumentNullException>(() => 86Assert.Throws<ArgumentNullException>(() => 217Assert.Throws<InvalidOperationException>(() => 232Assert.Throws<InvalidOperationException>(() => 274Assert.Throws<InvalidOperationException>(() =>

Utilities_Tests.cs (2)

150Assert.Throws<InvalidProjectFileException>(() => 167Assert.Throws<InvalidProjectFileException>(() =>

AssemblyNameEx_Tests.cs (2)

327Assert.Throws<FileLoadException>(() => 339Assert.Throws<FileLoadException>(() =>

CommandLineBuilderExtension_Tests.cs (1)

28Assert.Throws<ArgumentException>(() =>

FileStateTests.cs (3)

23Assert.Throws<ArgumentException>(() => 44Assert.Throws<ArgumentException>(() => { var time = state.LastWriteTime; }); 393Assert.Throws<FileNotFoundException>(() =>

GetInstalledSDKLocations_Tests.cs (2)

170Assert.Throws<ArgumentNullException>(() => 184Assert.Throws<ArgumentNullException>(() =>

ResolveSDKReference_Tests.cs (2)

1435Assert.Throws<ArgumentNullException>(() => 1451Assert.Throws<ArgumentNullException>(() =>

StreamMappedString_Tests.cs (4)

135Assert.Throws<ArgumentOutOfRangeException>(() => 221Assert.Throws<ArgumentOutOfRangeException>(() => 234Assert.Throws<ArgumentOutOfRangeException>(() => 246Assert.Throws<ArgumentOutOfRangeException>(() =>

ToolTaskExtension_Tests.cs (1)

58Assert.Throws<ArgumentException>(() =>

XslTransformation_Tests.cs (1)

606Assert.Throws<System.ArgumentNullException>(() =>

ObjectModelHelpers.cs (1)

1919Assert.Throws<InvalidOperationException>(method);

MuxLogger_Tests.cs (1)

69Assert.Throws<InvalidOperationException>(() =>

Workspaces\WorkspaceTests_EditorFeatures.cs (5)

136Assert.Throws<ArgumentException>(() => workspace.OnProjectRemoved(project.Id)); 150Assert.Throws<ArgumentException>(() => workspace.OnProjectRemoved(project2.Id)); 267Assert.Throws<ArgumentException>(() => workspace.OnProjectReferenceAdded(project1.Id, new ProjectReference(project2.Id))); 306Assert.Throws<ArgumentException>(() => workspace.OnProjectReferenceAdded(project1.Id, new ProjectReference(project2.Id))); 345Assert.Throws<ArgumentException>(() => workspace.OnProjectReferenceAdded(project2.Id, new ProjectReference(project1.Id)));

Semantics\AccessCheckTests.cs (6)

767Assert.Throws<ArgumentNullException>(() => { compilation.IsSymbolAccessibleWithin(classA, nullSymbol); }); 768Assert.Throws<ArgumentNullException>(() => { compilation.IsSymbolAccessibleWithin(nullSymbol, classA); }); 769Assert.Throws<ArgumentException>(() => { compilation.IsSymbolAccessibleWithin(classA, pubField); }); 861Assert.Throws<ArgumentException>(() => { compilation.IsSymbolAccessibleWithin(classA, classOther); }); 945Assert.Throws<ArgumentException>(() => { compilation3.IsSymbolAccessibleWithin(Outer, InOtherCompilation); }); 946Assert.Throws<ArgumentException>(() => { compilation3.IsSymbolAccessibleWithin(Outer, InFriendCompilation); });

Semantics\SyntaxTreeRootTests.cs (5)

113Assert.Throws<InvalidCastException>(() => { var _ = (CSharpSyntaxTree)(Object)tree.GetCompilationUnitRoot(); }); 114Assert.Throws<ArgumentNullException>(() => { tree.GetDiagnostics((CSharpSyntaxNode)null); }); 115Assert.Throws<InvalidOperationException>(() => { tree.GetDiagnostics(default(SyntaxToken)); }); 116Assert.Throws<ArgumentNullException>(() => { tree.GetDiagnostics((SyntaxNode)null); }); 117Assert.Throws<InvalidOperationException>(() => { tree.GetDiagnostics(default(SyntaxTrivia)); });

SourceGeneration\SyntaxAwareGeneratorTests.cs (4)

188Assert.Throws<InvalidOperationException>(() => 196Assert.Throws<InvalidOperationException>(() => 204Assert.Throws<InvalidOperationException>(() => 212Assert.Throws<InvalidOperationException>(() =>

Compilation\CompilationAPITests.cs (19)

Compilation\ReferenceManagerTests.cs (1)

1327Assert.Throws<TestException>(() => { var a = c.Assembly; });

Compilation\SemanticModelAPITests.cs (1)

647Assert.Throws<ArgumentException>(() =>

Compilation\SymbolSearchTests.cs (8)

20Assert.Throws<ArgumentException>(() => 26Assert.Throws<ArgumentException>(() => 32Assert.Throws<ArgumentException>(() => 38Assert.Throws<ArgumentException>(() => 48Assert.Throws<ArgumentNullException>(() => 54Assert.Throws<ArgumentNullException>(() => 64Assert.Throws<ArgumentNullException>(() => 70Assert.Throws<ArgumentNullException>(() =>

LexicalAndXml\SyntaxTokenParserTests.cs (1)

206Assert.Throws<ArgumentOutOfRangeException>(() => parser.SkipForwardTo(0));

Syntax\StructuredTriviaTests.cs (3)

197Assert.Throws<System.ArgumentOutOfRangeException>(delegate 202Assert.Throws<System.ArgumentOutOfRangeException>(delegate 208Assert.Throws<System.ArgumentOutOfRangeException>(delegate

Syntax\SyntaxNodeTests.cs (1)

3624Assert.Throws<System.ArgumentNullException>(delegate

MetadataShadowCopyProviderTests.cs (6)

63Assert.Throws<ArgumentNullException>(() => _provider.SuppressShadowCopy(null)); 64Assert.Throws<ArgumentException>(() => _provider.SuppressShadowCopy("c:goo.dll")); 65Assert.Throws<ArgumentException>(() => _provider.SuppressShadowCopy("bar.dll")); 66Assert.Throws<ArgumentException>(() => _provider.SuppressShadowCopy(@"\bar.dll")); 67Assert.Throws<ArgumentException>(() => _provider.SuppressShadowCopy(@"../bar.dll")); 161Assert.Throws<IOException>(() => File.Delete(sc));

AnalyzerAssemblyLoaderTests.cs (1)

1501Assert.Throws<UnauthorizedAccessException>(() => File.Delete(testFixture.Delta1));

Collections\HashSet\ISet_Generic_Tests`1.cs (8)

Collections\IdentifierCollectionTests.cs (2)

81Assert.Throws<NotSupportedException>(() => collection.Add("x")); 83Assert.Throws<NotSupportedException>(() => collection.Clear());

Collections\ImmutableDictionaryTestBase.cs (6)

131Assert.Throws<NotSupportedException>(() => dictionary.Add(new KeyValuePair<string, int>())); 133Assert.Throws<NotSupportedException>(() => dictionary.Clear()); 157Assert.Throws<NotSupportedException>(() => dictionary.Add("a", 1)); 168Assert.Throws<NotSupportedException>(() => dictionary.Add("a", 1)); 169Assert.Throws<NotSupportedException>(() => dictionary.Remove("a")); 171Assert.Throws<NotSupportedException>(() => dictionary.Clear());

Collections\ImmutableDictionaryTestBase.nonnetstandard.cs (3)

57Assert.Throws<NotSupportedException>(() => map.Add(5, 3)); 290Assert.Throws<NotSupportedException>(() => collection.Add(default(T)!)); 291Assert.Throws<NotSupportedException>(() => collection.Clear());

Collections\ImmutableSegmentedListTest.cs (8)

Collections\ImmutableSetTest.cs (6)

173Assert.Throws<NotSupportedException>(() => set.ExceptWith(null!)); 174Assert.Throws<NotSupportedException>(() => set.UnionWith(null!)); 175Assert.Throws<NotSupportedException>(() => set.IntersectWith(null!)); 176Assert.Throws<NotSupportedException>(() => set.SymmetricExceptWith(null!)); 183Assert.Throws<NotSupportedException>(() => set.Add(1)); 184Assert.Throws<NotSupportedException>(() => set.Clear());

Collections\List\ICollection.Generic.Tests.cs (8)

284Assert.Throws<NotSupportedException>(() => collection.Add(CreateT(0))); 317Assert.Throws<NotSupportedException>(() => collection.Clear()); 334Assert.Throws<NotSupportedException>(() => collection.Clear()); 335Assert.Throws<NotSupportedException>(() => collection.Clear()); 336Assert.Throws<NotSupportedException>(() => collection.Clear()); 483Assert.Throws<ArgumentNullException>(() => collection.CopyTo(null!, 0)); 492Assert.Throws<ArgumentOutOfRangeException>(() => collection.CopyTo(array, -1)); 493Assert.Throws<ArgumentOutOfRangeException>(() => collection.CopyTo(array, int.MinValue));

Collections\List\ICollection.NonGeneric.Tests.cs (5)

182Assert.Throws<ArgumentNullException>(() => collection.CopyTo(null!, 0)); 252Assert.Throws<ArgumentOutOfRangeException>(() => collection.CopyTo(array, -1)); 253Assert.Throws<ArgumentOutOfRangeException>(() => collection.CopyTo(array, int.MinValue)); 263Assert.Throws<ArgumentException>(() => collection.CopyTo(array, count)); 286Assert.Throws<ArgumentException>(() => collection.CopyTo(array, 1));

Collections\List\IEnumerable.Generic.Tests.cs (8)

184Assert.Throws<InvalidOperationException>( 728Assert.Throws<NotSupportedException>(() => enumerator.Reset()); 745Assert.Throws<InvalidOperationException>(() => enumerator.Reset()); 788Assert.Throws<InvalidOperationException>(() => enumerator.Reset()); 832Assert.Throws<InvalidOperationException>(() => enumerator.Reset()); 870Assert.Throws<NotSupportedException>( 887Assert.Throws<NotSupportedException>( 903Assert.Throws<NotSupportedException>(

Collections\List\IEnumerable.NonGeneric.Tests.cs (4)

366Assert.Throws<NotSupportedException>(() => enumerator.Reset()); 381Assert.Throws<InvalidOperationException>(() => enumerator.Reset()); 407Assert.Throws<InvalidOperationException>(() => enumerator.Reset()); 430Assert.Throws<InvalidOperationException>(() => enumerator.Reset());

Collections\List\IList.Generic.Tests.cs (10)

Collections\List\IList.NonGeneric.Tests.cs (7)

544Assert.Throws<NotSupportedException>(() => collection.Clear()); 766Assert.Throws<NotSupportedException>(() => list.Insert(count / 2, CreateT(321432))); 854Assert.Throws<ArgumentException>(() => list.Insert(count / 2, value)); 870Assert.Throws<NotSupportedException>(() => collection.Remove(CreateT(34543))); 908Assert.Throws<ArgumentException>(() => list.Remove(value)); 999Assert.Throws<ArgumentException>(() => collection.Remove(value)); 1044Assert.Throws<NotSupportedException>(() => list.RemoveAt(count / 2));

Collections\List\SegmentedList.Generic.Tests.Misc.cs (1)

115Assert.Throws<ArgumentOutOfRangeException>(() => _ilist.Insert(bad[i], items[0])); //"ArgumentOutOfRangeException expected."

Collections\TestExtensionsMethods.cs (1)

20Assert.Throws<NullReferenceException>(a);

FileLinePositionSpanTests.cs (3)

35Assert.Throws<ArgumentNullException>( 41Assert.Throws<ArgumentException>( 47Assert.Throws<ArgumentException>(

LinePositionTests.cs (2)

31Assert.Throws<ArgumentOutOfRangeException>( 38Assert.Throws<ArgumentOutOfRangeException>(

MetadataReferences\AssemblyIdentityTests.cs (1)

81Assert.Throws<ArgumentNullException>(() => { AssemblyIdentity.FromAssemblyDefinition(asm); });

MetadataReferences\ModuleMetadataTests.cs (4)

24Assert.Throws<ArgumentOutOfRangeException>(() => { fixed (byte* ptr = new byte[] { 1, 2, 3 }) ModuleMetadata.CreateFromMetadata((IntPtr)ptr, 0); }); 25Assert.Throws<ArgumentOutOfRangeException>(() => { fixed (byte* ptr = new byte[] { 1, 2, 3 }) ModuleMetadata.CreateFromMetadata((IntPtr)ptr, -1); }); 90Assert.Throws<ArgumentOutOfRangeException>(() => { fixed (byte* ptr = new byte[] { 1, 2, 3 }) ModuleMetadata.CreateFromImage((IntPtr)ptr, 0); }); 91Assert.Throws<ArgumentOutOfRangeException>(() => { fixed (byte* ptr = new byte[] { 1, 2, 3 }) ModuleMetadata.CreateFromImage((IntPtr)ptr, -1); });

Text\StringTextTest.cs (1)

84Assert.Throws<IndexOutOfRangeException>(

Text\StringTextTests_Default.cs (1)

50Assert.Throws<IndexOutOfRangeException>(

Text\TextChangeRangeTest.cs (1)

19Assert.Throws<ArgumentOutOfRangeException>(

Text\TextChangeTests.cs (6)

220Assert.Throws<ArgumentOutOfRangeException>(() => newText.CopyTo(-1, destination, 0, 2)); 221Assert.Throws<ArgumentOutOfRangeException>(() => newText.CopyTo(0, destination, -1, 2)); 222Assert.Throws<ArgumentOutOfRangeException>(() => newText.CopyTo(0, destination, 0, -1)); 223Assert.Throws<ArgumentNullException>(() => newText.CopyTo(0, null, 0, 2)); 224Assert.Throws<ArgumentOutOfRangeException>(() => newText.CopyTo(newText.Length - 1, destination, 0, 2)); 225Assert.Throws<ArgumentOutOfRangeException>(() => newText.CopyTo(0, destination, destination.Length - 1, 2));

CodeGen\CodeGenTuples.vb (11)

ObjectFormatterTests.vb (2)

88Assert.Throws(Of ArgumentException)(Sub() primitiveFormatter.TestEscapeStringWithoutQuotes()) 89Assert.Throws(Of ArgumentException)(Sub() primitiveFormatter.TestEscapeCharWithoutQuotes())

PrintOptionsTests.vb (5)

18Assert.Throws(Of ArgumentNullException)(Sub() s_formatter.FormatObject("hello", options:=Nothing)) 23Assert.Throws(Of ArgumentOutOfRangeException)( 32Assert.Throws(Of ArgumentOutOfRangeException)( 41Assert.Throws(Of ArgumentOutOfRangeException)( 46Assert.Throws(Of ArgumentOutOfRangeException)(

FlowAnalysis\IterationJumpYieldStatementTests.vb (1)

1305Xunit.Assert.Throws(Of ArgumentException)(

Semantics\QueryExpressions_FlowAnalysis.vb (2)

897Assert.Throws(Of System.ArgumentException)( 1099Assert.Throws(Of System.ArgumentException)(

VisualStudioMSBuildWorkspaceTests.cs (2)

2204Assert.Throws<NotSupportedException>(delegate 2214Assert.Throws<NotSupportedException>(delegate

CommandLineProject\CommandLineProjectTests.cs (1)

37Assert.Throws<InvalidOperationException>(delegate

ObjectSerializationTests.cs (4)

243Assert.Throws<ArgumentException>(() => TestRoundTripCompressedUint(uint.MaxValue)); // max uint not allowed 244Assert.Throws<ArgumentException>(() => TestRoundTripCompressedUint(0x80000000u)); // highest bit set not allowed 245Assert.Throws<ArgumentException>(() => TestRoundTripCompressedUint(0x40000000u)); // second highest bit set not allowed 246Assert.Throws<ArgumentException>(() => TestRoundTripCompressedUint(0xC0000000u)); // both high bits set not allowed

UtilityTest\AsyncLazyTests.cs (1)

248var thrownException = Assert.Throws<OperationCanceledException>(() =>

DataFrame.IOTests.cs (1)

1079Assert.Throws<ArgumentException>(() => DataFrame.SaveCsv(dataFrame, csvStream, separator: separator, cultureInfo: cultureInfo));

DataFrameTests.cs (7)

78Assert.Throws<ArgumentException>(() => dataFrame.Columns.Insert(2, bigColumn)); 79Assert.Throws<ArgumentException>(() => dataFrame.Columns.Add(bigColumn)); 83Assert.Throws<ArgumentException>(() => dataFrame.Columns.Insert(2, smallColumn)); 84Assert.Throws<ArgumentException>(() => dataFrame.Columns.Add(smallColumn)); 88Assert.Throws<ArgumentException>(() => dataFrame.Columns.Insert(2, repeatedName)); 93Assert.Throws<ArgumentOutOfRangeException>(() => dataFrame.Columns.Insert(columnCount + 1, repeatedName)); 806Assert.Throws<ArgumentException>(() => df.Columns.Insert(1, new Int32DataFrameColumn("Int2", Enumerable.Range(0, 5).Select(x => x))));

TextFieldParserTests.cs (1)

113Assert.Throws<ArgumentException>(() => parser.SetFieldWidths(new[] { -1, -1 }));

SwixPackageTests.cs (1)

28Exception e = Assert.Throws<Exception>(() =>

RemoteExecutorTests.cs (3)

26Assert.Throws<RemoteExecutionException>(() => 51Assert.Throws<RemoteExecutionException>(() => 64Assert.Throws<RemoteExecutionException>(() =>

ExceptionAssertsTests.cs (6)

IdentityAssertsTests.cs (1)

55 Assert.Throws<SameException>(() => Assert.Same(0, 0));

SetAssertsTests.cs (1)

334 var ex = Assert.Throws<SupersetException>(() => Assert.Superset(expectedSuperset, actual));

Utilities\AIJsonUtilitiesTests.cs (11)

RedisCacheSetAndRemoveTests.cs (1)

99Assert.Throws<ArgumentNullException>(() => cache.Set(key, value));

KubernetesProbesOptionsValidatorTests.cs (1)

115Assert.Throws<OptionsValidationException>(action);

Windows\WindowsCountersTests.cs (1)

99Assert.Throws<AggregateException>(() =>

Metrics\MetricCollectorTests.cs (3)

362Assert.Throws<ObjectDisposedException>(() => collector.Clear()); 364Assert.Throws<ObjectDisposedException>(() => collector.RecordObservableInstruments()); 379Assert.Throws<ObjectDisposedException>(() => collector.Clear());

Polly\HttpRetryStrategyOptionsExtensionsTests.cs (3)

18Assert.Throws<ArgumentNullException>(() => ((HttpRetryStrategyOptions)null!).DisableFor(HttpMethod.Get)); 24Assert.Throws<ArgumentNullException>(() => new HttpRetryStrategyOptions().DisableFor(null!)); 37Assert.Throws<ArgumentException>(() => options.DisableFor(HttpMethod.Get));

Resilience\HttpClientBuilderExtensionsTests.Standard.cs (4)

107Assert.Throws<ArgumentNullException>(() => AddStandardResilienceHandler(mode, builder, _validConfigurationSection, options => { })); 117Assert.Throws<ArgumentNullException>(() => AddStandardResilienceHandler(mode, builder, _validConfigurationSection, null!)); 128Assert.Throws<ArgumentNullException>(() => AddStandardResilienceHandler(mode, builder, null!, options => { })); 138Assert.Throws<ArgumentException>(() => AddStandardResilienceHandler(mode, builder, _emptyConfigurationSection, options => { }));

Resilience\HttpResilienceContextExtensionsTests.cs (1)

54Assert.Throws<ArgumentNullException>(() => context.SetRequestMessage(request));

ResourceManagerStringLocalizerTest.cs (1)

194var exception = Assert.Throws<MissingManifestResourceException>(() =>

InitCommandTest.cs (1)

138Assert.Throws<ArgumentException>(() =>

Logging\ExtendedLoggerFactoryTests.cs (2)

25Assert.Throws<ObjectDisposedException>(() => factory.AddProvider(CreateProvider())); 33Assert.Throws<ArgumentNullException>(() => factory.AddProvider(null!));

FakeTimeProviderTests.cs (2)

212Assert.Throws<ArgumentOutOfRangeException>(() => timeProvider.Advance(TimeSpan.FromTicks(-1))); 220Assert.Throws<ArgumentOutOfRangeException>(() => timeProvider.SetUtcNow(timeProvider.GetUtcNow() - TimeSpan.FromTicks(1)));

Infrastructure\DotNetDispatcherTest.cs (4)

42var ex = Assert.Throws<ArgumentException>(() => 64var ex = Assert.Throws<ArgumentException>(() => 587var ex = Assert.Throws<ArgumentException>(() => 610var ex = Assert.Throws<JsonException>(() =>

ColumnInferenceTests.cs (1)

48Assert.Throws<ArgumentException>(new System.Action(() => context.Auto().InferColumns(dataPath, "Junk", groupColumns: false)));

CachingTests.cs (1)

67var ex = Assert.Throws<InvalidOperationException>(() => CacheOnEmptyEstimatorChain());

DatabaseLoaderTests.cs (1)

46var ex = Assert.Throws<System.Reflection.TargetInvocationException>(() => IrisLightGbmImpl(dbs));

ImagesTests.cs (1)

1302Assert.Throws<ArgumentException>(() => image1.Save(imageTempPath));

Scenarios\Api\TestApi.cs (1)

263Assert.Throws<InvalidOperationException>(() => idv.Schema[1].Annotations.GetValue(kindFloat, ref retrievedReadOnlyMemoryVBuffer));

SvmLightTests.cs (5)

236var ex = Assert.Throws<InvalidOperationException>(() => 507var ex = Assert.Throws<InvalidOperationException>(() => 515ex = Assert.Throws<InvalidOperationException>(() => 523ex = Assert.Throws<InvalidOperationException>(() => 531ex = Assert.Throws<InvalidOperationException>(() =>

CacheControlHeaderValueTest.cs (5)

46Assert.Throws<ArgumentException>(() => cacheControl.NoCacheHeaders.Add(null)); 47Assert.Throws<FormatException>(() => cacheControl.NoCacheHeaders.Add("invalid PLACEHOLDER")); 53Assert.Throws<ArgumentException>(() => cacheControl.PrivateHeaders.Add(null)); 54Assert.Throws<FormatException>(() => cacheControl.PrivateHeaders.Add("invalid PLACEHOLDER")); 61Assert.Throws<ArgumentNullException>(() => cacheControl.Extensions.Add(null!));

ContentDispositionHeaderValueTest.cs (1)

59Assert.Throws<ArgumentNullException>(() => contentDisposition.Parameters.Add(null!));

HeaderUtilitiesTest.cs (2)

287Assert.Throws<FormatException>(() => { var actual = HeaderUtilities.EscapeAsQuotedString(input); }); 293Assert.Throws<FormatException>(() => { var actual = HeaderUtilities.EscapeAsQuotedString($"{(char)0x7F}"); });

MediaTypeHeaderValueTest.cs (4)

123Assert.Throws<ArgumentNullException>(() => mediaType.Parameters.Add(null!)); 149Assert.Throws<InvalidOperationException>(() => { mediaType1.MediaType = "some/value"; }); 184Assert.Throws<NotSupportedException>(() => mediaType1.Parameters.Add(new NameValueHeaderValue("name"))); 186Assert.Throws<NotSupportedException>(() => mediaType1.Parameters.Clear());

NameValueHeaderValueTest.cs (5)

89Assert.Throws<InvalidOperationException>(() => { pair1.Value = "othervalue"; }); 122Assert.Throws<InvalidOperationException>(() => { pair1.Value = "othervalue"; }); 145Assert.Throws<FormatException>(() => { var x = new NameValueHeaderValue("name"); x.Value = " x "; }); 146Assert.Throws<FormatException>(() => { var x = new NameValueHeaderValue("name"); x.Value = "x y"; }); 615Assert.Throws<FormatException>(() => header.SetAndEscapeValue(input));

InteractionTests.cs (1)

30_ = Assert.Throws<ArgumentException>(() => Interaction.AppActivate(GetUniqueName())).ToString();

Microsoft\VisualBasic\MyServices\FileSystemProxyTests.cs (18)

Microsoft\VisualBasic\MyServices\RegistryProxyTests.cs (2)

36Assert.Throws<ArgumentException>(() => registry.SetValue(keyName, valueName, "")); 37Assert.Throws<ArgumentException>(() => registry.SetValue(keyName, valueName, "", Win32.RegistryValueKind.String));

CodeModel\FileCodeImportTests.cs (2)

35Assert.Throws<COMException>(() => { var value = import.Name; }); 42Assert.Throws<COMException>(() => { var value = import.FullName; });

Https\ClientCredentialTypeTests.4.1.0.cs (2)

118MessageSecurityException exception = Assert.Throws<MessageSecurityException>(() => 178ArgumentException exception = Assert.Throws<ArgumentException>(() =>

Https\HttpsTests.4.1.0.cs (1)

337Assert.Throws<SecurityNegotiationException>(() => { _ = serviceProxy.Echo(testString); });

Negotiate\NegotiateStream_Http_Tests.4.1.0.cs (1)

85Assert.Throws<System.ServiceModel.ProtocolException>(() => { result = serviceProxy.Echo(testString); });

Tcp\IdentityTests.4.1.1.cs (1)

36var exception = Assert.Throws<MessageSecurityException>(() =>

Tcp\StreamingTests.4.1.0.cs (1)

225Assert.Throws<TimeoutException>(() =>

EmptyCollections\EmptyReadonlyDictionaryTests.cs (3)

37Assert.Throws<NotSupportedException>(() => dict.Add(1, "One")); 48Assert.Throws<NotSupportedException>(() => dict.Add(1, "One")); 60Assert.Throws<NotSupportedException>(() => coll.Add(new KeyValuePair<int, string>(1, "One")));

EmptyCollections\EmptyReadOnlyListTests.cs (1)

57Assert.Throws<NotSupportedException>(() => coll.Add(1));

src\Servers\Kestrel\test\BindTests\AddressRegistrationTests.cs (5)

556var exception = Assert.Throws<IOException>(() => host.Start()); 591var exception = Assert.Throws<IOException>(() => host.Start()); 758Assert.Throws<InvalidOperationException>(() => host.Start()); 783Assert.Throws<InvalidOperationException>(() => host.Start()); 973var exception = Assert.Throws<IOException>(() => host.Start());

mono\System.Drawing\BitmapTests.cs (8)

128Assert.Throws<InvalidOperationException>(() => bmp.SetPixel(0, 0, c)); 137Assert.Throws<InvalidOperationException>(() => bmp.SetPixel(0, 0, c)); 146Assert.Throws<InvalidOperationException>(() => bmp.SetPixel(0, 0, c)); 1148public void SetResolution_Zero() => Assert.Throws<ArgumentException>(() => SetResolution(0.0f, 0.0f)); 1151public void SetResolution_Negative_X() => Assert.Throws<ArgumentException>(() => SetResolution(-1.0f, 1.0f)); 1154public void SetResolution_Negative_Y() => Assert.Throws<ArgumentException>(() => SetResolution(1.0f, -1.0f)); 1163public void SetResolution_NaN() => Assert.Throws<ArgumentException>(() => SetResolution(float.NaN, float.NaN)); 1166public void SetResolution_NegativeInfinity() => Assert.Throws<ArgumentException>(() => SetResolution(float.NegativeInfinity, float.NegativeInfinity));

mono\System.Drawing\GraphicsTests.cs (57)

mono\System.Imaging\MetafileTest.cs (2)

266Assert.Throws<ArgumentNullException>(() => Metafile_StreamEmfType(null, EmfType.EmfOnly)); 280Assert.Throws<ArgumentException>(() => Metafile_StreamEmfType(ms, (EmfType)int.MinValue));

System\Drawing\BitmapTests.cs (4)

909Assert.Throws<InvalidOperationException>(() => bitmap.MakeTransparent(Color.Red)); 933Assert.Throws<InvalidOperationException>(() => bitmap.SetPixel(0, 0, Color.Red)); 1242Assert.Throws<ExternalException>(() => bitmap.UnlockBits(new BitmapData())); 1252Assert.Throws<ExternalException>(() => bitmap.UnlockBits(new BitmapData()));

System\Drawing\BufferedGraphicsContextTests.cs (2)

233Assert.Throws<InvalidOperationException>(context.Dispose); 246Assert.Throws<InvalidOperationException>(context.Dispose);

System\Drawing\Drawing2D\GraphicsPathTests.cs (4)

1066Assert.Throws<ArgumentNullException>(() => 1068Assert.Throws<ArgumentNullException>(() => 1070Assert.Throws<ArgumentNullException>(() => 1072Assert.Throws<ArgumentNullException>(() =>

System\Drawing\Drawing2D\MatrixTests.cs (2)

375Assert.Throws<InvalidOperationException>(() => matrix.Multiply(matrix)); 376Assert.Throws<InvalidOperationException>(() => matrix.Multiply(matrix, MatrixOrder.Prepend));

System\Drawing\FontTests.cs (3)

766Assert.Throws<ArgumentNullException>(() => font.ToLogFont(null)); 767Assert.Throws<ArgumentNullException>(() => font.ToLogFont(null, graphics)); 787Assert.Throws<ArgumentException>(() => font.ToLogFont(new LOGFONT(), graphics));

System\Drawing\Graphics_DrawBezierTests.cs (5)

92Assert.Throws<InvalidOperationException>(() => graphics.DrawBezier(pen, 1, 2, 3, 4, 5, 6, 7, 8)); 93Assert.Throws<InvalidOperationException>(() => graphics.DrawBezier(pen, Point.Empty, Point.Empty, Point.Empty, Point.Empty)); 94Assert.Throws<InvalidOperationException>(() => graphics.DrawBezier(pen, PointF.Empty, PointF.Empty, PointF.Empty, PointF.Empty)); 166Assert.Throws<InvalidOperationException>(() => graphics.DrawBeziers(pen, new Point[2])); 167Assert.Throws<InvalidOperationException>(() => graphics.DrawBeziers(pen, new PointF[2]));

System\Drawing\Graphics_DrawLineTests.cs (6)

72Assert.Throws<InvalidOperationException>(() => graphics.DrawLine(pen, Point.Empty, Point.Empty)); 73Assert.Throws<InvalidOperationException>(() => graphics.DrawLine(pen, 0, 0, 0, 0)); 74Assert.Throws<InvalidOperationException>(() => graphics.DrawLine(pen, PointF.Empty, PointF.Empty)); 75Assert.Throws<InvalidOperationException>(() => graphics.DrawLine(pen, 0f, 0f, 0f, 0f)); 149Assert.Throws<InvalidOperationException>(() => graphics.DrawLines(pen, new Point[2])); 150Assert.Throws<InvalidOperationException>(() => graphics.DrawLines(pen, new PointF[2]));

System\Drawing\GraphicsTests.Core.cs (2)

102Assert.Throws<InvalidOperationException>(() => graphics.DrawRectangle(pen, new RectangleF(0f, 0f, 1f, 1f))); 178Assert.Throws<InvalidOperationException>(() => graphics.FillPie(brush, new RectangleF(0, 0, 1, 1), 0, 90));

System\Drawing\GraphicsTests.cs (54)

System\Drawing\IconTests.cs (11)

453Assert.Throws<ArgumentNullException>(() => icon.Save(null)); 473Assert.Throws<ObjectDisposedException>(() => icon.Save(stream)); 492Assert.Throws<ObjectDisposedException>(() => icon.Save(stream)); 502Assert.Throws<ObjectDisposedException>(() => icon.Save(new MemoryStream())); 786Assert.Throws<ArgumentNullException>(() => { Icon.ExtractIcon(null!, 0, 16); }); 787Assert.Throws<ArgumentNullException>(() => { Icon.ExtractIcon(null!, 0); }); 793Assert.Throws<IOException>(() => { Icon.ExtractIcon(string.Empty, 0, 16); }); 794Assert.Throws<IOException>(() => { Icon.ExtractIcon(string.Empty, 0); }); 804Assert.Throws<ArgumentOutOfRangeException>(() => { Icon.ExtractIcon("Foo", 0, size); }); 810Assert.Throws<IOException>(() => 815Assert.Throws<IOException>(() =>

System\Drawing\ImageTests.cs (4)

150Assert.Throws<ExternalException>(() => bitmap.RemovePropertyItem(PropertyTagChrominanceTable)); 170Assert.Throws<ExternalException>(() => bitmap.RemovePropertyItem(PropertyTagChrominanceTable)); 180Assert.Throws<ExternalException>(() => bitmap.RemovePropertyItem(propid)); 190Assert.Throws<ExternalException>(() => bitmap.RemovePropertyItem(propid));

System\Drawing\Imaging\ImageAttributesTests.cs (10)

1082Assert.Throws<ArgumentNullException>(() => imageAttr.SetOutputChannelColorProfile(null)); 1083Assert.Throws<ArgumentNullException>(() => imageAttr.SetOutputChannelColorProfile(null, ColorAdjustType.Default)); 1090Assert.Throws<ArgumentException>(() => imageAttr.SetOutputChannelColorProfile(string.Empty)); 1091Assert.Throws<ArgumentException>(() => imageAttr.SetOutputChannelColorProfile(string.Empty, ColorAdjustType.Default)); 1098Assert.Throws<OutOfMemoryException>(() => imageAttr.SetOutputChannelColorProfile("invalidPath")); 1099Assert.Throws<OutOfMemoryException>(() => imageAttr.SetOutputChannelColorProfile("invalidPath", ColorAdjustType.Default)); 1107Assert.Throws<PathTooLongException>(() => imageAttr.SetOutputChannelColorProfile(fileNameTooLong)); 1108Assert.Throws<PathTooLongException>(() => imageAttr.SetOutputChannelColorProfile(fileNameTooLong, ColorAdjustType.Default)); 1228Assert.Throws<ArgumentNullException>(() => imageAttr.SetRemapTable(null, ColorAdjustType.Default)); 1315Assert.Throws<NullReferenceException>(() => imageAttr.GetAdjustedPalette(null, ColorAdjustType.Default));

System\Drawing\PenTests.cs (2)

797Assert.Throws<ArgumentNullException>(() => pen.MultiplyTransform(null)); 798Assert.Throws<ArgumentNullException>(() => pen.MultiplyTransform(null, MatrixOrder.Prepend));

System\Drawing\Printing\PreviewPrintControllerTests.cs (1)

111Assert.Throws<NullReferenceException>(() => controller.OnStartPrint(null, new PrintEventArgs()));

System\Drawing\Printing\PrintControllerTests.cs (1)

85Assert.Throws<NullReferenceException>(() => controller.OnStartPrint(null, new PrintEventArgs()));

System\Drawing\RegionTests.cs (5)

419Assert.Throws<InvalidOperationException>(() => region.Complement(region)); 826Assert.Throws<InvalidOperationException>(() => region.Exclude(region)); 1159Assert.Throws<InvalidOperationException>(() => region.Intersect(region)); 1722Assert.Throws<InvalidOperationException>(() => region.Union(region)); 2080Assert.Throws<InvalidOperationException>(() => region.Xor(region));

System\Drawing\StringFormatTests.cs (3)

163Assert.Throws<ArgumentNullException>(() => format.SetTabStops(0, null)); 218Assert.Throws<ArgumentNullException>(() => format.SetMeasurableCharacterRanges(null)); 225Assert.Throws<OverflowException>(() => format.SetMeasurableCharacterRanges(new CharacterRange[33]));

System\Drawing\Text\PrivateFontCollectionTests.cs (2)

107Assert.Throws<FileNotFoundException>(() => fontCollection.AddFontFile("fileName")); 114Assert.Throws<FileNotFoundException>(

ServiceModel\SecurityBindingElementTest.cs (1)

36Assert.Throws<PlatformNotSupportedException>(() =>

ServiceModel\MessageSecurityOverTcpTest.cs (2)

23Assert.Throws <PlatformNotSupportedException>(() => 35Assert.Throws<PlatformNotSupportedException>(() =>

Channels\CommunicationObjectTest.cs (4)

316InvalidOperationException actualException = Assert.Throws<InvalidOperationException>(() => 343InvalidOperationException actualException = Assert.Throws<InvalidOperationException>(() => 368InvalidOperationException actualException = Assert.Throws<InvalidOperationException>(() => 399InvalidOperationException actualException = Assert.Throws<InvalidOperationException>(() =>

Channels\CustomBindingTest.cs (1)

56Assert.Throws<ArgumentException>(() =>

Channels\CustomChannelTest.cs (4)

245InvalidOperationException actualException = Assert.Throws<InvalidOperationException>(() => 299InvalidOperationException actualException = Assert.Throws<InvalidOperationException>(() => 623Assert.Throws<InvalidOperationException>(() => ((IClientChannel)channel).Open()); 676Assert.Throws<InvalidOperationException>(() => ((IClientChannel)channel).DisplayInitializationUI());

Description\OperationContractAttributeTest.cs (2)

30var exception = Assert.Throws<InvalidOperationException>(() => 43var exception = Assert.Throws<InvalidOperationException>(() =>

IdentityModel\SecurityTokenSerializerTest.cs (3)

66Assert.Throws<ArgumentNullException>(() => sts.WriteToken(null, null)); 67Assert.Throws<ArgumentNullException>(() => sts.WriteKeyIdentifier(null, null)); 68Assert.Throws<ArgumentNullException>(() => sts.WriteKeyIdentifierClause(null, null));

ServiceModel\DeliveryRequirementsTest.cs (3)

29Assert.Throws<InvalidOperationException>(() => factory.Open()); 59Assert.Throws<InvalidOperationException>(() => factory.Open()); 68Assert.Throws<InvalidOperationException>(() => factory.Open());

ServiceModel\DuplexChannelFactoryTest.cs (5)

28Assert.Throws<InvalidOperationException>(() => 46Assert.Throws<UriFormatException>(() => 58Assert.Throws<UriFormatException>(() => 103var exception = Assert.Throws<InvalidOperationException>(() => 133Assert.Throws<InvalidOperationException>(() =>

ServiceModel\SynchronizedCollection.cs (6)

96Assert.Throws<ArgumentOutOfRangeException>(() => 101Assert.Throws<ArgumentOutOfRangeException>(() => 106Assert.Throws<ArgumentOutOfRangeException>(() => 111Assert.Throws<ArgumentOutOfRangeException>(() => 118Assert.Throws<ArgumentOutOfRangeException>(() => 123Assert.Throws<ArgumentOutOfRangeException>(() =>

System\ComponentModel\Design\ByteViewerTests.cs (2)

395Assert.Throws<NullReferenceException>(() => control.OnLayout(null)); 587Assert.Throws<NullReferenceException>(() => control.OnPaint(null));

System\ComponentModel\Design\ComponentDesignerTests.cs (4)

2260Assert.Throws<NotImplementedException>(() => designer.InitializeExistingComponent(defaultValues)); 2375Assert.Throws<InvalidOperationException>(() => designer.PreFilterProperties(properties)); 2478Assert.Throws<ArrayTypeMismatchException>(() => designer.PostFilterEvents(new Dictionary<object, object> { { "key", new object() } })); 2906Assert.Throws<ArrayTypeMismatchException>(() => filter.PostFilterEvents(new Dictionary<object, object> { { "key", new object() } }));

System\ComponentModel\Design\DesignerActionMethodItemTests.cs (3)

208Assert.Throws<InvalidOperationException>(item.Invoke); 219Assert.Throws<InvalidOperationException>(item.Invoke); 235Assert.Throws<TargetParameterCountException>(item.Invoke);

System\ComponentModel\Design\DesignerHostTests.cs (25)

System\ComponentModel\Design\DesignSurfaceTests.cs (9)

291Assert.Throws<InvalidOperationException>(() => container.RemoveService(serviceType)); 960Assert.Throws<InvalidOperationException>(() => surface.BeginLoad(typeof(RootDesignerComponent))); 961Assert.Throws<InvalidOperationException>(() => surface.BeginLoad(otherMockLoader.Object)); 970Assert.Throws<ObjectDisposedException>(() => surface.BeginLoad(typeof(RootDesignerComponent))); 971Assert.Throws<ObjectDisposedException>(() => surface.BeginLoad(mockLoader.Object)); 1193Assert.Throws<InvalidOperationException>(surface.Dispose); 1214Assert.Throws<InvalidOperationException>(surface.Dispose); 1295Assert.Throws<InvalidOperationException>(() => surface.Dispose(true)); 1333Assert.Throws<InvalidOperationException>(() => surface.Dispose(true));

System\ComponentModel\Design\ExceptionCollectionTests.cs (3)

54Assert.Throws<SerializationException>(() => formatter.Serialize(stream, collection)); 58Assert.Throws<NotSupportedException>(() => formatter.Serialize(stream, collection)); 66Assert.Throws<PlatformNotSupportedException>(() => collection.GetObjectData(null, default));

System\ComponentModel\Design\Serialization\CodeDomComponentSerializationServiceTests.cs (11)

System\ComponentModel\Design\Serialization\CodeDomSerializerExceptionTests.cs (3)

97Assert.Throws<SerializationException>(() => formatter.Serialize(stream, exception)); 101Assert.Throws<NotSupportedException>(() => formatter.Serialize(stream, exception)); 109Assert.Throws<PlatformNotSupportedException>(() => exception.GetObjectData(null, default));

System\ComponentModel\Design\Serialization\DesignerSerializationManagerTests.cs (4)

387Assert.Throws<InvalidOperationException>(() => iManager.ResolveName += handler); 399Assert.Throws<InvalidOperationException>(() => iManager.SerializationComplete += handler); 1907Assert.Throws<InvalidOperationException>(() => iManager.ReportError(null)); 1979Assert.Throws<InvalidOperationException>(() => iManager.SetName(null, null));

System\ComponentModel\Design\SiteNestedContainerTests.cs (8)

570Assert.Throws<NotImplementedException>(() => container.Add(component)); 571Assert.Throws<NotImplementedException>(() => container.Add(component, "name")); 585Assert.Throws<InvalidOperationException>(() => container.Add(component)); 586Assert.Throws<InvalidOperationException>(() => container.Add(new RootDesignerComponent(), host.RootComponentClassName)); 596Assert.Throws<InvalidOperationException>(() => container.Add(component)); 597Assert.Throws<InvalidOperationException>(() => container.Add(component, "name")); 607Assert.Throws<DivideByZeroException>(() => container.Add(component)); 611Assert.Throws<DivideByZeroException>(() => container.Add(component, "name"));

System\Drawing\Design\ToolboxItemTests.cs (2)

976Assert.Throws<InvalidOperationException>(item.CheckUnlocked); 1444Assert.Throws<InvalidOperationException>(() => item.Initialize(type));

System\Windows\Forms\Design\EventHandlerServiceTests.cs (2)

92Assert.Throws<ArgumentNullException>(() => service.PopHandler(null)); 150Assert.Throws<ArgumentNullException>(() => service.PushHandler(null));

Extensions\AssertExtensions.cs (7)

30Assert.Equal(expectedMessage, Assert.Throws<T>(action).Message); 36Assert.Contains(expectedMessageContent, Assert.Throws<T>(action).Message); 42T exception = Assert.Throws<T>(action); 79T exception = Assert.Throws<T>(action); 89T exception = Assert.Throws<T>(action); 102Assert.Throws<TException>(() => 248Assert.Throws<T>(action);

CheckedListBoxTests.cs (2)

360ArgumentOutOfRangeException ex = Assert.Throws<ArgumentOutOfRangeException>(() => box.SetItemCheckState(index, CheckState.Checked)); 455Assert.Throws<NullReferenceException>(() => control.OnDrawItem(null));

DataStreamFromComStreamTests.cs (1)

17Assert.Throws<IOException>(() => dataStream.Write(new byte[bufferSize], index, count));

ExceptionHandlingTests.cs (1)

19Assert.Throws<InvalidOperationException>(() => action());

System\Resources\ResXResourceReaderTests.cs (4)

21Assert.Throws<PlatformNotSupportedException>(() => 37Assert.Throws<PlatformNotSupportedException>(resourceWriter.Generate); 192ArgumentException exception = Assert.Throws<ArgumentException>(() => { IDictionaryEnumerator enumerator = resXReader.GetEnumerator(); }); 214ArgumentException exception = Assert.Throws<ArgumentException>(() =>

System\Resources\ResXResourceWriterTests.cs (1)

277Assert.Throws<ArgumentNullException>(() =>

System\Windows\Forms\AccessibleObjects\DataGridViewButtonCellAccessibleObjectTests.cs (2)

56Assert.Throws<InvalidOperationException>(() 67Assert.Throws<InvalidOperationException>(accessibleObject.DoDefaultAction);

System\Windows\Forms\AccessibleObjects\DataGridViewCellAccessibleObjectTests.cs (2)

372Assert.Throws<InvalidOperationException>(accessibleObject.DoDefaultAction); 461Assert.Throws<InvalidOperationException>(() => accessibleObject.Select(AccessibleSelection.None));

System\Windows\Forms\AccessibleObjects\DataGridViewCheckBoxCellAccessibleObjectTests.cs (2)

193Assert.Throws<InvalidOperationException>(() 203Assert.Throws<InvalidOperationException>(cell.AccessibilityObject.DoDefaultAction);

System\Windows\Forms\AccessibleObjects\DataGridViewImageCellAccessibleObjectTests.cs (1)

91Assert.Throws<InvalidOperationException>(() =>

System\Windows\Forms\AccessibleObjects\DataGridViewLinkCellAccessibleObjectTests.cs (2)

56Assert.Throws<InvalidOperationException>(() => 66Assert.Throws<InvalidOperationException>(cell.AccessibilityObject.DoDefaultAction);

System\Windows\Forms\AccessibleObjects\DataGridViewRowAccessibleObjectTests.cs (1)

385Assert.Throws<InvalidOperationException>(() => accessibleObject.Select(AccessibleSelection.None));

System\Windows\Forms\ApplicationTests.cs (1)

251Assert.Throws<InvalidOperationException>(() => Application.SetDefaultFont(SystemFonts.CaptionFont));

System\Windows\Forms\AxHost.AxPropertyDescriptorTests.cs (6)

1058Assert.Throws<TargetException>(() => property.SetValue(new object(), "Value")); 1067Assert.Throws<TargetException>(() => property.SetValue(new object(), "Value")); 1110Assert.Throws<ArgumentException>(() => property.SetValue(control, new object())); 1119Assert.Throws<ArgumentException>(() => property.SetValue(control, new object())); 1158Assert.Throws<ArgumentException>(() => property.SetValue(control, new object())); 1167Assert.Throws<ArgumentException>(() => property.SetValue(control, new object()));

System\Windows\Forms\AxHostTests.cs (39)

System\Windows\Forms\BaseCollectionTests.cs (2)

41Assert.Throws<NullReferenceException>(() => collection.CopyTo(Array.Empty<object>(), 0)); 57Assert.Throws<NullReferenceException>(() => collection.CopyTo(Array.Empty<object>(), 0));

System\Windows\Forms\BindingContextTests.cs (1)

744Assert.Throws<NotImplementedException>(() => context.CollectionChanged += handler);

System\Windows\Forms\ButtonBaseTests.cs (4)

5738Assert.Throws<NullReferenceException>(() => control.OnKeyDown(null)); 6018Assert.Throws<NullReferenceException>(() => control.OnKeyUp(null)); 6205Assert.Throws<NullReferenceException>(() => control.OnMouseDown(null)); 6820Assert.Throws<NullReferenceException>(() => control.OnMouseMove(null));

System\Windows\Forms\ButtonTests.cs (2)

2353Assert.Throws<NullReferenceException>(() => control.OnMouseDown(null)); 2865Assert.Throws<NullReferenceException>(() => control.OnMouseUp(null));

System\Windows\Forms\Combobox.ObjectCollectionTests.cs (5)

396Assert.Throws<ArgumentException>(() => comboBoxObjectCollection.AddRange(new string[] { "a", "b" })); 464Assert.Throws<ArgumentException>(comboBoxObjectCollection.Clear); 826Assert.Throws<ArgumentException>(() => comboBoxObjectCollection.Insert(3, 1)); 927Assert.Throws<ArgumentException>(() => comboBoxObjectCollection.RemoveAt(0)); 1072Assert.Throws<ArgumentException>(() => comboBoxObjectCollection.Remove("a"));

System\Windows\Forms\ControlPaintTests.cs (18)

System\Windows\Forms\ControlTests.ControlCollection.cs (8)

System\Windows\Forms\ControlTests.Handlers.cs (4)

2987Assert.Throws<NullReferenceException>(() => control.OnInvalidated(null)); 4170Assert.Throws<ArgumentNullException>(() => control.OnPaintBackground(null)); 4658Assert.Throws<DivideByZeroException>(() => control.OnPrint(eventArgs)); 4726Assert.Throws<DivideByZeroException>(() => control.OnPrint(eventArgs));

System\Windows\Forms\ControlTests.Methods.cs (20)

System\Windows\Forms\ControlTests.Properties.cs (4)

9904Assert.Throws<ArgumentException>(oldValue.MakeEmpty); 9910Assert.Throws<ArgumentException>(oldValue.MakeEmpty); 9963Assert.Throws<ArgumentException>(oldValue.MakeEmpty); 9972Assert.Throws<ArgumentException>(oldValue.MakeEmpty);

System\Windows\Forms\CursorTests.cs (2)

408Assert.Throws<ArgumentException>(() => cursor.Draw(graphics, new Rectangle(Point.Empty, cursor.Size))); 445Assert.Throws<ArgumentException>(() => cursor.DrawStretched(graphics, new Rectangle(Point.Empty, cursor.Size)));

System\Windows\Forms\DataGridViewCellPaintingEventArgsTests.cs (6)

109Assert.Throws<InvalidOperationException>(() => e.Paint(new Rectangle(1, 2, 3, 4), DataGridViewPaintParts.None)); 122Assert.Throws<InvalidOperationException>(() => e.Paint(new Rectangle(1, 2, 3, 4), DataGridViewPaintParts.None)); 159Assert.Throws<InvalidOperationException>(() => e.PaintBackground(new Rectangle(1, 2, 3, 4), true)); 172Assert.Throws<InvalidOperationException>(() => e.PaintBackground(new Rectangle(1, 2, 3, 4), true)); 209Assert.Throws<InvalidOperationException>(() => e.PaintContent(new Rectangle(1, 2, 3, 4))); 222Assert.Throws<InvalidOperationException>(() => e.PaintContent(new Rectangle(1, 2, 3, 4)));

System\Windows\Forms\DataGridViewCellTests.cs (4)

3467Assert.Throws<InvalidOperationException>(cell.DetachEditingControl); 3481Assert.Throws<InvalidOperationException>(cell.DetachEditingControl); 5210Assert.Throws<InvalidOperationException>(() => cell.InitializeEditingControl(-1, null, null)); 6229Assert.Throws<InvalidOperationException>(() => cell.PositionEditingControl(true, true, new Rectangle(1, 2, 3, 4), new Rectangle(1, 2, 3, 4), new DataGridViewCellStyle(), true, true, true, true));

System\Windows\Forms\DataGridViewColumnCollectionTests.cs (1)

423Assert.Throws<InvalidOperationException>(iSupportInitialize.EndInit);

System\Windows\Forms\DataGridViewElementTests.cs (5)

92Assert.Throws<NullReferenceException>(() => element.RaiseCellClick(null)); 144Assert.Throws<NullReferenceException>(() => element.RaiseCellContentClick(null)); 196Assert.Throws<NullReferenceException>(() => element.RaiseCellContentDoubleClick(null)); 248Assert.Throws<NullReferenceException>(() => element.RaiseCellValueChanged(null)); 320Assert.Throws<NullReferenceException>(() => element.RaiseDataError(null));

System\Windows\Forms\DataGridViewHeaderCellTests.cs (5)

4227Assert.Throws<NullReferenceException>(() => cell.OnMouseDown(null)); 4296Assert.Throws<ArgumentOutOfRangeException>(() => cell.OnMouseEnter(rowIndex)); 4364Assert.Throws<ArgumentOutOfRangeException>(() => cell.OnMouseLeave(rowIndex)); 4510Assert.Throws<ArgumentOutOfRangeException>(() => cell.OnMouseUp(e)); 4610Assert.Throws<NullReferenceException>(() => cell.OnMouseUp(null));

System\Windows\Forms\DataGridViewRowPostPaintEventArgsTests.cs (6)

103Assert.Throws<InvalidOperationException>(() => e.DrawFocus(new Rectangle(1, 2, 3, 4), true)); 127Assert.Throws<InvalidOperationException>(() => e.PaintCells(new Rectangle(1, 2, 3, 4), DataGridViewPaintParts.None)); 151Assert.Throws<InvalidOperationException>(() => e.PaintCellsBackground(new Rectangle(1, 2, 3, 4), true)); 175Assert.Throws<InvalidOperationException>(() => e.PaintCellsContent(new Rectangle(1, 2, 3, 4))); 212Assert.Throws<InvalidOperationException>(() => e.PaintHeader(DataGridViewPaintParts.None)); 213Assert.Throws<InvalidOperationException>(() => e.PaintHeader(true));

System\Windows\Forms\DataGridViewRowPrePaintEventArgsTests.cs (6)

130Assert.Throws<InvalidOperationException>(() => e.DrawFocus(new Rectangle(1, 2, 3, 4), true)); 154Assert.Throws<InvalidOperationException>(() => e.PaintCells(new Rectangle(1, 2, 3, 4), DataGridViewPaintParts.None)); 178Assert.Throws<InvalidOperationException>(() => e.PaintCellsBackground(new Rectangle(1, 2, 3, 4), true)); 202Assert.Throws<InvalidOperationException>(() => e.PaintCellsContent(new Rectangle(1, 2, 3, 4))); 239Assert.Throws<InvalidOperationException>(() => e.PaintHeader(DataGridViewPaintParts.None)); 240Assert.Throws<InvalidOperationException>(() => e.PaintHeader(true));

System\Windows\Forms\DataGridViewRowTests.cs (10)

System\Windows\Forms\DataGridViewSelectedCellCollectionTests.cs (6)

94Assert.Throws<NotSupportedException>(collection.Clear); 177Assert.Throws<NotSupportedException>(() => collection.Insert(index, dataGridViewCell)); 306Assert.Throws<NotSupportedException>(iList.Clear); 488Assert.Throws<NotSupportedException>(() => iList.Insert(index, value)); 505Assert.Throws<NotSupportedException>(() => iList.Remove(value)); 517Assert.Throws<NotSupportedException>(() => iList.RemoveAt(index));

System\Windows\Forms\DataGridViewSelectedColumnCollectionTests.cs (6)

106Assert.Throws<NotSupportedException>(collection.Clear); 197Assert.Throws<NotSupportedException>(() => collection.Insert(index, dataGridViewColumn)); 338Assert.Throws<NotSupportedException>(iList.Clear); 536Assert.Throws<NotSupportedException>(() => iList.Insert(index, value)); 553Assert.Throws<NotSupportedException>(() => iList.Remove(value)); 565Assert.Throws<NotSupportedException>(() => iList.RemoveAt(index));

System\Windows\Forms\DataGridViewSelectedRowCollectionTests.cs (6)

91Assert.Throws<NotSupportedException>(collection.Clear); 172Assert.Throws<NotSupportedException>(() => collection.Insert(index, dataGridRow)); 298Assert.Throws<NotSupportedException>(iList.Clear); 476Assert.Throws<NotSupportedException>(() => iList.Insert(index, value)); 493Assert.Throws<NotSupportedException>(() => iList.Remove(value)); 505Assert.Throws<NotSupportedException>(() => iList.RemoveAt(index));

System\Windows\Forms\DataGridViewTests.cs (2)

2313Assert.Throws<NullReferenceException>(() => control.OnColumnHeadersHeightSizeModeChanged(null)); 2794Assert.Throws<NullReferenceException>(() => control.OnRowHeadersWidthSizeModeChanged(null));

System\Windows\Forms\DataGridViewTextBoxEditingControlTests.cs (1)

1431Assert.Throws<InvalidOperationException>(() => control.OnTextChanged(eventArgs));

System\Windows\Forms\ErrorProviderTests.cs (1)

840Assert.Throws<ArgumentException>(() => provider.BindToDataAndErrors(newDataSource, "NoSuchValue"));

System\Windows\Forms\FlowLayoutSettingsTests.cs (1)

249Assert.Throws<NotSupportedException>(() => settings.SetFlowBreak(new object(), value));

System\Windows\Forms\GroupBoxTests.cs (2)

1944Assert.Throws<ArgumentNullException>(() => control.OnPaint(null)); 1956Assert.Throws<NullReferenceException>(() => control.OnPaint(null));

System\Windows\Forms\HtmlDocumentTests.cs (2)

1512COMException ex = Assert.Throws<COMException>(() => document.AttachEventHandler(string.Empty, handler)); 1684Assert.Throws<COMException>(() => document.ExecCommand(command, showUI, value));

System\Windows\Forms\HtmlElementTests.cs (3)

1707COMException ex = Assert.Throws<COMException>(() => element.AttachEventHandler(string.Empty, handler)); 2472Assert.Throws<ArgumentException>(() => element.SetAttribute(null, "value")); 2487COMException ex = Assert.Throws<COMException>(() => element.SetAttribute(string.Empty, "value"));

System\Windows\Forms\ImageList.ImageCollectionTests.cs (9)

System\Windows\Forms\ImageListTests.cs (3)

1024Assert.Throws<NullReferenceException>(() => list.Draw(null, Point.Empty, 0)); 1025Assert.Throws<NullReferenceException>(() => list.Draw(null, 0, 0, 0)); 1026Assert.Throws<NullReferenceException>(() => list.Draw(null, 0, 0, 10, 10, 0));

System\Windows\Forms\Layout\FlowLayoutTests.cs (1)

24Assert.Throws<NotSupportedException>(() => engine.InitLayout("child", BoundsSpecified.All));

System\Windows\Forms\Layout\LayoutEngineTests.cs (1)

21Assert.Throws<NotSupportedException>(() => engine.InitLayout("child", BoundsSpecified.All));

System\Windows\Forms\Layout\TableLayoutSettingsTests.cs (5)

664Assert.Throws<NotSupportedException>(() => settings.SetCellPosition("control", default)); 888Assert.Throws<NotSupportedException>(() => settings.SetColumn("control", 1)); 1120Assert.Throws<NotSupportedException>(() => settings.SetColumnSpan("control", 1)); 1364Assert.Throws<NotSupportedException>(() => settings.SetRow("control", 1)); 1595Assert.Throws<NotSupportedException>(() => settings.SetRowSpan("control", 1));

System\Windows\Forms\ListBox.IntegerCollectionTests.cs (1)

2560Assert.Throws<ArgumentException>(() => collection.Remove(item));

System\Windows\Forms\ListBox.ObjectCollectionTests.cs (19)

System\Windows\Forms\ListBox.SelectedIndexCollectionTests.cs (4)

81Assert.Throws<NotSupportedException>(collection.Clear); 98Assert.Throws<NotSupportedException>(() => collection.Insert(index, value)); 109Assert.Throws<NotSupportedException>(() => collection.Remove(value)); 120Assert.Throws<NotSupportedException>(() => collection.RemoveAt(index));

System\Windows\Forms\ListBox.SelectedObjectCollectionTests.cs (4)

81Assert.Throws<NotSupportedException>(collection.Clear); 98Assert.Throws<NotSupportedException>(() => collection.Insert(index, value)); 109Assert.Throws<NotSupportedException>(() => collection.Remove(value)); 120Assert.Throws<NotSupportedException>(() => collection.RemoveAt(index));

System\Windows\Forms\ListViewGroupCollectionTests.cs (3)

851Assert.Throws<ArgumentException>(() => collection.Insert(0, group)); 1115Assert.Throws<InvalidOperationException>(() => listView.Groups.AddRange(sourceGroup)); 1131Assert.Throws<InvalidOperationException>(() => listView.Groups.Insert(0, new ListViewGroup()));

System\Windows\Forms\NativeWindowTests.cs (4)

165Assert.Throws<NullReferenceException>(() => window.CreateHandle(null)); 178Assert.Throws<InvalidOperationException>(() => window.CreateHandle(cp)); 192Assert.Throws<Win32Exception>(() => window.CreateHandle(cp)); 214Assert.Throws<Win32Exception>(() => window2.CreateHandle(cp2));

System\Windows\Forms\NotifyIconTests.cs (2)

965Assert.Throws<ArgumentException>(() => notifyIcon.ShowBalloonTip(0)); 966Assert.Throws<ArgumentException>(() => notifyIcon.ShowBalloonTip(0, "Title", tipText, ToolTipIcon.Error));

System\Windows\Forms\PictureBoxTests.cs (6)

1963Assert.Throws<InvalidOperationException>(() => pictureBox.Load(null)); 1969Assert.Throws<InvalidOperationException>(() => pictureBox.Load(string.Empty)); 2120Assert.Throws<InvalidOperationException>(pictureBox.Load); 2121Assert.Throws<InvalidOperationException>(() => pictureBox.Load(imageLocation)); 2132Assert.Throws<InvalidOperationException>(pictureBox.LoadAsync); 2133Assert.Throws<InvalidOperationException>(() => pictureBox.LoadAsync(imageLocation));

System\Windows\Forms\ProgressBarTests.cs (2)

1897Assert.Throws<InvalidOperationException>(() => control.Increment(value)); 2553Assert.Throws<InvalidOperationException>(control.PerformStep);

System\Windows\Forms\PropertyGridTests.cs (2)

3743Assert.Throws<NullReferenceException>(() => control.OnMouseDown(null)); 3843Assert.Throws<NullReferenceException>(() => control.OnMouseMove(null));

System\Windows\Forms\PropertyManagerTests.cs (2)

394Assert.Throws<NotSupportedException>(manager.AddNew); 404Assert.Throws<NotSupportedException>(() => manager.RemoveAt(index));

System\Windows\Forms\RadioButtonTests.cs (1)

1270Assert.Throws<NullReferenceException>(() => control.OnMouseUp(null));

System\Windows\Forms\RichTextBoxTests.cs (3)

8780Assert.Throws<ArgumentException>(() => control.LoadFile(stream, fileType)); 8789Assert.Throws<ArgumentException>(() => control.LoadFile(stream, RichTextBoxStreamType.RichText)); 8803Assert.Throws<ArgumentException>(() => control.LoadFile(stream, RichTextBoxStreamType.RichText));

System\Windows\Forms\ScrollableControlTests.cs (1)

1886Assert.Throws<ArgumentNullException>(() => control.OnPaintBackground(null));

System\Windows\Forms\SplitterTests.cs (1)

2175Assert.Throws<NullReferenceException>(() => control.OnMouseDown(null));

System\Windows\Forms\StatusStripTests.cs (2)

1194Assert.Throws<NullReferenceException>(() => control.OnLayout(null)); 1244Assert.Throws<ArgumentNullException>(() => control.OnPaintBackground(null));

System\Windows\Forms\TabControl.ControlCollectionTests.cs (2)

876Assert.Throws<ArgumentException>(() => collection.Add(value)); 884Assert.Throws<ArgumentNullException>(() => collection.Add(null));

System\Windows\Forms\TabControl.TabPageCollectionTests.cs (6)

1292Assert.Throws<InvalidCastException>(() => iList.CopyTo(array, 1)); 2948Assert.Throws<ArgumentOutOfRangeException>(() => collection.Insert(index, value)); 2961Assert.Throws<ArgumentOutOfRangeException>(() => collection.Insert(index, value)); 3143Assert.Throws<ArgumentException>(() => iList.Insert(0, value)); 3179Assert.Throws<ArgumentOutOfRangeException>(() => iList.Insert(index, value)); 3193Assert.Throws<ArgumentOutOfRangeException>(() => iList.Insert(index, value));

System\Windows\Forms\TableLayoutPanelTests.cs (2)

1405Assert.Throws<NullReferenceException>(() => control.OnLayout(null)); 1539Assert.Throws<ArgumentNullException>(() => control.OnPaintBackground(null));

System\Windows\Forms\TableLayoutStyleCollectionTests.cs (2)

107Assert.Throws<ArgumentException>(() => collection.Insert(0, new object())); 217Assert.Throws<ArgumentException>(() => collection.Remove(new object()));

System\Windows\Forms\TabPageTests.cs (1)

4254Assert.Throws<ArgumentNullException>(() => control.OnPaintBackground(null));

System\Windows\Forms\TabPageTests.TabPageControlCollection.cs (1)

107Assert.Throws<ArgumentException>(() => collection.Add(control));

System\Windows\Forms\ToolStripButtonTests.cs (1)

1508Assert.Throws<NullReferenceException>(() => item.OnPaint(null));

System\Windows\Forms\ToolStripContentPanelTests.cs (1)

1887Assert.Throws<NullReferenceException>(() => control.OnPaintBackground(null));

System\Windows\Forms\ToolStripControlHostTests.cs (6)

354TargetInvocationException ex = Assert.Throws<TargetInvocationException>(() => property.ResetValue(item)); 1030TargetInvocationException ex = Assert.Throws<TargetInvocationException>(() => property.ResetValue(item)); 1173TargetInvocationException ex = Assert.Throws<TargetInvocationException>(() => property.ResetValue(item)); 2705Assert.Throws<ObjectDisposedException>(item.Focus); 4415Assert.Throws<ObjectDisposedException>(item.ResetBackColor); 4448Assert.Throws<ObjectDisposedException>(item.ResetForeColor);

System\Windows\Forms\ToolStripDropDownTests.cs (1)

4765Assert.Throws<NullReferenceException>(() => control.OnScroll(null));

System\Windows\Forms\ToolStripSeparatorTests.cs (1)

1348Assert.Throws<NullReferenceException>(() => item.OnPaint(null));

System\Windows\Forms\ToolStripTests.cs (8)

System\Windows\Forms\TreeViewTests.cs (3)

5845Assert.Throws<NullReferenceException>(() => control.OnKeyDown(null)); 5890Assert.Throws<NullReferenceException>(() => control.OnKeyPress(null)); 5937Assert.Throws<NullReferenceException>(() => control.OnKeyUp(null));

System\Windows\Forms\UpDownBaseTests.cs (6)

2041Assert.Throws<NullReferenceException>(() => control.OnMouseDown(null)); 2168Assert.Throws<NullReferenceException>(() => control.OnMouseUp(null)); 2220Assert.Throws<NullReferenceException>(() => control.OnMouseWheel(null)); 2336Assert.Throws<NullReferenceException>(() => control.OnPaint(null)); 2348Assert.Throws<ArgumentNullException>(() => control.OnPaint(null)); 2423Assert.Throws<NullReferenceException>(() => control.OnTextBoxKeyDown(new object(), null));

System\Windows\Forms\VisualStyles\VisualStyleRendererTests.cs (2)

529Assert.Throws<ArgumentException>(() => renderer.SetParameters(element.ClassName, element.Part, element.State)); 557Assert.Throws<ArgumentException>(() => renderer.SetParameters(element));

System\Windows\Forms\WebBrowserTests.cs (21)

System\Windows\Forms\WindowsFormsSynchronizationContextTests.cs (1)

87Assert.Throws<InvalidAsynchronousStateException>(() => context.Send(callback, new object()));

TrackBarTests.cs (1)

2600Assert.Throws<NullReferenceException>(() => control.OnMouseWheel(null));

WebBrowserBaseTests.cs (43)

System\Xaml\Schema\XamlMemberInvokerTests.cs (2)

147Assert.Throws<NotSupportedException>(() => invoker.SetValue(instance, 1)); 154Assert.Throws<NotSupportedException>(() => invoker.SetValue(new object(), "value"));

System\Xaml\Schema\XamlTypeInvokerTests.cs (6)

85Assert.Throws<NotSupportedException>(() => invoker.AddToCollection(new object(), 1)); 92Assert.Throws<NotSupportedException>(() => invoker.AddToCollection(new object(), 1)); 99Assert.Throws<XamlSchemaException>(() => invoker.AddToCollection(new GetEnumeratorClass(), "a")); 135Assert.Throws<NotSupportedException>(() => invoker.AddToDictionary(new object(), 1, 2)); 142Assert.Throws<NotSupportedException>(() => invoker.AddToDictionary(new object(), 1, 2)); 149Assert.Throws<XamlSchemaException>(() => invoker.AddToDictionary(new GetEnumeratorClass(), new object(), "a"));

System\Xaml\XamlBackgroundReaderTests.cs (2)

301Assert.Throws<InvalidOperationException>(() => reader.StartThread()); 316Assert.Throws<ObjectDisposedException>(() => reader.Close());

System\Xaml\XamlDirectiveTests.cs (1)

92Assert.Throws<NotSupportedException>(() => directive.Invoker.SetValue(null, null));

System\Xaml\XamlNodeListTests.cs (8)

System\Xaml\XamlNodeQueueTests.cs (8)

System\Xaml\XamlReaderTests.cs (1)

52Assert.Throws<XamlInternalException>(() => reader.Skip());

System\Xaml\XamlWriterTests.cs (1)

92Assert.Throws<NotImplementedException>(() => writer.WriteNode(reader));

System\ComponentModel\CurrentChangingEventManagerTests.cs (2)

381Assert.Throws<NullReferenceException>(() => CurrentChangingEventManager.AddHandler(null, handler)); 384Assert.Throws<NullReferenceException>(() => CurrentChangingEventManager.RemoveHandler(null, handler));

System\ComponentModel\PropertyChangedEventManagerTests.cs (2)

398Assert.Throws<NullReferenceException>(() => PropertyChangedEventManager.AddHandler(null, handler, "propertyName")); 401Assert.Throws<NullReferenceException>(() => PropertyChangedEventManager.AddHandler(null, handler, "propertyName"));

System\ComponentModel\SortDescriptionCollectionTests.cs (3)

791Assert.Throws<NotSupportedException>(() => collection.Add(new SortDescription("Name", ListSortDirection.Ascending))); 792Assert.Throws<NotSupportedException>(() => collection.Insert(0, new SortDescription("Name", ListSortDirection.Ascending))); 793Assert.Throws<NotSupportedException>(() => collection.Clear());

System\Windows\DependencyObjectTests.cs (19)

System\Windows\DependencyPropertyKeyTests.cs (3)

43Assert.Throws<ArgumentException>(() => key.OverrideMetadata(forType, new PropertyMetadata())); 58Assert.Throws<ArgumentException>(() => key.OverrideMetadata(typeof(int), property.DefaultMetadata)); 65Assert.Throws<ArgumentException>(() => key.OverrideMetadata(typeof(DependencyObject), new PropertyMetadata()));

System\Windows\FreezableTests.cs (85)

System\Windows\Media\MatrixTests.cs (1)

1231Assert.Throws<InvalidOperationException>(() => matrix.Invert());

System\Windows\NameScopeTests.cs (19)

System\Windows\PropertyMetadataTests.cs (1)

507Assert.Throws<InvalidOperationException>(() => metadata.Merge(new PropertyMetadata(), null!));

System\Windows\RectTests.cs (4)

1807Assert.Throws<InvalidOperationException>(() => Rect.Empty.Inflate(0, 0)); 1808Assert.Throws<InvalidOperationException>(() => Rect.Empty.Inflate(new Size(0, 0))); 2752Assert.Throws<InvalidOperationException>(() => Rect.Empty.Offset(0, 0)); 2753Assert.Throws<InvalidOperationException>(() => Rect.Empty.Offset(new Vector(0, 0)));

System\Windows\SplashScreenTests.cs (6)

71Assert.Throws<MissingManifestResourceException>(() => splashScreen.Show(false)); 72Assert.Throws<MissingManifestResourceException>(() => splashScreen.Show(true)); 73Assert.Throws<MissingManifestResourceException>(() => splashScreen.Show(false, false)); 74Assert.Throws<MissingManifestResourceException>(() => splashScreen.Show(false, true)); 75Assert.Throws<MissingManifestResourceException>(() => splashScreen.Show(true, false)); 76Assert.Throws<MissingManifestResourceException>(() => splashScreen.Show(true, true));

System\Windows\Threading\DispatcherPriorityAwaiterTests.cs (5)

131Assert.Throws<ArgumentNullException>(() => awaiter.OnCompleted(null)); 139Assert.Throws<InvalidOperationException>(() => awaiter.OnCompleted(null)); 140Assert.Throws<InvalidOperationException>(() => awaiter.OnCompleted(() => { })); 147Assert.Throws<InvalidOperationException>(() => awaiter.OnCompleted(null)); 148Assert.Throws<InvalidOperationException>(() => awaiter.OnCompleted(() => { }));

System\Windows\Threading\DispatcherTests.cs (1)

83Assert.Throws<InvalidEnumArgumentException>(() => Dispatcher.ValidatePriority(priority, null));

System\Windows\WeakEventManagerTests.cs (14)

System\Windows\WeakEventManagerTTests.cs (7)

189Assert.Throws<NullReferenceException>(() => WeakEventManager<object, EventArgs>.AddHandler(new object(), null, (sender, e) => { })); 192Assert.Throws<NullReferenceException>(() => WeakEventManager<object, EventArgs>.AddHandler(new object(), null, (sender, e) => { })); 213Assert.Throws<ArgumentException>(() => WeakEventManager<object, EventArgs>.AddHandler(source, eventName, handler)); 216Assert.Throws<ArgumentException>(() => WeakEventManager<object, EventArgs>.AddHandler(source, eventName, handler)); 351Assert.Throws<NullReferenceException>(() => WeakEventManager<object, EventArgs>.RemoveHandler(new object(), null, (sender, e) => { })); 372Assert.Throws<ArgumentException>(() => WeakEventManager<object, EventArgs>.RemoveHandler(source, eventName, handler)); 375Assert.Throws<ArgumentException>(() => WeakEventManager<object, EventArgs>.RemoveHandler(source, eventName, handler));

ExceptionAsserts.cs (1)

141 var ex = Throws<T>(testCode);