Throws

AspireWebPubSubExtensionsTests.cs (1)

151var ex = Assert.Throws<InvalidOperationException>(host.Services.GetRequiredService<WebPubSubServiceClient>);

ConformanceTests.cs (2)

249Assert.Throws<InvalidOperationException>(host.Services.GetRequiredService<TService>); 367Assert.Throws<InvalidOperationException>(() =>

AzureBicepResourceTests.cs (3)

162Assert.Throws<InvalidOperationException>(() => bicepResource.GetOutput("resourceEndpoint").Value); 172Assert.Throws<InvalidOperationException>(() => bicepResource.GetSecretOutput("connectionString").Value); 2757var ex = Assert.Throws<ArgumentNullException>(() => provisioningResource.ConfigureInfrastructure(null!));

AzureWebPubSubExtensionsTests.cs (1)

21var ex = Assert.Throws<ArgumentException>(() => wps.AddHub("a_b_c"));

ElasticsearchPublicApiTests.cs (6)

19var exception = Assert.Throws<ArgumentNullException>(action); 31var exception = Assert.Throws<ArgumentNullException>(action); 55var exception = Assert.Throws<ArgumentNullException>(action); 69var exception = Assert.Throws<ArgumentNullException>(action); 83var exception = Assert.Throws<ArgumentNullException>(action); 94var exception = Assert.Throws<ArgumentNullException>(action);

GarnetPublicApiTests.cs (7)

20var exception = Assert.Throws<ArgumentNullException>(action); 32var exception = Assert.Throws<ArgumentNullException>(action); 43var exception = Assert.Throws<ArgumentNullException>(action); 55var exception = Assert.Throws<ArgumentNullException>(action); 68var exception = Assert.Throws<ArgumentNullException>(action); 79var exception = Assert.Throws<ArgumentNullException>(action); 90var exception = Assert.Throws<ArgumentNullException>(action);

KafkaPublicApiTests.cs (9)

KeycloakPublicApiTests.cs (10)

MilvusPublicApiTests.cs (12)

AddMongoDBTests.cs (2)

237Assert.Throws<DistributedApplicationException>(() => db.AddDatabase("db")); 249Assert.Throws<DistributedApplicationException>(() => db.AddDatabase("db"));

MongoDBPublicApiTests.cs (16)

AddMySqlTests.cs (2)

306Assert.Throws<DistributedApplicationException>(() => db.AddDatabase("db")); 318Assert.Throws<DistributedApplicationException>(() => db.AddDatabase("db"));

MySqlPublicApiTests.cs (13)

NatsPublicApiTests.cs (8)

NodeJsPublicApiTests.cs (10)

AddOracleTests.cs (2)

272Assert.Throws<DistributedApplicationException>(() => db.AddDatabase("db")); 284Assert.Throws<DistributedApplicationException>(() => db.AddDatabase("db"));

AddPostgresTests.cs (2)

557Assert.Throws<DistributedApplicationException>(() => db.AddDatabase("db")); 569Assert.Throws<DistributedApplicationException>(() => db.AddDatabase("db"));

PostgrePublicApiTests.cs (17)

PythonPublicApiTests.cs (14)

QdrantPublicApiTests.cs (9)

AddRabbitMQTests.cs (3)

162Assert.Throws<DistributedApplicationException>(rabbitmq.WithManagementPlugin); 176Assert.Throws<DistributedApplicationException>(rabbitmq.WithManagementPlugin); 190Assert.Throws<DistributedApplicationException>(rabbitmq.WithManagementPlugin);

RabbitMQPublicApiTests.cs (9)

RedisPublicApiTests.cs (12)

AddSqlServerTests.cs (2)

205Assert.Throws<DistributedApplicationException>(() => db.AddDatabase("db")); 217Assert.Throws<DistributedApplicationException>(() => db.AddDatabase("db"));

SqlServerPublicApiTests.cs (12)

TestingBuilderTests.cs (1)

176Assert.Throws<InvalidOperationException>(() => app.CreateHttpClient("mywebapp1"));

AddParameterTests.cs (2)

225var ex1 = Assert.Throws<ArgumentException>(() => appBuilder.AddParameter("pass", () => "SomeSecret", publishValueAsDefault: true, secret: true)); 227var ex2 = Assert.Throws<ArgumentException>(() => appBuilder.AddParameter("pass", "SomeSecret", publishValueAsDefault: true, secret: true));

DistributedApplicationBuilderTests.cs (4)

133var ex = Assert.Throws<DistributedApplicationException>(() => appBuilder.AddResource(new ContainerResource("Test"))); 144var ex = Assert.Throws<DistributedApplicationException>(() => appBuilder.AddResource(new ContainerResource("TEST"))); 156var ex = Assert.Throws<DistributedApplicationException>(appBuilder.Build); 168var ex = Assert.Throws<DistributedApplicationException>(appBuilder.Build);

ProjectResourceTests.cs (2)

271var ex = Assert.Throws<DistributedApplicationException>(() => appBuilder.AddProject<TestProject>("projectName")); 280var ex = Assert.Throws<DistributedApplicationException>(() => appBuilder.AddProject<Projects.ServiceA>("projectName", launchProfileName: "not-exist"));

WithEndpointTests.cs (1)

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

AspireKeycloakExtensionTests.cs (4)

29var exception = Assert.Throws<InvalidOperationException>(() => 49var exception = Assert.Throws<InvalidOperationException>(() => 110var exception = Assert.Throws<InvalidOperationException>(() => 130var exception = Assert.Throws<InvalidOperationException>(() =>

EnrichCosmosDbTests.cs (1)

135var exception = Assert.Throws<InvalidOperationException>(host.Services.GetRequiredService<TestDbContext>);

EnrichSqlServerTests.cs (2)

109var exception = Assert.Throws<InvalidOperationException>(host.Services.GetRequiredService<TestDbContext>); 304var exception = Assert.Throws<InvalidOperationException>(host.Services.GetRequiredService<TestDbContext>);

EnrichNpgsqlTests.cs (2)

112var exception = Assert.Throws<InvalidOperationException>(host.Services.GetRequiredService<TestDbContext>); 315var exception = Assert.Throws<InvalidOperationException>(host.Services.GetRequiredService<TestDbContext>);

AspireOpenAIExtensionsTests.cs (1)

103var exception = Assert.Throws<InvalidOperationException>(host.Services.GetRequiredService<OpenAIClient>);

EnrichOracleDatabaseTests.cs (2)

110var exception = Assert.Throws<InvalidOperationException>(host.Services.GetRequiredService<TestDbContext>); 305var exception = Assert.Throws<InvalidOperationException>(host.Services.GetRequiredService<TestDbContext>);

EnrichMySqlTests.cs (2)

123var exception = Assert.Throws<InvalidOperationException>(host.Services.GetRequiredService<TestDbContext>); 318var exception = Assert.Throws<InvalidOperationException>(host.Services.GetRequiredService<TestDbContext>);

MaxRequestBodySizeTests.cs (1)

251invalidOpEx = Assert.Throws<InvalidOperationException>(() =>

ChunkedRequestTests.cs (6)

243Assert.Throws<InvalidOperationException>(() => request.GetTrailer("X-Trailer-Header")); // Not yet 250Assert.Throws<InvalidOperationException>(() => request.GetTrailer("X-Trailer-Header")); // Not yet 258Assert.Throws<InvalidOperationException>(() => request.GetTrailer("X-Trailer-Header")); 369Assert.Throws<InvalidOperationException>(() => request.GetTrailer("X-Trailer-Header")); // Not yet 376Assert.Throws<InvalidOperationException>(() => request.GetTrailer("X-Trailer-Header")); // Not yet 384Assert.Throws<InvalidOperationException>(() => request.GetTrailer("X-Trailer-Header"));

Http2\Http2StreamTests.cs (3)

2145Assert.Throws<InvalidOperationException>(() => context.Response.ContentType = "Custom 你好 Type"); 2473Assert.Throws<InvalidOperationException>(() => context.Features.Get<IHttpResponseTrailersFeature>().Trailers.ETag = "Custom 你好 Tag"); 2474Assert.Throws<InvalidOperationException>(() => context.Features.Get<IHttpResponseTrailersFeature>().Trailers.Accept = "Custom 你好 Tag");

Http3\Http3StreamTests.cs (3)

863Assert.Throws<InvalidOperationException>(() => context.Response.ContentType = "Custom 你好 Type"); 1017Assert.Throws<InvalidOperationException>(() => context.Features.Get<IHttpResponseTrailersFeature>().Trailers.ETag = "Custom 你好 Tag"); 1018Assert.Throws<InvalidOperationException>(() => context.Features.Get<IHttpResponseTrailersFeature>().Trailers.Accept = "Custom 你好 Tag");

MaxRequestBodySizeTests.cs (2)

297invalidOpEx = Assert.Throws<InvalidOperationException>(() => 337invalidOpEx = Assert.Throws<InvalidOperationException>(() =>

RequestTests.cs (2)

1698var ioEx = Assert.Throws<InvalidOperationException>(() => context.Request.Body.Read(new byte[1], 0, 1)); 1791var ioEx = Assert.Throws<InvalidOperationException>(() => context.Request.Body.Read(new byte[1], 0, 1));

ResponseHeaderTests.cs (2)

24Assert.Throws<InvalidOperationException>(() => context.Response.ContentType = "Custom 你好 Type"); // Special cased 25Assert.Throws<InvalidOperationException>(() => context.Response.Headers.Accept = "Custom 你好 Accept"); // Not special cased

ResponseTests.cs (1)

4276writeEx = Assert.Throws<InvalidOperationException>(() => httpContext.Response.BodyWriter.GetMemory());

AntiforgeryApplicationBuilderExtensionsTest.cs (1)

41var exception = Assert.Throws<InvalidOperationException>(() => builder.UseAntiforgery());

AsyncContextHttpContextOfTTests.cs (1)

78Assert.Throws<InvalidOperationException>(() => _context.Get());

AsyncStateHttpContextExtensionsTests.cs (1)

18Assert.Throws<ArgumentNullException>(() => AsyncStateHttpContextExtensions.AddAsyncStateHttpContext(null!));

AuthenticationSchemeProviderTests.cs (1)

153var error = Assert.Throws<InvalidOperationException>(() => services.GetRequiredService<IAuthenticationSchemeProvider>());

CookieTests.cs (1)

293Assert.Throws<OptionsValidationException>(() => options.Get(CookieAuthenticationDefaults.AuthenticationScheme));

OpenIdConnect\OpenIdConnectTests.cs (1)

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

AuthorizationPolicyFacts.cs (1)

14Assert.Throws<InvalidOperationException>(() => new AuthorizationPolicyBuilder().RequireRole());

DefaultAuthorizationServiceTests.cs (1)

482Assert.Throws<InvalidOperationException>(() => BuildAuthorizationService(services =>

EditContextDataAnnotationsExtensionsTest.cs (1)

17var ex = Assert.Throws<ArgumentNullException>(() => editContext.EnableDataAnnotationsValidation(_serviceProvider));

EditContextTest.cs (4)

11var ex = Assert.Throws<ArgumentNullException>(() => new EditContext(null)); 281Assert.Throws<KeyNotFoundException>(() => editContext.Properties[key1]); 290Assert.Throws<KeyNotFoundException>(() => editContext.Properties[key3]); 336Assert.Throws<KeyNotFoundException>(() => editContext.Properties[key]);

FieldIdentifierTest.cs (4)

15var ex = Assert.Throws<ArgumentNullException>(() => new FieldIdentifier(null, "somefield")); 22var ex = Assert.Throws<ArgumentException>(() => new FieldIdentifier(DateTime.Now, "somefield")); 30var ex = Assert.Throws<ArgumentNullException>(() => new FieldIdentifier(new object(), null)); 164var ex = Assert.Throws<ArgumentException>(() =>

ValidationMessageStoreTest.cs (1)

11var ex = Assert.Throws<ArgumentNullException>(() => new ValidationMessageStore(null));

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

364var exception = Assert.Throws<InvalidDataException>(() => HubProtocol.TryParseMessage(ref data, binder, out _));

CascadingParameterTest.cs (1)

566var ex = Assert.Throws<InvalidOperationException>(() => renderer.AssignRootComponentId(component));

EventCallbackFactoryBinderExtensionsTest.cs (1)

605var ex = Assert.Throws<InvalidOperationException>(() => EventCallback.Factory.CreateBinder(component, setter, value));

NavigationManagerTest.cs (3)

140var exception = Assert.Throws<InvalidOperationException>(() => navigationManager.GetUriWithQueryParameter(name, "test")); 193var exception = Assert.Throws<InvalidOperationException>(() => navigationManager.GetUriWithQueryParameters(unsupportedParameterValues)); 209var exception = Assert.Throws<InvalidOperationException>(() => navigationManager.GetUriWithQueryParameters(values));

ParameterViewTest.cs (4)

336Assert.Throws<InvalidOperationException>(() => parameterView.GetEnumerator()); 337Assert.Throws<InvalidOperationException>(() => parameterView.GetValueOrDefault<object>("anything")); 339Assert.Throws<InvalidOperationException>(() => parameterView.ToDictionary()); 340var ex = Assert.Throws<InvalidOperationException>(() => parameterView.TryGetValue<object>("anything", out _));

RendererTest.cs (6)

663var ex = Assert.Throws<InvalidOperationException>(() => renderer.GetEventArgsType(eventHandlerId)); 686var ex = Assert.Throws<InvalidOperationException>(() => renderer.GetEventArgsType(eventHandlerId)); 4458Assert.Throws<InvalidOperationException>(() => parameterView.GetEnumerator()); 4459Assert.Throws<InvalidOperationException>(() => parameterView.GetValueOrDefault<object>("anything")); 4461Assert.Throws<InvalidOperationException>(parameterView.ToDictionary); 4462var ex = Assert.Throws<InvalidOperationException>(() => parameterView.TryGetValue<object>("anything", out _));

RenderTreeDiffBuilderTest.cs (3)

398var ex = Assert.Throws<InvalidOperationException>(() => GetSingleUpdatedComponent()); 415var ex = Assert.Throws<InvalidOperationException>(() => GetSingleUpdatedComponent()); 432var ex = Assert.Throws<InvalidOperationException>(() => GetSingleUpdatedComponent());

Forms\InputFileChangeEventArgsTest.cs (3)

30var ex = Assert.Throws<InvalidOperationException>(() => instance.File); 38var ex = Assert.Throws<InvalidOperationException>(() => instance.File); 62var ex = Assert.Throws<InvalidOperationException>(() => instance.GetMultipleFiles(1));

Hosting\WebAssemblyHostBuilderTest.cs (1)

106Assert.Throws<InvalidOperationException>(() => host.Services.GetRequiredService<TestServiceThatTakesStringBuilder>());

CookieChunkingTests.cs (1)

182Assert.Throws<FormatException>(() => new ChunkingCookieManager() { ThrowForPartialCookies = true }

CorsPolicyBuilderTests.cs (3)

145Assert.Throws<ArgumentNullException>(() => builder.WithOrigins(args)); 156Assert.Throws<ArgumentNullException>(() => builder.WithOrigins(args)); 342var ex = Assert.Throws<InvalidOperationException>(() => builder.Build());

DataProtectionCommonExtensionsTests.cs (1)

116var ex = Assert.Throws<InvalidOperationException>(() => services.GetDataProtectionProvider());

DataProtectionProviderTests.cs (1)

199Assert.Throws<CryptographicException>(() => keylessUnprotector.Unprotect(data));

TimeLimitedDataProtectorTests.cs (1)

170Assert.Throws<CryptographicException>(() => ephemeralProtector.Unprotect(timeLimitedProtectedPayload));

AuthenticatedEncryption\ConfigurationModel\ManagedAuthenticatedEncryptorDescriptorDeserializerTests.cs (1)

125var ex = Assert.Throws<InvalidOperationException>(() => new ManagedAuthenticatedEncryptorDescriptorDeserializer().ImportFromXml(XElement.Parse(xml)));

Internal\KeyManagementOptionsPostSetupTest.cs (1)

172Assert.Throws<InvalidOperationException>(() => options.XmlEncryptor.Encrypt(xElement));

KeyManagement\KeyRingProviderTests.cs (2)

183Assert.Throws<InvalidOperationException>(() => keyRingProvider.GetCacheableKeyRing(now)); // The would-be default key is revoked 264var exception = Assert.Throws<InvalidOperationException>(() => keyRingProvider.GetCacheableKeyRing(now));

KeyManagement\XmlKeyManagerTests.cs (2)

592Assert.Throws<FormatException>(() => RunGetAllKeysCore(xml, new Mock<IActivator>().Object)); 998Assert.Throws<NotSupportedException>(() => withoutDeletion.DeleteKeys(_ => false));

ServiceCollectionTests.cs (1)

106Assert.Throws<InvalidOperationException>(() => options.XmlEncryptor.Encrypt(xElement));

XmlEncryption\EncryptedXmlDecryptorTests.cs (3)

24var ex = Assert.Throws<CryptographicException>(() => 42var ex = Assert.Throws<CryptographicException>(() => 60var ex = Assert.Throws<CryptographicException>(() =>

HealthCheckMiddlewareTests.cs (2)

936var exception = Assert.Throws<InvalidOperationException>(() => 947var exception = Assert.Throws<InvalidOperationException>(() =>

Latency\RequestCheckpointExtensionsTests.cs (2)

17Assert.Throws<ArgumentNullException>(() => Extensions.DependencyInjection.RequestLatencyTelemetryServiceCollectionExtensions.AddRequestCheckpoint(null!)); 23Assert.Throws<ArgumentNullException>(() => Builder.RequestLatencyTelemetryApplicationBuilderExtensions.UseRequestCheckpoint(null!));

Latency\RequestLatencyTelemetryExtensionsTests.cs (4)

20Assert.Throws<ArgumentNullException>(() => 22Assert.Throws<ArgumentNullException>(() => 24Assert.Throws<ArgumentNullException>(() => 26Assert.Throws<ArgumentNullException>(() =>

Logging\HttpLoggingServiceExtensionsTests.cs (2)

25Assert.Throws<ArgumentNullException>(static () => HttpLoggingServiceCollectionExtensions.AddHttpLogEnricher<TestHttpLogEnricher>(null!)); 27Assert.Throws<ArgumentNullException>(

Logging\LoggingOptionsValidationTests.cs (1)

28var ex = Assert.Throws<InvalidOperationException>(

Logging\RequestHeadersEnricherExtensionsTests.cs (4)

18Assert.Throws<ArgumentNullException>(() => 21Assert.Throws<ArgumentNullException>(() => 24Assert.Throws<ArgumentNullException>(() => 35Assert.Throws<ArgumentNullException>(() => sp.GetRequiredService<ILogEnricher>());

JsonTranscodingServiceMethodProviderTests.cs (6)

97var ex = Assert.Throws<InvalidOperationException>(() => FindGrpcEndpoint(endpoints, nameof(JsonTranscodingGreeterService.NoOption))); 166var ex = Assert.Throws<InvalidOperationException>(() => MapEndpoints<JsonTranscodingInvalidResponseBodyGreeterService>()); 178var ex = Assert.Throws<InvalidOperationException>(() => MapEndpoints<JsonTranscodingInvalidNestedResponseBodyGreeterService>()); 190var ex = Assert.Throws<InvalidOperationException>(() => MapEndpoints<JsonTranscodingInvalidBodyGreeterService>()); 202var ex = Assert.Throws<InvalidOperationException>(() => MapEndpoints<JsonTranscodingInvalidNestedBodyGreeterService>()); 214var ex = Assert.Throws<InvalidOperationException>(() => MapEndpoints<JsonTranscodingInvalidPatternGreeterService>());

HeaderParsingExtensionsTests.cs (2)

37Assert.Throws<OptionsValidationException>(() => services.GetRequiredService<IOptions<HeaderParsingOptions>>().Value); 47Assert.Throws<OptionsValidationException>(() => services.GetRequiredService<IOptions<HeaderParsingOptions>>().Value);

WebHostBuilderTests.cs (9)

69Assert.Throws<ArgumentNullException>(() => builder.UseServer(server).UseStartup((Func<WebHostBuilderContext, object>)null)); 77var ex = Assert.Throws<InvalidOperationException>(() => builder.UseServer(server).UseStartup<object>(context => null).Build()); 424var exception = Assert.Throws<InvalidOperationException>(() => hostBuilder.Build()); 441Assert.Throws<InvalidOperationException>(() => hostBuilder.Build()); 454var exception = Assert.Throws<InvalidOperationException>(() => hostBuilder.Build()); 841var ex = Assert.Throws<InvalidOperationException>(() => builder.Build()); 1005var exception = Assert.Throws<NotSupportedException>(() => builder.Build()); 1260Assert.Throws<ArgumentNullException>(() => new HostingStartupAttribute(null)); 1266Assert.Throws<ArgumentException>(() => new HostingStartupAttribute(typeof(WebHostTests)));

WebHostTests.cs (6)

34Assert.Throws<ArgumentNullException>(() => CreateBuilder().UseStartup((string)null)); 734Assert.Throws<NotImplementedException>(() => builder.Build()); 960Assert.Throws<ObjectDisposedException>(() => capturedContext.TraceIdentifier); 961Assert.Throws<ObjectDisposedException>(() => capturedContext.Features.Get<IHttpRequestIdentifierFeature>()); 963Assert.Throws<ObjectDisposedException>(() => capturedRequest.Scheme); 990var ex = Assert.Throws<InvalidOperationException>(() => builder.Build());

EndpointFilterInvocationContextOfTTests.cs (5)

24Assert.Throws<InvalidCastException>(() => context.GetArgument<string>(1)); 25Assert.Throws<InvalidCastException>(() => context.GetArgument<int>(0)); 26Assert.Throws<InvalidCastException>(() => context.GetArgument<string>(3)); 80Assert.Throws<NullReferenceException>(() => context.GetArgument<int>(1)); 81Assert.Throws<NullReferenceException>(() => context.GetArgument<bool>(2));

EndpointMetadataCollectionTests.cs (1)

90Assert.Throws<InvalidOperationException>(() => metadata.GetRequiredMetadata<string>());

HostStringTest.cs (1)

171Assert.Throws<FormatException>(() => HostString.MatchesAny("example.com:1abc", new StringSegment[] { "example.com" }));

HttpProtocolTests.cs (1)

131Assert.Throws<ArgumentOutOfRangeException>(() => HttpProtocol.GetHttpProtocol(version));

MapPathMiddlewareTests.cs (3)

41Assert.Throws<ArgumentNullException>(() => builder.Map("/foo", configuration: null!)); 42Assert.Throws<ArgumentNullException>(() => new MapMiddleware(noMiddleware, null!)); 131Assert.Throws<ArgumentException>(() => new ApplicationBuilder(serviceProvider: null!).Map(matchPath, map => { }).Build());

MapPredicateMiddlewareTests.cs (6)

51Assert.Throws<ArgumentNullException>(() => builder.MapWhen(null!, UseNotImplemented)); 52Assert.Throws<ArgumentNullException>(() => builder.MapWhen(NotImplementedPredicate, configuration: null!)); 53Assert.Throws<ArgumentNullException>(() => new MapWhenMiddleware(null!, noOptions)); 54Assert.Throws<ArgumentNullException>(() => new MapWhenMiddleware(noMiddleware, null!)); 55Assert.Throws<ArgumentNullException>(() => new MapWhenMiddleware(null!, noOptions)); 56Assert.Throws<ArgumentNullException>(() => new MapWhenMiddleware(noMiddleware, null!));

UseMiddlewareTest.cs (11)

HttpConnectionManagerTests.cs (2)

38Assert.Throws<ArgumentOutOfRangeException>(() => httpOptions.TransportMaxBufferSize = -1); 39Assert.Throws<ArgumentOutOfRangeException>(() => httpOptions.ApplicationMaxBufferSize = -1);

NegotiateProtocolTests.cs (2)

62var exception = Assert.Throws<InvalidDataException>(() => NegotiateProtocol.ParseResponse(responseData)); 82var exception = Assert.Throws<InvalidDataException>(() => NegotiateProtocol.ParseResponse(responseData));

HeaderDictionaryTypeExtensionsTest.cs (2)

161Assert.Throws<NotSupportedException>(() => context.Request.GetTypedHeaders().Get<object>("custom")); 285Assert.Throws<NotSupportedException>(() => context.Request.GetTypedHeaders().GetList<object>("custom"));

ProblemDetailsServiceCollectionExtensionsTest.cs (1)

125Assert.Throws<InvalidOperationException>(() => jsonOptions.Value);

RequestDelegateFactoryTests.cs (38)

RequestDelegateGenerator\CompileTimeCreationTests.cs (1)

428var exception = Assert.Throws<InvalidOperationException>(() => GetEndpointFromCompilation(compilation, serviceProvider: serviceProvider));

RequestDelegateGenerator\RequestDelegateCreationTests.KeyServices.cs (2)

50var exception = Assert.Throws<NotSupportedException>(() => GetEndpointFromCompilation(compilation, serviceProvider: serviceProvider)); 218var runtimeException = Assert.Throws<InvalidOperationException>(() => GetEndpointFromCompilation(compilation, serviceProvider: serviceProvider));

RequestDelegateGenerator\RuntimeCreationTests.cs (1)

26var ex = Assert.Throws<InvalidOperationException>(() => GetEndpointFromCompilation(compilation));

UriHelperTests.cs (1)

180Assert.Throws<ArgumentNullException>(() => UriHelper.BuildAbsolute(null, resHost, resPath, resPath, resQuery, resFragment));

ResultsOfTHelperTests.cs (1)

75Assert.Throws<InvalidOperationException>(() => GetMetadata<DefaultInterfaceMethodEndpointMetadataProvider>());

BindingAddressTests.cs (3)

16Assert.Throws<FormatException>(() => BindingAddress.Parse(url)); 30Assert.Throws<FormatException>(() => BindingAddress.Parse(url)); 40Assert.Throws<FormatException>(() => BindingAddress.Parse(url));

DefaultHttpContextTests.cs (1)

23var exception = Assert.Throws<InvalidOperationException>(() => context.Session);

HeaderDictionaryTests.cs (6)

93Assert.Throws<InvalidOperationException>(() => headers["header1"] = "value1"); 94Assert.Throws<InvalidOperationException>(() => ((IDictionary<string, StringValues>)headers)["header1"] = "value1"); 95Assert.Throws<InvalidOperationException>(() => headers.ContentLength = 12); 99Assert.Throws<InvalidOperationException>(() => headers.Remove(new KeyValuePair<string, StringValues>("header1", "value1"))); 100Assert.Throws<InvalidOperationException>(() => headers.Remove("header1")); 133Assert.Throws<KeyNotFoundException>(() => asIDictionary["Header1"]);

Timeouts\RequestTimeoutOptionsTests.cs (5)

49Assert.Throws<ArgumentException>(() => options.AddPolicy("", TimeSpan.FromSeconds(47))); 50Assert.Throws<ArgumentNullException>(() => options.AddPolicy(null, TimeSpan.FromSeconds(47))); 52Assert.Throws<ArgumentException>(() => options.AddPolicy("", new RequestTimeoutPolicy())); 53Assert.Throws<ArgumentNullException>(() => options.AddPolicy(null, new RequestTimeoutPolicy())); 55Assert.Throws<ArgumentNullException>(() => options.AddPolicy("policy1", null));

HttpLoggingAttributeTests.cs (4)

11var ex = Assert.Throws<ArgumentOutOfRangeException>(() => new HttpLoggingAttribute(HttpLoggingFields.None) { RequestBodyLogLimit = -1 }); 14ex = Assert.Throws<ArgumentOutOfRangeException>(() => new HttpLoggingAttribute(HttpLoggingFields.None) { ResponseBodyLogLimit = -1 }); 23Assert.Throws<InvalidOperationException>(() => attribute.RequestBodyLogLimit); 24Assert.Throws<InvalidOperationException>(() => attribute.ResponseBodyLogLimit);

HttpLoggingEndpointConventionBuilderTests.cs (2)

44var ex = Assert.Throws<ArgumentOutOfRangeException>(() => 48ex = Assert.Throws<ArgumentOutOfRangeException>(() =>

HttpLoggingServicesExtensionsTests.cs (4)

14Assert.Throws<ArgumentNullException>(() => 21Assert.Throws<ArgumentNullException>(() => 33var ex = Assert.Throws<InvalidOperationException>(() => appBuilder.UseHttpLogging()); 45var ex = Assert.Throws<InvalidOperationException>(() => appBuilder.UseW3CLogging());

W3CLoggerOptionsTests.cs (4)

21var ex = Assert.Throws<ArgumentOutOfRangeException>(() => options.FileSizeLimit = -1); 29Assert.Throws<ArgumentException>(() => options.FileName = ""); 36Assert.Throws<ArgumentException>(() => options.LogDirectory = ""); 43var ex = Assert.Throws<ArgumentOutOfRangeException>(() => options.FlushInterval = TimeSpan.FromSeconds(-1));

CertificateForwardingTest.cs (2)

24Assert.Throws<OptionsValidationException>(() => options.Value); 34Assert.Throws<OptionsValidationException>(() => options.Value);

IPNetworkTest.cs (3)

72var ex = Assert.Throws<ArgumentOutOfRangeException>(() => new IPNetwork(address, prefixLength)); 96var ex = Assert.Throws<FormatException>(() => IPNetwork.Parse(input)); 105var ex = Assert.Throws<ArgumentOutOfRangeException>(() => IPNetwork.Parse(input));

UserStoreEncryptPersonalDataTest.cs (1)

290var e = Assert.Throws<InvalidOperationException>(() => dbContext.Database.EnsureCreated());

UserStoreWithGenericsTest.cs (2)

83var e = Assert.Throws<InvalidOperationException>(() => builder.AddEntityFrameworkStores<ContextWithGenerics>()); 92var e = Assert.Throws<InvalidOperationException>(() => builder.AddEntityFrameworkStores<ContextWithGenerics>());

IdentityBuilderTest.cs (8)

32Assert.Throws<ArgumentException>(() => new IdentityBuilder(typeof(int), new ServiceCollection())); 38Assert.Throws<ArgumentException>(() => new IdentityBuilder(typeof(PocoUser), typeof(int), new ServiceCollection())); 50Assert.Throws<InvalidOperationException>(() => sp.GetService<RoleManager<PocoRole>>()); 256Assert.Throws<InvalidOperationException>(() => builder.AddUserManager<object>()); 257Assert.Throws<InvalidOperationException>(() => builder.AddRoleManager<object>()); 258Assert.Throws<InvalidOperationException>(() => builder.AddSignInManager<object>()); 267Assert.Throws<InvalidOperationException>(() => builder.AddTokenProvider<object>("whatevs")); 268Assert.Throws<InvalidOperationException>(() => builder.AddTokenProvider("whatevs", typeof(object)));

RoleManagerTest.cs (1)

55Assert.Throws<NotSupportedException>(() => manager.Roles.Count());

UserManagerTest.cs (3)

683Assert.Throws<NotSupportedException>(() => manager.Users.Count()); 811var e = Assert.Throws<InvalidOperationException>(() => services.BuildServiceProvider().GetService<UserManager<PocoUser>>()); 822var e = Assert.Throws<InvalidOperationException>(() => services.BuildServiceProvider().GetService<UserManager<PocoUser>>());

MaximumOSVersionAttributeTest.cs (3)

14Assert.Throws<NotImplementedException>(() => new MaximumOSVersionAttribute(OperatingSystems.Linux, "2.5")); 20Assert.Throws<NotImplementedException>(() => new MaximumOSVersionAttribute(OperatingSystems.MacOSX, "2.5")); 26Assert.Throws<NotImplementedException>(() => new MaximumOSVersionAttribute(OperatingSystems.Linux | OperatingSystems.Windows, "2.5"));

MinimumOSVersionAttributeTest.cs (3)

14Assert.Throws<NotImplementedException>(() => new MinimumOSVersionAttribute(OperatingSystems.Linux, "2.5")); 20Assert.Throws<NotImplementedException>(() => new MinimumOSVersionAttribute(OperatingSystems.MacOSX, "2.5")); 26Assert.Throws<NotImplementedException>(() => new MinimumOSVersionAttribute(OperatingSystems.Linux | OperatingSystems.Windows, "2.5"));

TestPathUtilitiesTest.cs (1)

18var exception = Assert.Throws<Exception>(() => TestPathUtilities.GetSolutionRootDirectory("NotTesting"));

RequestLocalizationOptionsTest.cs (1)

55Assert.Throws<ArgumentNullException>(() => options.DefaultRequestCulture = null);

ModelBinding\BindingInfoTest.cs (1)

327Assert.Throws<NotSupportedException>(() => BindingInfo.GetBindingInfo(attributes, modelMetadata));

ModelBinding\ModelMetadataTest.cs (6)

387Assert.Throws<NotImplementedException>(() => metadata.ContainerMetadata); 397var result = Assert.Throws<NotImplementedException>(() => metadata.GetMetadataForType(typeof(string))); 407var result = Assert.Throws<NotImplementedException>(() => metadata.GetMetadataForProperties(typeof(string))); 419Assert.Throws<NotSupportedException>(() => metadata.ElementType); 422Assert.Throws<NotSupportedException>(() => metadata.IsComplexType); 423Assert.Throws<NotSupportedException>(() => metadata.IsCollectionType);

ModelBinding\ModelStateDictionaryTest.cs (2)

1652var invalidException = Assert.Throws<InvalidOperationException>(() => dictionary.TryAddModelException(key, exception)); 1670var invalidException = Assert.Throws<InvalidOperationException>(() => dictionary.TryAddModelError(key, "errorMessage"));

ActionResultOfTTest.cs (3)

18var ex = Assert.Throws<ArgumentException>(() => new ActionResult<FileStreamResult>(value: input)); 29var ex = Assert.Throws<ArgumentException>(() => new ActionResult<FileStreamResult>(result: actionResult)); 40var ex = Assert.Throws<ArgumentException>(() => new ActionResult<TestResult>(value: result));

ApplicationParts\RelatedAssemblyPartTest.cs (2)

36var ex = Assert.Throws<InvalidOperationException>(() => RelatedAssemblyAttribute.GetRelatedAssemblies(assembly, throwOnError: true)); 51Assert.Throws<FileNotFoundException>(() => RelatedAssemblyAttribute.GetRelatedAssemblies(assembly, throwOnError: true));

Builder\MvcApplicationBuilderExtensionsTest.cs (1)

24var exception = Assert.Throws<InvalidOperationException>(

ConsumesAttributeTests.cs (3)

28var exception = Assert.Throws<FormatException>(() => new ConsumesAttribute(contentType)); 45var ex = Assert.Throws<FormatException>( 65var ex = Assert.Throws<InvalidOperationException>(

Controllers\ServiceBasedControllerActivatorTest.cs (1)

66var ex = Assert.Throws<InvalidOperationException>(

Formatters\InputFormatterTest.cs (2)

393Assert.Throws<InvalidOperationException>(() => formatter.CanRead(context)); 403Assert.Throws<InvalidOperationException>(

Formatters\MediaTypeTest.cs (1)

131Assert.Throws<ArgumentException>(() => new MediaType("lengthof9", 5, 5));

Formatters\OutputFormatterTests.cs (2)

216Assert.Throws<InvalidOperationException>(() => formatter.CanWriteResult(context)); 227Assert.Throws<InvalidOperationException>(

Formatters\TextInputFormatterTest.cs (1)

57Assert.Throws<InvalidOperationException>(() => formatter.TestSelectCharacterEncoding(context));

ModelBinding\Binders\BodyModelBinderProviderTest.cs (1)

52var exception = Assert.Throws<InvalidOperationException>(() => provider.GetBinder(context));

ModelBinding\Binders\ComplexTypeModelBinderTest.cs (3)

539var exception = Assert.Throws<InvalidOperationException>(() => binder.CreateModelPublic(bindingContext)); 564var exception = Assert.Throws<InvalidOperationException>(() => binder.CreateModelPublic(bindingContext)); 581var exception = Assert.Throws<InvalidOperationException>(() => binder.CreateModelPublic(bindingContext));

ModelBinding\Binders\FormCollectionModelBinderProviderTest.cs (1)

20var exception = Assert.Throws<InvalidOperationException>(() => provider.GetBinder(context));

ModelBinding\Metadata\ModelAttributesTest.cs (1)

298var exception = Assert.Throws<InvalidOperationException>(() => ModelAttributes.GetAttributesForProperty(modelType, property));

ModelBinding\ModelBinderFactoryTest.cs (2)

34var exception = Assert.Throws<InvalidOperationException>(() => factory.CreateBinder(context)); 56var exception = Assert.Throws<InvalidOperationException>(() => factory.CreateBinder(context));

ModelBinding\Validation\DefaultComplexObjectValidationStrategyTest.cs (3)

150Assert.Throws<NullReferenceException>(() => entry.Model); 156Assert.Throws<NullReferenceException>(() => entry.Model); 182var exception = Assert.Throws<InvalidOperationException>(() => BufferEntries(enumerator));

MvcOptionsTest.cs (1)

15var ex = Assert.Throws<ArgumentOutOfRangeException>(() => options.MaxModelValidationErrors = -1);

ProducesAttributeTests.cs (2)

100var ex = Assert.Throws<FormatException>( 122var ex = Assert.Throws<InvalidOperationException>(

ProducesResponseTypeAttributeTests.cs (1)

41var ex = Assert.Throws<InvalidOperationException>(

ResponseCacheAttributeTest.cs (1)

54var ex = Assert.Throws<InvalidOperationException>(

Routing\ActionEndpointFactoryTest.cs (1)

213var exception = Assert.Throws<InvalidOperationException>(() => CreateAttributeRoutedEndpoint(action));

Routing\ControllerLinkGeneratorExtensionsTest.cs (4)

25var exception = Assert.Throws<ArgumentException>(() => 29exception = Assert.Throws<ArgumentNullException>(() => 33exception = Assert.Throws<ArgumentNullException>(() => 37exception = Assert.Throws<ArgumentNullException>(() =>

Routing\KnownRouteValueConstraintTests.cs (1)

191var ex = Assert.Throws<InvalidOperationException>(

Routing\UrlHelperExtensionsTest.cs (1)

549var ex = Assert.Throws<InvalidOperationException>(() => urlHelper.Object.Page(expected));

Routing\UrlHelperTestBase.cs (1)

1088var ex = Assert.Throws<InvalidOperationException>(() => urlHelper.ActionLink("contact", "home"));

XmlDataContractSerializerInputFormatterTest.cs (1)

452Assert.Throws<ArgumentOutOfRangeException>(() => formatter.MaxDepth = 0);

XmlSerializerInputFormatterTest.cs (1)

469Assert.Throws<ArgumentOutOfRangeException>(() => formatter.MaxDepth = 0);

AntiforgeryMiddlewareTest.cs (1)

63var exception = Assert.Throws<InvalidOperationException>(() => app.MapControllers());

SimpleWithWebApplicationBuilderExceptionTests.cs (1)

29var ex = Assert.Throws<InvalidOperationException>(() => Factory.CreateClient());

TestingInfrastructureTests.cs (1)

47var ex = Assert.Throws<InvalidOperationException>(() => factory.CreateClient());

ValidationIntegrationTests.cs (3)

1489Assert.Throws<NullReferenceException>(() => model.ValidateNeverLength); 1596Assert.Throws<NullReferenceException>(() => model.ControlLength); 1686Assert.Throws<NullReferenceException>(() => model.ControlLength);

ValidationWithRecordIntegrationTests.cs (3)

1333Assert.Throws<NullReferenceException>(() => model.ValidateNeverLength); 1404Assert.Throws<NullReferenceException>(() => model.ControlLength); 1492Assert.Throws<NullReferenceException>(() => model.ControlLength);

DependencyInjection\MvcNewtonsoftJsonOptionsExtensionsTest.cs (2)

221var exception = Assert.Throws<InvalidOperationException>( 235var exception = Assert.Throws<InvalidOperationException>(

RazorPageTest.cs (1)

444ex = Assert.Throws<InvalidOperationException>(() => v.RenderSection("bar"));

Infrastructure\ServiceBasedPageModelActivatorProviderTest.cs (1)

115var ex = Assert.Throws<InvalidOperationException>(

AttributeDictionaryTest.cs (1)

387Assert.Throws<KeyNotFoundException>(() => attributes["nada"]);

ControllerUnitTestabilityTests.cs (1)

557Assert.Throws<ArgumentNullException>(() => controller.Redirect_Action(null));

DefaultDisplayTemplatesTest.cs (1)

366var ex = Assert.Throws<ArgumentException>(() => helper.DisplayFor(m => m.Property1));

DefaultEditorTemplatesTest.cs (1)

1314var ex = Assert.Throws<FormatException>(() => helper.EditorFor(m => m.Property1));

DefaultHtmlGeneratorTest.cs (1)

525var exception = Assert.Throws<InvalidOperationException>(() => htmlGenerator.GetCurrentValues(

Infrastructure\DefaultTempDataSerializerTest.cs (1)

51var ex = Assert.Throws<InvalidOperationException>(() => testProvider.Serialize(input));

RemoteAttributeTest.cs (1)

149var exception = Assert.Throws<InvalidOperationException>(() => testableAttribute.InvokeGetUrl(context));

Rendering\HtmlHelperCheckboxTest.cs (1)

81var ex = Assert.Throws<FormatException>(

Rendering\HtmlHelperDisplayNameExtensionsTest.cs (2)

166var exception = Assert.Throws<InvalidOperationException>( 181var exception = Assert.Throws<InvalidOperationException>(

Rendering\HtmlHelperLabelExtensionsTest.cs (1)

429var exception = Assert.Throws<InvalidOperationException>(

Rendering\HtmlHelperPartialExtensionsTest.cs (1)

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

ViewComponents\DefaultViewComponentDescriptorProviderTest.cs (5)

22var ex = Assert.Throws<InvalidOperationException>(() => provider.GetViewComponents().ToArray()); 38var ex = Assert.Throws<InvalidOperationException>(() => provider.GetViewComponents().ToArray()); 53var ex = Assert.Throws<InvalidOperationException>(() => provider.GetViewComponents().ToArray()); 67var ex = Assert.Throws<InvalidOperationException>(() => provider.GetViewComponents().ToArray()); 80var ex = Assert.Throws<InvalidOperationException>(() => provider.GetViewComponents().ToArray());

ViewComponents\DefaultViewComponentSelectorTest.cs (2)

104var ex = Assert.Throws<InvalidOperationException>(() => selector.SelectComponent("Ambiguous")); 125var ex = Assert.Throws<InvalidOperationException>(() => selector.SelectComponent(name));

ViewDataDictionaryOfTModelTest.cs (10)

ViewDataOfTTest.cs (2)

18Exception ex = Assert.Throws<InvalidOperationException>(() => viewData.Model = null); 30Exception ex = Assert.Throws<InvalidOperationException>(() => viewData.Model = DateTime.UtcNow);

ViewEngines\CompositeViewEngineTest.cs (3)

44var exception = Assert.Throws<InvalidOperationException>( 172var exception = Assert.Throws<InvalidOperationException>( 311var exception = Assert.Throws<InvalidOperationException>(

Services\OpenApiGeneratorTests.cs (1)

77var ex = Assert.Throws<InvalidOperationException>(() => GetOpenApiOperation(lambda.Compile()));

OwinEnvironmentTests.cs (1)

108Assert.Throws<KeyNotFoundException>(() => env[key]);

RateLimitingApplicationBuilderExtensionsTests.cs (3)

16Assert.Throws<ArgumentNullException>(() => RateLimiterApplicationBuilderExtensions.UseRateLimiter(null)); 23Assert.Throws<ArgumentNullException>(() => appBuilder.UseRateLimiter(null)); 34var ex = Assert.Throws<InvalidOperationException>(() => appBuilder.UseRateLimiter());

RateLimitingOptionsTests.cs (5)

16Assert.Throws<ArgumentNullException>(() => options.AddPolicy<string>(null, context => RateLimitPartition.GetNoLimiter<string>("myKey"))); 23Assert.Throws<ArgumentNullException>(() => options.AddPolicy<string>("myKey", partitioner: null)); 30Assert.Throws<ArgumentNullException>(() => options.AddPolicy<string>("myKey", policy: null)); 38Assert.Throws<ArgumentException>(() => options.AddPolicy<string>("myKey", context => RateLimitPartition.GetNoLimiter<string>("yourKey"))); 46Assert.Throws<ArgumentException>(() => options.AddPolicy<string, TestRateLimiterPolicy>("myKey"));

ResponseCachingFeatureTests.cs (1)

52Assert.Throws<ArgumentException>(() => new ResponseCachingFeature().VaryByQueryKeys = value);

MinimalFormTests.cs (1)

228exception = Assert.Throws<InvalidOperationException>(() => app.UseAntiforgery());

Builder\EndpointRoutingApplicationBuilderExtensionsTest.cs (4)

28var ex = Assert.Throws<InvalidOperationException>(() => app.UseRouting()); 45var ex = Assert.Throws<InvalidOperationException>(() => app.UseEndpoints(endpoints => { })); 118var ex = Assert.Throws<InvalidOperationException>(() => app.UseEndpoints(endpoints => { })); 140var ex = Assert.Throws<InvalidOperationException>(() => app.Map("/Test", b => b.UseEndpoints(endpoints => { })));

Builder\GroupTest.cs (1)

309var ex = Assert.Throws<NotSupportedException>(() => dataSource.Endpoints);

Builder\RequestDelegateEndpointRouteBuilderExtensionsTest.cs (1)

469Assert.Throws<InvalidOperationException>(() => endpointBuilder.WithMetadata(new RouteNameMetadata("Foo")));

Builder\RouteHandlerEndpointRouteBuilderExtensionsTest.cs (6)

216var ex = Assert.Throws<InvalidOperationException>(() => dataSource.Endpoints); 227var ex = Assert.Throws<InvalidOperationException>(() => dataSource.Endpoints); 255var ex = Assert.Throws<InvalidOperationException>(() => dataSource.Endpoints); 499Assert.Throws<InvalidOperationException>(() => endpointBuilder.WithMetadata(new RouteNameMetadata("Foo"))); 596var ex = Assert.Throws<InvalidOperationException>(() => dataSource.Endpoints); 654var ex = Assert.Throws<InvalidOperationException>(() => dataSource.Endpoints);

Builder\RoutingBuilderExtensionsTest.cs (3)

25var exception = Assert.Throws<InvalidOperationException>( 42var ex = Assert.Throws<InvalidOperationException>(() => app.UseRouter(Mock.Of<IRouter>())); 59var ex = Assert.Throws<InvalidOperationException>(() => app.UseRouter(b => { }));

CompositeEndpointDataSourceTest.cs (4)

77Assert.Same(ex, Assert.Throws<Exception>(() => compositeDataSource.Endpoints)); 78Assert.Same(ex, Assert.Throws<Exception>(() => compositeDataSource.Endpoints)); 79Assert.Same(ex, Assert.Throws<Exception>(() => compositeDataSource.GetGroupedEndpoints(groupContext))); 80Assert.Same(ex, Assert.Throws<Exception>(() => compositeDataSource.GetGroupedEndpoints(groupContext)));

DefaultEndpointDataSourceTests.cs (2)

49var actual = Assert.Throws<ArgumentNullException>(() => new DefaultEndpointDataSource(endpoints)); 93var actual = Assert.Throws<ArgumentNullException>(() => new DefaultEndpointDataSource(endpoints));

DefaultInlineConstraintResolverTest.cs (4)

48var ex = Assert.Throws<RouteCreationException>( 319var ex = Assert.Throws<RouteCreationException>(() => resolver.ResolveConstraint("custom")); 334var ex = Assert.Throws<RouteCreationException>(() => resolver.ResolveConstraint("custom(5,6)")); 360var ex = Assert.Throws<RouteCreationException>(() => _constraintResolver.ResolveConstraint("int(5,6)"));

DefaultParameterPolicyFactoryTest.cs (4)

21var exception = Assert.Throws<InvalidOperationException>( 43var exception = Assert.Throws<RouteCreationException>( 331var exception = Assert.Throws<RouteCreationException>( 372var exception = Assert.Throws<RouteCreationException>(

Patterns\RoutePatternFactoryTest.cs (8)

76var ex = Assert.Throws<InvalidOperationException>(() => RoutePatternFactory.Pattern( 124var ex = Assert.Throws<InvalidOperationException>(() => RoutePatternFactory.Pattern( 390var ex = Assert.Throws<InvalidOperationException>(() => RoutePatternFactory.Pattern( 757var ex = Assert.Throws<RoutePatternException>(() => RoutePatternFactory.Combine(left, right)); 805var ex = Assert.Throws<InvalidOperationException>(() => RoutePatternFactory.Combine(left, right)); 817var ex = Assert.Throws<InvalidOperationException>(() => RoutePatternFactory.Combine(left, right)); 830var ex = Assert.Throws<InvalidOperationException>(() => RoutePatternFactory.Combine(left, right)); 842var ex = Assert.Throws<InvalidOperationException>(() => RoutePatternFactory.Combine(left, right));

RouteBuilderTest.cs (1)

43var exception = Assert.Throws<InvalidOperationException>(() => new RouteBuilder(applicationBuilderMock.Object));

RouteCollectionTest.cs (2)

303var ex = Assert.Throws<InvalidOperationException>(() => routeCollection.GetVirtualPath(virtualPathContext)); 325var ex = Assert.Throws<InvalidOperationException>(() => routeCollection.GetVirtualPath(virtualPathContext));

RouteEndpointBuilderTest.cs (1)

23var ex = Assert.Throws<ArgumentNullException>(() => new RouteEndpointBuilder(context => Task.CompletedTask, routePattern: null, order: 0));

RouteTest.cs (1)

31var exception = Assert.Throws<RouteCreationException>(

TemplateParserDefaultValuesTests.cs (2)

60var ex = Assert.Throws<RouteCreationException>( 85var ex = Assert.Throws<RouteCreationException>(

OpaqueUpgradeTests.cs (1)

146Assert.Throws<InvalidOperationException>(() => feature.MaxRequestBodySize = 12);

RequestBodyLimitTests.cs (9)

ResponseHeaderTests.cs (2)

228Assert.Throws<InvalidOperationException>(() => response.StatusCode = 404); 259Assert.Throws<InvalidOperationException>(() => response.StatusCode = 404);

UrlPrefixTests.cs (4)

18Assert.Throws<FormatException>(() => UrlPrefix.Create(url)); 27Assert.Throws<ArgumentOutOfRangeException>(() => UrlPrefix.Create(url)); 39Assert.Throws<ArgumentException>(() => UrlPrefix.Create(url)); 49Assert.Throws<FormatException>(() => UrlPrefix.Create(url));

BodyControlTests.cs (3)

101Assert.Throws<Exception>(() => requestPipe.TryRead(out var res))); 118Assert.Throws<ObjectDisposedException>(() => requestPipe.TryRead(out var res)); 134Assert.Throws<ObjectDisposedException>(() => responsePipe.GetMemory());

DiagnosticMemoryPoolTests.cs (8)

Http1\Http1ConnectionTests.cs (6)

56var exception = Assert.Throws<InvalidOperationException>(() => TakeMessageHeaders(readableBuffer, trailers: false, out _consumed, out _examined)); 304Assert.Throws<InvalidOperationException>(() => ((IHttpResponseFeature)_http1Connection).StatusCode = StatusCodes.Status404NotFound); 315Assert.Throws<InvalidOperationException>(() => ((IHttpResponseFeature)_http1Connection).ReasonPhrase = "Reason phrase"); 560var exception = Assert.Throws<BadHttpRequestException>(() => 940var ex = Assert.Throws<InvalidOperationException>(() => ((IHttpMaxRequestBodySizeFeature)_http1Connection).MaxRequestBodySize = 1); 948var ex = Assert.Throws<ArgumentOutOfRangeException>(() => ((IHttpMaxRequestBodySizeFeature)_http1Connection).MaxRequestBodySize = -1);

Http2\Http2HttpProtocolFeatureCollectionTests.cs (3)

54Assert.Throws<NotSupportedException>(() => minRateFeature.MinDataRate); 55Assert.Throws<NotSupportedException>(() => minRateFeature.MinDataRate = new MinDataRate(1, TimeSpan.FromSeconds(2))); 61Assert.Throws<NotSupportedException>(() => minRateFeature.MinDataRate);

Http3\Http3HttpProtocolFeatureCollectionTests.cs (3)

54Assert.Throws<NotSupportedException>(() => minRateFeature.MinDataRate); 55Assert.Throws<NotSupportedException>(() => minRateFeature.MinDataRate = new MinDataRate(1, TimeSpan.FromSeconds(2))); 61Assert.Throws<NotSupportedException>(() => minRateFeature.MinDataRate);

HttpParserTests.cs (7)

86var exception = Assert.Throws<BadHttpRequestException>(() => 120var exception = Assert.Throws<BadHttpRequestException>(() => 139var exception = Assert.Throws<BadHttpRequestException>(() => 167var exception = Assert.Throws<BadHttpRequestException>(() => 185var exception = Assert.Throws<BadHttpRequestException>(() => 528var exception = Assert.Throws<BadHttpRequestException>(() => 539exception = Assert.Throws<BadHttpRequestException>(() =>

HttpRequestHeadersTests.cs (3)

97Assert.Throws<KeyNotFoundException>(() => headers["custom"]); 98Assert.Throws<KeyNotFoundException>(() => headers["host"]); 99Assert.Throws<KeyNotFoundException>(() => headers["Content-Length"]);

HttpRequestStreamTests.cs (5)

43Assert.Throws<NotSupportedException>(() => stream.Seek(0, SeekOrigin.Begin)); 50Assert.Throws<NotSupportedException>(() => stream.Length); 64Assert.Throws<NotSupportedException>(() => stream.Position); 65Assert.Throws<NotSupportedException>(() => stream.Position = 0); 120var ioEx = Assert.Throws<InvalidOperationException>(() => stream.Read(new byte[1], 0, 1));

HttpResponseHeadersTests.cs (2)

287Assert.Throws<InvalidOperationException>(() => dictionary["my-header"] = "other-value"); 298Assert.Throws<InvalidOperationException>(() => dictionary.Remove("my-header"));

HttpResponseStreamTests.cs (7)

43Assert.Throws<NotSupportedException>(() => stream.Read(new byte[1], 0, 1)); 50Assert.Throws<NotSupportedException>(() => stream.ReadByte()); 64Assert.Throws<NotSupportedException>(() => stream.BeginRead(new byte[1], 0, 1, null, null)); 71Assert.Throws<NotSupportedException>(() => stream.Seek(0, SeekOrigin.Begin)); 78Assert.Throws<NotSupportedException>(() => stream.Length); 92Assert.Throws<NotSupportedException>(() => stream.Position); 93Assert.Throws<NotSupportedException>(() => stream.Position = 0);

KestrelServerLimitsTests.cs (9)

KestrelServerOptionsTests.cs (3)

63Assert.Throws<InvalidOperationException>(() => options.Configure()); 74Assert.Throws<InvalidOperationException>(() => options.Configure()); 102var ex = Assert.Throws<ArgumentNullException>(() => options.RequestHeaderEncodingSelector = null);

KestrelServerTests.cs (1)

281var exception = Assert.Throws<ArgumentNullException>(() =>

MemoryPoolTests.cs (1)

46var exception = Assert.Throws<ObjectDisposedException>(() => memoryPool.Rent());

MessageBodyTests.cs (10)

MinDataRateTests.cs (2)

26var exception = Assert.Throws<ArgumentOutOfRangeException>(() => new MinDataRate(bytesPerSecond: value, gracePeriod: TimeSpan.MaxValue)); 43var exception = Assert.Throws<ArgumentOutOfRangeException>(() => new MinDataRate(bytesPerSecond: 1, gracePeriod: value));

ConfigurationReaderTests.cs (1)

97var exception = Assert.Throws<ArgumentException>(() =>

HttpsConnectionAdapterOptionsTest.cs (1)

37var exception = Assert.Throws<ArgumentOutOfRangeException>(() => new HttpsConnectionAdapterOptions { HandshakeTimeout = value });

CommandLineApplicationTests.cs (18)

ObjectMethodExecutorTest.cs (3)

74Assert.Throws<NotImplementedException>( 152Assert.Throws<ArgumentOutOfRangeException>(() => executor.GetDefaultValueForParameter(2)); 159Assert.Throws<InvalidOperationException>(() => executor.GetDefaultValueForParameter(0));

PropertyHelperTest.cs (2)

496Assert.Throws<NullReferenceException>(() => accessor(null)); 510Assert.Throws<NullReferenceException>(() => accessor(null));

runtime\Http2\DynamicTableTest.cs (2)

67Assert.Throws<IndexOutOfRangeException>(() => dynamicTable[0]); 70Assert.Throws<IndexOutOfRangeException>(() => dynamicTable[1]);

runtime\Http2\HPackIntegerTest.cs (1)

103Assert.Throws<HPackDecodingException>(() => decoder.TryDecode(octets[octets.Length - 1], out intResult));

runtime\Http2\HuffmanDecodingTests.cs (4)

89Assert.Throws<HuffmanDecodingException>(() => Huffman.Decode(encoded, ref decoded)); 271Exception exception = Assert.Throws<HuffmanDecodingException>(() => Huffman.Decode(new ReadOnlySpan<byte>(encoded), ref dst)); 288Exception exception = Assert.Throws<HuffmanDecodingException>(() => Huffman.Decode(new ReadOnlySpan<byte>(encoded), ref dst)); 333Exception exception = Assert.Throws<HuffmanDecodingException>(() => Huffman.Decode(new ReadOnlySpan<byte>(encoded), ref dst));

SegmentWriteStreamTests.cs (4)

18Assert.Throws<ArgumentOutOfRangeException>(() => new SegmentWriteStream(segmentSize)); 26Assert.Throws<NotSupportedException>(() => stream.Read(new byte[1], 0, 0)); 27Assert.Throws<NotSupportedException>(() => stream.Position = 0); 28Assert.Throws<NotSupportedException>(() => stream.Seek(0, SeekOrigin.Begin));

UrlDecoderTests.cs (4)

57Assert.Throws<ArgumentException>(() => UrlDecoder.DecodeRequestLine(source.AsSpan(), source.AsSpan(0, 1))); 64Assert.Throws<ArgumentException>(() => UrlDecoder.DecodeRequestLine(source.AsSpan(), source.AsSpan(0, 1), false)); 87Assert.Throws<InvalidOperationException>(() => UrlDecoder.DecodeInPlace(source.AsSpan())); 94Assert.Throws<InvalidOperationException>(() => UrlDecoder.DecodeInPlace(source.AsSpan(), false));

ValueStopwatchTest.cs (1)

28Assert.Throws<InvalidOperationException>(() => stopwatch.GetElapsedTime());

HttpConnectionTests.cs (6)

45Assert.Throws<ArgumentOutOfRangeException>(() => httpOptions.TransportMaxBufferSize = -1); 46Assert.Throws<ArgumentOutOfRangeException>(() => httpOptions.ApplicationMaxBufferSize = -1); 52var exception = Assert.Throws<ArgumentNullException>(() => new HttpConnection(null)); 59var exception = Assert.Throws<ArgumentException>(() => new HttpConnection(new HttpConnectionOptions(), NullLoggerFactory.Instance)); 67var exception = Assert.Throws<InvalidOperationException>(() => connection.ConnectionId = "custom conneciton ID"); 122Assert.Throws<ArgumentNullException>(() => httpOptions.Cookies = null);

HubConnectionBuilderTests.cs (3)

22var ex = Assert.Throws<InvalidOperationException>(() => new HubConnectionBuilder().Build()); 32var ex = Assert.Throws<InvalidOperationException>(() => builder.Build()); 69var ex = Assert.Throws<InvalidOperationException>(() => builder.Build());

HubConnectionTests.Protocol.cs (1)

712var ex = Assert.Throws<InvalidOperationException>(

Internal\Protocol\HandshakeProtocolTests.cs (1)

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

Internal\Protocol\JsonHubProtocolTests.cs (1)

54var ex = Assert.Throws<InvalidDataException>(() => JsonHubProtocol.TryParseMessage(ref data, binder, out var _));

Internal\Protocol\JsonHubProtocolTestsBase.cs (2)

196var ex = Assert.Throws<InvalidDataException>(() => JsonHubProtocol.TryParseMessage(ref data, binder, out var _)); 269var ex = Assert.Throws<InvalidDataException>(() => JsonHubProtocol.TryParseMessage(ref data, binder, out var message));

Internal\Protocol\MessagePackHubProtocolTestBase.cs (1)

364var exception = Assert.Throws<InvalidDataException>(() => HubProtocol.TryParseMessage(ref data, binder, out _));

Internal\Protocol\NewtonsoftJsonHubProtocolTests.cs (1)

52var ex = Assert.Throws<InvalidDataException>(() => JsonHubProtocol.TryParseMessage(ref data, binder, out var _));

AddSignalRTests.cs (1)

196Assert.Throws<ArgumentOutOfRangeException>(() => new HubOptions() { MaximumParallelInvocationsPerClient = 0 });

HubConnectionHandlerTests.cs (5)

243var ex = Assert.Throws<InvalidOperationException>(() => 1361var exception = Assert.Throws<NotSupportedException>(() => serviceProvider.GetService<HubConnectionHandler<GenericMethodHub>>()); 5046var ex = Assert.Throws<InvalidOperationException>(() => serviceProvider.GetService<HubConnectionHandler<KeyedServicesHub>>()); 5062var ex = Assert.Throws<InvalidOperationException>(() => serviceProvider.GetService<HubConnectionHandler<BadServicesHub>>()); 5073Assert.Throws<InvalidOperationException>(

ClientHandlerTests.cs (1)

344Assert.Throws<NotSupportedException>(() => invoker.Send(message, CancellationToken.None));

HttpContextBuilderTests.cs (1)

300var ex = Assert.Throws<IOException>(() => context.Response.Body.Read(new byte[100], 0, 100));

TestServerTests.cs (2)

118Assert.Throws<InvalidOperationException>(() => new TestServer(builder)); 306Assert.Throws<ArgumentNullException>(() => new TestServer(builder, null));

WebApplicationTests.cs (34)

AddWebSocketsTests.cs (1)

36Assert.Throws<ArgumentOutOfRangeException>(() => new WebSocketOptions() { KeepAliveTimeout = TimeSpan.FromMicroseconds(-1) });

FileBufferingReadStreamTests.cs (2)

159var exception = Assert.Throws<IOException>(() => stream.Read(bytes, 0, bytes.Length)); 191var exception = Assert.Throws<IOException>(() => stream.Read(bytes, 0, bytes.Length));

BackEnd\ConfigCache_Tests.cs (1)

125Assert.Throws<InternalErrorException>(() => ((ConfigCache)obj).GetSmallestConfigId());

BackEnd\TargetBuilder_Tests.cs (1)

1467Assert.Throws<InternalErrorException>(() => resultsCache.GetResultForRequest(entry.Request));

BuildEventArgsSerialization_Tests.cs (1)

961Assert.Throws<EndOfStreamException>(() => buildEventArgsReader.Read());

Evaluation\Evaluator_Tests.cs (1)

66Assert.Throws<InvalidProjectFileException>(() => collection.LoadProject(projectFile.Path));

Evaluation\Expander_Tests.cs (8)

2655Assert.Throws<InvalidProjectFileException>(() => expander.ExpandIntoStringLeaveEscaped("$([Microsoft.FOO.FileIO.FileSystem]::CurrentDirectory)", ExpanderOptions.ExpandProperties, MockElementLocation.Instance)); 2656Assert.Throws<InvalidProjectFileException>(() => expander.ExpandIntoStringLeaveEscaped("$([Foo.Baz]::new())", ExpanderOptions.ExpandProperties, MockElementLocation.Instance)); 2657Assert.Throws<InvalidProjectFileException>(() => expander.ExpandIntoStringLeaveEscaped("$([Foo]::new())", ExpanderOptions.ExpandProperties, MockElementLocation.Instance)); 2658Assert.Throws<InvalidProjectFileException>(() => expander.ExpandIntoStringLeaveEscaped("$([Foo.]::new())", ExpanderOptions.ExpandProperties, MockElementLocation.Instance)); 2659Assert.Throws<InvalidProjectFileException>(() => expander.ExpandIntoStringLeaveEscaped("$([.Foo]::new())", ExpanderOptions.ExpandProperties, MockElementLocation.Instance)); 2660Assert.Throws<InvalidProjectFileException>(() => expander.ExpandIntoStringLeaveEscaped("$([.]::new())", ExpanderOptions.ExpandProperties, MockElementLocation.Instance)); 2661Assert.Throws<InvalidProjectFileException>(() => expander.ExpandIntoStringLeaveEscaped("$([]::new())", ExpanderOptions.ExpandProperties, MockElementLocation.Instance)); 3345var ex = Assert.Throws<InvalidProjectFileException>(

Evaluation\ImportFromMSBuildExtensionsPath_Tests.cs (5)

60Assert.Throws<InvalidProjectFileException>(() => projColln.LoadProject(mainProjectPath)); 310Assert.Throws<InvalidProjectFileException>(() => projColln.LoadProject(mainProjectPath)); 643Assert.Throws<InvalidProjectFileException>(() => projectCollection.LoadProject(mainProjectPath)); 837Assert.Throws<InvalidProjectFileException>(() => projectCollection.LoadProject(mainProjectPath)); 871Assert.Throws<InvalidProjectFileException>(() => projectCollection.LoadProject(mainProjectPath));

Evaluation\ProjectSdkImplicitImport_Tests.cs (2)

328Assert.Throws<InvalidProjectFileException>( 396Assert.Throws<InvalidProjectFileException>(() => new Project(

Globbing\MSBuildGlob_Tests.cs (4)

57Assert.Throws<ArgumentNullException>(() => MSBuildGlob.Parse(null, "*")); 75Assert.Throws<ArgumentException>(() => MSBuildGlob.Parse(invalidPathChar.ToString(), "*")); 104Assert.Throws<ArgumentNullException>(() => MSBuildGlob.Parse(null)); 177Assert.Throws<ArgumentNullException>(() => glob.IsMatch(null));

Graph\ProjectGraph_Tests.cs (1)

126Assert.Throws<InternalErrorException>(() => new ProjectGraphNode(null));

CommandLineTests.cs (1)

7838Assert.Throws<Win32Exception>(() => Win32Res.GetResource(lib, resourceId, resourceType, out manifestSize));

Workspaces\WorkspaceTests_EditorFeatures.cs (1)

1441Assert.Throws<ArgumentException>(() => VersionStamp.Create(DateTime.Now));

CodeGen\CodeGenTupleTest.cs (16)

Emit\CompilationEmitTests.cs (1)

5180Assert.Throws<ArgumentException>(() => compilation.Emit(outReal));

Diagnostics\DiagnosticSuppressorTests.cs (1)

681Assert.Throws<OperationCanceledException>(() => compilation.GetAnalyzerDiagnostics(analyzersAndSuppressors, reportSuppressedDiagnostics: true, cancellationToken: cancellationToken));

FlowAnalysis\RegionAnalysisTests.cs (6)

3103Assert.Throws<ArgumentNullException>(() => semanticModel.AnalyzeControlFlow(statement, null)); 3104Assert.Throws<ArgumentNullException>(() => semanticModel.AnalyzeControlFlow(null, statement)); 3105Assert.Throws<ArgumentNullException>(() => semanticModel.AnalyzeControlFlow(null)); 3106Assert.Throws<ArgumentNullException>(() => semanticModel.AnalyzeDataFlow(null, statement)); 3107Assert.Throws<ArgumentNullException>(() => semanticModel.AnalyzeDataFlow(statement, null)); 3108Assert.Throws<ArgumentNullException>(() => semanticModel.AnalyzeDataFlow((StatementSyntax)null));

Semantics\CollectionExpressionTests.cs (2)

27064Assert.Throws<ArgumentNullException>(() => spread.GetElementConversion()); 27071Assert.Throws<ArgumentException>(() => spread.GetElementConversion());

Semantics\OutVarTests.cs (2)

1104Assert.Throws<NotSupportedException>(() => model.AnalyzeDataFlow(dataFlowParent)); 32791Assert.Throws<NotSupportedException>(() => model.AnalyzeDataFlow(dataFlowParent));

Semantics\PatternMatchingTestBase.cs (1)

327Assert.Throws<NotSupportedException>(() => model.AnalyzeDataFlow(dataFlowParent));

Semantics\PrimaryConstructorTests.cs (4)

2195Assert.Throws<ArgumentNullException>(() => model.TryGetSpeculativeSemanticModel(baseWithargs.ArgumentList.OpenParenToken.SpanStart, (PrimaryConstructorBaseTypeSyntax)null, out _)); 2196Assert.Throws<ArgumentException>(() => model.TryGetSpeculativeSemanticModel(baseWithargs.ArgumentList.OpenParenToken.SpanStart, baseWithargs, out _)); 2334Assert.Throws<ArgumentNullException>(() => model.TryGetSpeculativeSemanticModel(baseWithargs.ArgumentList.OpenParenToken.SpanStart, (PrimaryConstructorBaseTypeSyntax)null, out _)); 2335Assert.Throws<ArgumentException>(() => model.TryGetSpeculativeSemanticModel(baseWithargs.ArgumentList.OpenParenToken.SpanStart, baseWithargs, out _));

Semantics\RecordTests.cs (4)

22352Assert.Throws<ArgumentNullException>(() => model.TryGetSpeculativeSemanticModel(baseWithargs.ArgumentList.OpenParenToken.SpanStart, (PrimaryConstructorBaseTypeSyntax)null!, out _)); 22353Assert.Throws<ArgumentException>(() => model.TryGetSpeculativeSemanticModel(baseWithargs.ArgumentList.OpenParenToken.SpanStart, baseWithargs, out _)); 22491Assert.Throws<ArgumentNullException>(() => model.TryGetSpeculativeSemanticModel(baseWithargs.ArgumentList.OpenParenToken.SpanStart, (PrimaryConstructorBaseTypeSyntax)null!, out _)); 22492Assert.Throws<ArgumentException>(() => model.TryGetSpeculativeSemanticModel(baseWithargs.ArgumentList.OpenParenToken.SpanStart, baseWithargs, out _));

IOperation\IOperationTests_IAnonymousFunctionExpression.cs (13)

IOperation\IOperationTests_IArgument.cs (2)

3072Assert.Throws<ArgumentException>(() => argument.GetInConversion()); 3073Assert.Throws<ArgumentException>(() => argument.GetOutConversion());

IOperation\IOperationTests_ILocalFunctionStatement.cs (5)

1816Assert.Throws<ArgumentNullException>(() => graphM.GetLocalFunctionControlFlowGraph(null)); 1817Assert.Throws<ArgumentOutOfRangeException>(() => graphM.GetLocalFunctionControlFlowGraph(localFunctionD2)); 1818Assert.Throws<ArgumentNullException>(() => graphM.GetLocalFunctionControlFlowGraphInScope(null)); 1819Assert.Throws<ArgumentOutOfRangeException>(() => graphM.GetLocalFunctionControlFlowGraphInScope(localFunctionD2)); 1868Assert.Throws<ArgumentOutOfRangeException>(() => graphD2.GetLocalFunctionControlFlowGraph(localFunctionD1));

InteractiveSessionTests.cs (4)

502Assert.Throws<ArgumentException>(() => compilation2.IsSymbolAccessibleWithin(c3C3, c3C1)); 624Assert.Throws<CompilationErrorException>(() => s0.ContinueWithAsync("invalid$syntax").Result); 628Assert.Throws<CompilationErrorException>(() => s1.ContinueWithAsync("invalid$syntax").Result); 629Assert.Throws<CompilationErrorException>(() => s1.ContinueWithAsync("x = undefined_symbol").Result);

PrintOptionsTests.cs (5)

21Assert.Throws<ArgumentNullException>(() => s_formatter.FormatObject("hello", options: null)); 27Assert.Throws<ArgumentOutOfRangeException>(() => new PrintOptions().NumberRadix = 3); 33Assert.Throws<ArgumentOutOfRangeException>(() => new PrintOptions().MemberDisplayFormat = (MemberDisplayFormat)(-1)); 39Assert.Throws<ArgumentOutOfRangeException>(() => new PrintOptions().MaximumOutputLength = -1); 40Assert.Throws<ArgumentOutOfRangeException>(() => new PrintOptions().MaximumOutputLength = 0);

ScriptOptionsTests.cs (1)

37Assert.Throws<InvalidOperationException>(() => options.WithLanguageVersion(LanguageVersion.CSharp8));

ScriptTests.cs (7)

46Assert.Throws<ArgumentNullException>(() => CSharpScript.Create((string)null)); 59Assert.Throws<ArgumentNullException>(() => CSharpScript.Create((Stream)null, ScriptOptions)); 448Assert.Throws<ArgumentException>(() => state.GetVariable("x").Value = "str"); 449Assert.Throws<InvalidOperationException>(() => state.GetVariable("y").Value = "str"); 450Assert.Throws<InvalidOperationException>(() => state.GetVariable("z").Value = "str"); 451Assert.Throws<InvalidOperationException>(() => state.GetVariable("y").Value = 0); 452Assert.Throws<InvalidOperationException>(() => state.GetVariable("z").Value = 0);

Semantics\AccessCheckTests.cs (1)

975Assert.Throws<ArgumentException>(() => compilation.IsSymbolAccessibleWithin(classC, classQ));

Semantics\AccessibilityTests.cs (3)

42Assert.Throws<ArgumentNullException>(() => 49Assert.Throws<ArgumentOutOfRangeException>(() => 52Assert.Throws<ArgumentOutOfRangeException>(() =>

Semantics\LambdaTests.cs (3)

8021Assert.Throws<InvalidOperationException>(() => lambdas[0].Symbol.Parameters[0].ExplicitDefaultValue); 8031Assert.Throws<InvalidOperationException>(() => lambdas[1].Symbol.Parameters[0].ExplicitDefaultValue); 8038Assert.Throws<InvalidOperationException>(() => lambdas[2].Symbol.Parameters[0].ExplicitDefaultValue);

Semantics\MemberResolutionResultTests.cs (1)

24Assert.Throws<NotSupportedException>(() => d.GetHashCode());

Semantics\ScriptSemanticsTests.cs (1)

874Assert.Throws<InvalidOperationException>(() => CreateSubmission("a + 1", previous: s0));

Semantics\SyntaxTreeRootTests.cs (4)

62Assert.Throws<ArgumentException>(() => CSharpCompilation.Create("Grrr", syntaxTrees: new[] { arbitraryTree })); 63Assert.Throws<ArgumentException>(() => CSharpCompilation.CreateScriptCompilation("Wah").AddSyntaxTrees(arbitraryTree)); 64Assert.Throws<ArgumentException>(() => CSharpCompilation.Create("Bahh", syntaxTrees: new[] { parsedTree }).ReplaceSyntaxTree(parsedTree, arbitraryTree)); 65Assert.Throws<ArgumentException>(() => CSharpCompilation.Create("Woo").GetSemanticModel(arbitraryTree));

Semantics\TopLevelStatementsTests.cs (1)

1982Assert.Throws<System.ArgumentException>(() => CreateCompilation(new[] { Parse(text1, filename: "text1", DefaultParseOptions),

SourceGeneration\GeneratorDriverTests.cs (7)

763Assert.Throws<OperationCanceledException>(() => 1652Assert.Throws<InvalidOperationException>(() => throwsFunc(20, CancellationToken.None)); 1665Assert.Throws<OperationCanceledException>(() => timeoutFunc(30, new CancellationToken(true))); 1669Assert.Throws<OperationCanceledException>(() => otherTimeoutFunc(30, CancellationToken.None)); 2473Assert.Throws<OperationCanceledException>(() => driver = driver.RunGenerators(compilation, cancellationToken: cts.Token)); 2536Assert.Throws<ArgumentNullException>(() => driver.WithUpdatedParseOptions(null!)); 2687Assert.Throws<ArgumentNullException>(() => driver.WithUpdatedAnalyzerConfigOptions(null!));

SourceGeneration\SyntaxAwareGeneratorTests.cs (2)

1996Assert.Throws<OperationCanceledException>(() => driver = driver.RunGenerators(compilation, cancellationToken: cts.Token)); 2025Assert.Throws<OperationCanceledException>(() => driver = driver.RunGenerators(compilation, cancellationToken: cts.Token));

Compilation\CompilationAPITests.cs (68)

Compilation\GetSemanticInfoTests.cs (10)

4053Assert.Throws<InvalidOperationException>(() => method1.ReducedFrom.GetTypeInferredDuringReduction(null)); 4054Assert.Throws<ArgumentNullException>(() => method1.GetTypeInferredDuringReduction(null)); 5408Assert.Throws<InvalidOperationException>(() => type.Construct(objectType)); // non-generic type 5414Assert.Throws<InvalidOperationException>(() => type.Construct(objectType)); // non-generic type 5420Assert.Throws<ArgumentException>(() => type.Construct(new ITypeSymbol[] { null })); // null type arg 5421Assert.Throws<ArgumentException>(() => type.Construct()); // typeArgs.Length != Arity 5422Assert.Throws<InvalidOperationException>(() => type.Construct(objectType).Construct(objectType)); // constructed type 5428Assert.Throws<ArgumentException>(() => type.Construct(new ITypeSymbol[] { null })); // null type arg 5429Assert.Throws<ArgumentException>(() => type.Construct()); // typeArgs.Length != Arity 5430Assert.Throws<InvalidOperationException>(() => type.Construct(objectType).Construct(objectType)); // constructed type

Compilation\ReferenceManagerTests.cs (1)

2144Assert.Throws<ObjectDisposedException>(() => compilation.GetTypeByMetadataName("System.Int64").GetMembers());

Compilation\SemanticModelAPITests.cs (9)

2181Assert.Throws<ArgumentNullException>(() => model.TryGetSpeculativeSemanticModel(statement.SpanStart, statement: null, speculativeModel: out speculativeModel)); 2182Assert.Throws<ArgumentNullException>(() => model.TryGetSpeculativeSemanticModel(statement.SpanStart, constructorInitializer: (ConstructorInitializerSyntax)null, speculativeModel: out speculativeModel)); 2183Assert.Throws<ArgumentNullException>(() => model.TryGetSpeculativeSemanticModel(statement.SpanStart, attribute: null, speculativeModel: out speculativeModel)); 2186Assert.Throws<ArgumentException>(() => model.TryGetSpeculativeSemanticModel(statement.SpanStart, statement: statement, speculativeModel: out speculativeModel)); 2187Assert.Throws<ArgumentException>(() => model.TryGetSpeculativeSemanticModel(ctorInitializer.SpanStart, constructorInitializer: ctorInitializer, speculativeModel: out speculativeModel)); 2188Assert.Throws<ArgumentException>(() => model.TryGetSpeculativeSemanticModel(attribute.SpanStart, attribute: attribute, speculativeModel: out speculativeModel)); 2193Assert.Throws<InvalidOperationException>(() => speculativeModel.TryGetSpeculativeSemanticModel(speculatedStatement.SpanStart, speculatedStatement, speculativeModel: out speculativeModel)); 2235Assert.Throws<InvalidOperationException>(() => speculativeModel.TryGetSpeculativeSemanticModel(speculatedStatement.SpanStart, newSpeculatedStatement, out newModel)); 2239Assert.Throws<InvalidOperationException>(() => speculativeModel.TryGetSpeculativeSemanticModel(speculatedStatement.SpanStart, newSpeculatedStatement, out newModel));

Compilation\SemanticModelGetSemanticInfoTests.cs (7)

1665Assert.Throws<ArgumentNullException>(() => model.GetSymbolInfo((ExpressionSyntax)null)); 1666Assert.Throws<ArgumentNullException>(() => model.GetTypeInfo((ExpressionSyntax)null)); 1667Assert.Throws<ArgumentNullException>(() => model.GetMemberGroup((ExpressionSyntax)null)); 1668Assert.Throws<ArgumentNullException>(() => model.GetConstantValue((ExpressionSyntax)null)); 1670Assert.Throws<ArgumentNullException>(() => model.GetSymbolInfo((ConstructorInitializerSyntax)null)); 1671Assert.Throws<ArgumentNullException>(() => model.GetTypeInfo((ConstructorInitializerSyntax)null)); 1672Assert.Throws<ArgumentNullException>(() => model.GetMemberGroup((ConstructorInitializerSyntax)null));

DocumentationComments\DocumentationCommentCompilerTests.cs (1)

3355Assert.Throws<XmlException>(() => XElement.Parse(xml));

Symbols\AnonymousTypesSemanticsTests.cs (1)

1980Assert.Throws<InvalidOperationException>(() => namedType.Construct(args));

Symbols\CorLibrary\CorTypes.cs (3)

228Assert.Throws<ArgumentOutOfRangeException>(() => c1.GetSpecialType(SpecialType.None)); 229Assert.Throws<ArgumentOutOfRangeException>(() => ((Compilation)c1).GetSpecialType(SpecialType.None)); 231Assert.Throws<ArgumentOutOfRangeException>(() => ((Compilation)c1).GetSpecialType(SpecialType.Count + 1));

Symbols\CustomModifiersTests.cs (13)

Symbols\FunctionPointerTypeSymbolTests.cs (9)

Symbols\Source\FileModifierTests.cs (1)

4590var ex = Assert.Throws<ArgumentException>(() => CreateCompilation(new[] { tree, tree }));

LexicalAndXml\SyntaxTokenParserTests.cs (1)

22Assert.Throws<NullReferenceException>(() => parser.ParseNextToken());

Syntax\SeparatedSyntaxListTests.cs (11)

Syntax\SyntaxFactoryTests.cs (4)

103Assert.Throws<ArgumentException>(() => SyntaxFactory.Token(SyntaxKind.NumericLiteralExpression)); 141Assert.Throws<ArgumentException>(() => SyntaxFactory.Token(default(SyntaxTriviaList), SyntaxKind.IdentifierToken, "text", "valueText", default(SyntaxTriviaList))); 142Assert.Throws<ArgumentException>(() => SyntaxFactory.Token(default(SyntaxTriviaList), SyntaxKind.CharacterLiteralToken, "text", "valueText", default(SyntaxTriviaList))); 143Assert.Throws<ArgumentException>(() => SyntaxFactory.Token(default(SyntaxTriviaList), SyntaxKind.NumericLiteralToken, "text", "valueText", default(SyntaxTriviaList)));

Syntax\SyntaxListTests.cs (13)

Syntax\SyntaxNodeOrTokenListTests.cs (11)

Syntax\SyntaxNodeTests.cs (20)

Syntax\SyntaxTests.cs (2)

33Assert.Throws<ArgumentNullException>(() => SyntaxFactory.IsCompleteSubmission(null)); 34Assert.Throws<ArgumentException>(() =>

Syntax\SyntaxTokenListTests.cs (15)

Syntax\SyntaxTriviaListTests.cs (22)

Syntax\TrackNodeTests.cs (2)

127Assert.Throws<InvalidOperationException>(() => replacedExpr.GetCurrentNode(originalA)); 184Assert.Throws<ArgumentException>(() => expr.TrackNodes(SyntaxFactory.IdentifierName("c")));

Emit\CompilationOutputsTests.cs (4)

88Assert.Throws<ObjectDisposedException>(() => currentPEStream!.Length); 92Assert.Throws<ObjectDisposedException>(() => currentPdbStream!.Length); 103Assert.Throws<ObjectDisposedException>(() => currentPEStream.Length); 108Assert.Throws<ObjectDisposedException>(() => currentPEStream.Length);

Extensions\SourceTextContainerExtensionsTests.cs (1)

20Assert.Throws<ArgumentException>(() => Microsoft.CodeAnalysis.Text.Extensions.GetTextBuffer(containerMock.Object));

MetadataShadowCopyProviderTests.cs (14)

Compilation\TestOperationVisitor.cs (4)

96Assert.Throws<InvalidOperationException>(() => operation.ChildOperations.First()); 97Assert.Throws<InvalidOperationException>(() => operation.ChildOperations.Last()); 852Assert.Throws<ArgumentException>(() => VisualBasic.VisualBasicExtensions.GetConversion(operation)); 856Assert.Throws<ArgumentException>(() => CSharp.CSharpExtensions.GetConversion(operation));

AnalyzerAssemblyLoaderTests.cs (1)

388var exception = Assert.Throws<TargetInvocationException>(

Analyzers\AnalyzerConfigTests.cs (6)

1482Assert.Throws<ArgumentException>(() => Parse("", "relativeDir/file")); 1483Assert.Throws<ArgumentException>(() => Parse("", "/")); 1484Assert.Throws<ArgumentException>(() => Parse("", "/subdir/")); 1490Assert.Throws<ArgumentException>(() => Parse("", "Z:")); 1491Assert.Throws<ArgumentException>(() => Parse("", "Z:\\")); 1492Assert.Throws<ArgumentException>(() => Parse("", ":\\.editorconfig"));

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

315Assert.Throws<ArgumentNullException>(() => set.IsProperSubsetOf(null!)); 316Assert.Throws<ArgumentNullException>(() => set.IsProperSupersetOf(null!)); 317Assert.Throws<ArgumentNullException>(() => set.IsSubsetOf(null!)); 318Assert.Throws<ArgumentNullException>(() => set.IsSupersetOf(null!)); 319Assert.Throws<ArgumentNullException>(() => set.Overlaps(null!)); 320Assert.Throws<ArgumentNullException>(() => set.SetEquals(null!)); 330Assert.Throws<NotSupportedException>(() => set.Add(CreateT(0)));

Collections\IdentifierCollectionTests.cs (1)

82Assert.Throws<NotSupportedException>(() => collection.Remove("x"));

Collections\ImmutableArrayExtensionsTests.cs (8)

29Assert.Throws<ArgumentNullException>(() => ImmutableArray.CreateRange<int>((IEnumerable<int>)null)); 57Assert.Throws<NullReferenceException>(() => nullOrEmpty.IsEmpty); 143Assert.Throws<NullReferenceException>(() => default(ImmutableArray<int>).Single()); 144Assert.Throws<InvalidOperationException>(() => ImmutableArray.Create<int>().Single()); 146Assert.Throws<InvalidOperationException>(() => ImmutableArray.Create<int>(1, 2).Single()); 150Assert.Throws<NullReferenceException>(() => default(ImmutableArray<int>).Single(isOdd)); 151Assert.Throws<InvalidOperationException>(() => ImmutableArray.Create<int>().Single(isOdd)); 153Assert.Throws<InvalidOperationException>(() => ImmutableArray.Create<int>(1, 2, 3).Single(isOdd));

Collections\ImmutableDictionaryBuilderTestBase.cs (1)

74Assert.Throws<KeyNotFoundException>(() => builder["foo"]);

Collections\ImmutableDictionaryTestBase.cs (6)

107Assert.Throws<KeyNotFoundException>(() => this.Empty<int, int>()[3]); 132Assert.Throws<NotSupportedException>(() => dictionary.Remove(new KeyValuePair<string, int>())); 158Assert.Throws<NotSupportedException>(() => dictionary.Remove("a")); 159Assert.Throws<NotSupportedException>(() => dictionary["a"] = 2); 160Assert.Throws<KeyNotFoundException>(() => dictionary["a"]); 170Assert.Throws<NotSupportedException>(() => dictionary["a"] = 2);

Collections\ImmutableDictionaryTestBase.nonnetstandard.cs (2)

50Assert.Throws<NotSupportedException>(() => map.Remove(5)); 64Assert.Throws<NotSupportedException>(() => map[3] = 5);

Collections\ImmutableSegmentedDictionaryBuilderTest.cs (1)

262TargetInvocationException tie = Assert.Throws<TargetInvocationException>(() => Activator.CreateInstance(proxyType, (object?)null));

Collections\ImmutableSegmentedDictionaryTest.cs (1)

262TargetInvocationException tie = Assert.Throws<TargetInvocationException>(() => Activator.CreateInstance(proxyType, (object?)null));

Collections\ImmutableSegmentedHashSetBuilderTest.cs (1)

92Assert.Throws<InvalidOperationException>(() => enumerator.MoveNext());

Collections\ImmutableSegmentedHashSetTest.cs (1)

198TargetInvocationException tie = Assert.Throws<TargetInvocationException>(() => Activator.CreateInstance(proxyType, (object?)null));

Collections\ImmutableSegmentedListBuilderTest.cs (1)

372TargetInvocationException tie = Assert.Throws<TargetInvocationException>(() => Activator.CreateInstance(proxyType, (object)null!));

Collections\ImmutableSegmentedListTest.cs (5)

748Assert.Throws<NotSupportedException>(() => list.Add(1)); 753Assert.Throws<NotSupportedException>(() => list[0] = 1); 764Assert.Throws<NotSupportedException>(() => list.Remove(1)); 766Assert.Throws<NotSupportedException>(() => list[0] = 1); 787TargetInvocationException tie = Assert.Throws<TargetInvocationException>(() => Activator.CreateInstance(proxyType, (object?)null));

Collections\ImmutableSetTest.cs (2)

172Assert.Throws<NotSupportedException>(() => set.Add(0)); 185Assert.Throws<NotSupportedException>(() => set.Remove(1));

Collections\IndexOfTests.cs (17)

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

456Assert.Throws<ArgumentException>(() => collection.Contains(invalidValue)) 560Assert.Throws<NotSupportedException>(() => collection.Remove(CreateT(34543))); 677Assert.Throws<ArgumentException>(() => collection.Remove(value)); 690Assert.Throws<ArgumentNullException>(() => collection.Remove(default(T)!));

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

154Assert.Throws<NotSupportedException>(() => collection.SyncRoot);

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

166Assert.Throws<InvalidOperationException>( 179Assert.Throws<InvalidOperationException>( 217Assert.Throws<InvalidOperationException>(() => enumerator.Current); 315Assert.Throws<InvalidOperationException>(() => enumerator.Current); 434Assert.Throws<InvalidOperationException>(() => enumerator.MoveNext()); 480Assert.Throws<InvalidOperationException>(() => enumerator.MoveNext()); 524Assert.Throws<InvalidOperationException>(() => enumerator.MoveNext()); 654Assert.Throws<InvalidOperationException>(() => enumerator.Current); 670Assert.Throws<InvalidOperationException>(() => enumerator.Current); 689Assert.Throws<InvalidOperationException>(() => enumerator.Current);

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

203Assert.Throws<InvalidOperationException>(() => enumerator.MoveNext()); 229Assert.Throws<InvalidOperationException>(() => enumerator.MoveNext()); 252Assert.Throws<InvalidOperationException>(() => enumerator.MoveNext()); 316Assert.Throws<InvalidOperationException>(() => enumerator.Current); 330Assert.Throws<InvalidOperationException>(() => enumerator.Current); 347Assert.Throws<InvalidOperationException>(() => enumerator.Current);

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

177Assert.Throws<NotSupportedException>(() => list[count / 2] = CreateT(321432)); 209Assert.Throws<ArgumentNullException>(() => list[0] = default(T)!); 244Assert.Throws<ArgumentNullException>(() => list[lastIndex] = default(T)!); 274Assert.Throws<ArgumentException>(() => list[count / 2] = value); 302Assert.Throws<ArgumentNullException>(() => list.IndexOf(default(T)!)); 372Assert.Throws<ArgumentException>(() => list.IndexOf(value)); 628Assert.Throws<InvalidOperationException>(() => enumerator.Current); // enumerator.Current should fail 644Assert.Throws<InvalidOperationException>(() => enumerator.Current); // enumerator.Current should fail

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

281Assert.Throws<NotSupportedException>(() => list[count / 2] = CreateT(321432)); 364Assert.Throws<ArgumentException>(() => list[count / 2] = value); 511Assert.Throws<NotSupportedException>(() => collection.Add(CreateT(0))); 620Assert.Throws<ArgumentException>(() => collection.Contains(invalidValue)) 700Assert.Throws<ArgumentException>(() => list.IndexOf(value)); 1097Assert.Throws<InvalidOperationException>(() => enumerator.Current); // Enumerator.Current should fail 1112Assert.Throws<InvalidOperationException>(() => enumerator.Current); // Enumerator.Current should fail

Collections\SegmentedArrayTests.cs (2)

56Assert.Throws<NullReferenceException>(() => ((IList)data)[0]); 57Assert.Throws<NullReferenceException>(() => ((IList)data)[0] = IntPtr.Zero);

Diagnostics\CompilationWithAnalyzersTests.cs (3)

31Assert.Throws<ArgumentNullException>(() => CompilationWithAnalyzers.GetEffectiveDiagnostics(default(ImmutableArray<Diagnostic>), c)); 32Assert.Throws<ArgumentNullException>(() => CompilationWithAnalyzers.GetEffectiveDiagnostics(null, c)); 33Assert.Throws<ArgumentNullException>(() => CompilationWithAnalyzers.GetEffectiveDiagnostics(ds, null));

Diagnostics\OperationTests.cs (12)

EmbeddedTextTests.cs (4)

60Assert.Throws<IOException>(() => EmbeddedText.FromStream("path", new HugeStream())); 61Assert.Throws<EndOfStreamException>(() => EmbeddedText.FromStream("path", new TruncatingStream(10))); 62Assert.Throws<EndOfStreamException>(() => EmbeddedText.FromStream("path", new TruncatingStream(1000))); 63Assert.Throws<IOException>(() => EmbeddedText.FromStream("path", new ReadFailsStream()));

Emit\CustomDebugInfoTests.cs (5)

154var e = Assert.Throws<InvalidDataException>(() => EditAndContinueMethodDebugInformation.Create(ImmutableArray.Create(new byte[] { 0x01, 0x68, 0xff }), ImmutableArray<byte>.Empty)); 157e = Assert.Throws<InvalidDataException>(() => EditAndContinueMethodDebugInformation.Create(ImmutableArray.Create(new byte[] { 0x01, 0x68, 0xff, 0xff, 0xff, 0xff }), ImmutableArray<byte>.Empty)); 160e = Assert.Throws<InvalidDataException>(() => EditAndContinueMethodDebugInformation.Create(ImmutableArray.Create(new byte[] { 0xff, 0xff, 0xff, 0xff }), ImmutableArray<byte>.Empty)); 171e = Assert.Throws<InvalidDataException>(() => EditAndContinueMethodDebugInformation.Create(ImmutableArray.Create(largeData), ImmutableArray<byte>.Empty)); 337Assert.Throws<InvalidDataException>(() => EditAndContinueMethodDebugInformation.Create(

Emit\EmitBaselineTests.cs (4)

33Assert.Throws<ArgumentNullException>(() => EmitBaseline.CreateInitialBaseline(null, peModule, debugInfoProvider, localSigProvider, true)); 34Assert.Throws<ArgumentNullException>(() => EmitBaseline.CreateInitialBaseline(compilation, null, debugInfoProvider, localSigProvider, true)); 35Assert.Throws<ArgumentNullException>(() => EmitBaseline.CreateInitialBaseline(compilation, peModule, null, localSigProvider, true)); 36Assert.Throws<ArgumentNullException>(() => EmitBaseline.CreateInitialBaseline(compilation, mdModule, debugInfoProvider, null, true));

IsSymbolAccessibleWithinTests.cs (8)

34Assert.Throws<ArgumentException>(() => csc.IsSymbolAccessibleWithin(Av, Av)); 35Assert.Throws<ArgumentException>(() => csc.IsSymbolAccessibleWithin(Av, Ac)); 36Assert.Throws<ArgumentException>(() => csc.IsSymbolAccessibleWithin(Ac, Av)); 37Assert.Throws<ArgumentException>(() => csc.IsSymbolAccessibleWithin(Ac, Ac, Av)); 39Assert.Throws<ArgumentException>(() => vbc.IsSymbolAccessibleWithin(Ac, Ac)); 40Assert.Throws<ArgumentException>(() => vbc.IsSymbolAccessibleWithin(Ac, Av)); 41Assert.Throws<ArgumentException>(() => vbc.IsSymbolAccessibleWithin(Av, Ac)); 42Assert.Throws<ArgumentException>(() => vbc.IsSymbolAccessibleWithin(Av, Av, Ac));

MetadataReferences\AssemblyIdentityDisplayNameTests.cs (1)

367Assert.Throws<ArgumentNullException>(() => AssemblyIdentity.TryParseDisplayName(null, out id));

MetadataReferences\AssemblyIdentityTests.cs (9)

MetadataReferences\AssemblyMetadataTests.cs (11)

MetadataReferences\AssemblyPortabilityPolicyTests.cs (3)

80Assert.Throws<COMException>(() => FusionAssemblyPortabilityPolicy.LoadFromFile(appConfig.Path)); 89Assert.Throws<COMException>(() => FusionAssemblyPortabilityPolicy.LoadFromFile(appConfig.Path)); 105Assert.Throws<COMException>(() => FusionAssemblyPortabilityPolicy.LoadFromFile(appConfig.Path));

MetadataReferences\FusionAssemblyIdentityTests.cs (6)

207Assert.Throws<CultureNotFoundException>(() => ToAssemblyName(nameObject)); 211Assert.Throws<CultureNotFoundException>(() => ToAssemblyName(nameObject)); 213Assert.Throws<CultureNotFoundException>(() => new AssemblyName("mscorlib, Version=2.0.0.0, Culture=nonsense")); 214Assert.Throws<CultureNotFoundException>(() => new AssemblyName("mscorlib, Version=2.0.0.0, Culture=null")); 216Assert.Throws<ArgumentException>(() => FusionAssemblyIdentity.ToAssemblyNameObject(new AssemblyName { Name = "x\0x" })); 224Assert.Throws<FileLoadException>(() => name.FullName);

MetadataReferences\MetadataReferencePropertiesTests.cs (8)

42Assert.Throws<ArgumentOutOfRangeException>(() => new MetadataReferenceProperties((MetadataImageKind)byte.MaxValue)); 43Assert.Throws<ArgumentException>(() => new MetadataReferenceProperties(MetadataImageKind.Module, ImmutableArray.Create("blah"))); 44Assert.Throws<ArgumentException>(() => new MetadataReferenceProperties(MetadataImageKind.Module, embedInteropTypes: true)); 45Assert.Throws<ArgumentException>(() => new MetadataReferenceProperties(MetadataImageKind.Module, ImmutableArray.Create(""))); 46Assert.Throws<ArgumentException>(() => new MetadataReferenceProperties(MetadataImageKind.Module, ImmutableArray.Create("x\0x"))); 48Assert.Throws<ArgumentException>(() => MetadataReferenceProperties.Module.WithAliases(ImmutableArray.Create("blah"))); 49Assert.Throws<ArgumentException>(() => MetadataReferenceProperties.Module.WithAliases(new[] { "blah" })); 50Assert.Throws<ArgumentException>(() => MetadataReferenceProperties.Module.WithEmbedInteropTypes(true));

MetadataReferences\MetadataReferenceTests.cs (5)

280Assert.Throws<ArgumentException>(() => r.WithAliases(new[] { "bar" })); 281Assert.Throws<ArgumentException>(() => r.WithEmbedInteropTypes(true)); 364Assert.Throws<ArgumentException>(() => r.WithProperties(new MetadataReferenceProperties(MetadataImageKind.Module))); 395Assert.Throws<ArgumentException>(() => r.WithProperties(new MetadataReferenceProperties(MetadataImageKind.Module))); 587Assert.Throws<BadImageFormatException>((Func<object>)((AssemblyMetadata)r.GetMetadataNoCopy()).GetAssembly);

MetadataReferences\ModuleMetadataTests.cs (19)

ResourceDescriptionTests.cs (17)

Text\LargeTextTests.cs (2)

65Assert.Throws<IndexOutOfRangeException>(() => text[-1]); 66Assert.Throws<IndexOutOfRangeException>(() => text[HelloWorld.Length]);

Text\SourceTextStreamTests.cs (1)

35Assert.Throws<ArgumentException>(() => stream.Read(buffer, 0, local));

Text\SourceTextTests.cs (2)

343Assert.Throws<InvalidDataException>(() => SourceText.From(bytes, bytes.Length, throwIfBinaryDetected: true)); 346Assert.Throws<InvalidDataException>(() => SourceText.From(stream, throwIfBinaryDetected: true));

Text\StringText_LineTest.cs (7)

62Assert.Throws<ArgumentOutOfRangeException>(() => TextLine.FromSpan(text, new TextSpan(0, 0))); 69Assert.Throws<ArgumentOutOfRangeException>(() => TextLine.FromSpan(text, new TextSpan(0, 3))); 76Assert.Throws<ArgumentOutOfRangeException>(() => TextLine.FromSpan(text, new TextSpan(1, 5))); 107Assert.Throws<ArgumentOutOfRangeException>(() => TextLine.FromSpan(text, new TextSpan(1, 10))); 114Assert.Throws<ArgumentOutOfRangeException>(() => TextLine.FromSpan(text, new TextSpan(-1, 2))); 121Assert.Throws<ArgumentOutOfRangeException>(() => TextLine.FromSpan(text, new TextSpan(7, 0))); 128Assert.Throws<ArgumentNullException>(() => TextLine.FromSpan(null, new TextSpan(0, 2)));

Text\StringTextTest.cs (4)

69Assert.Throws<ArgumentNullException>(() => SourceText.From((string)null, Encoding.UTF8)); 75Assert.Throws<ArgumentNullException>(() => SourceText.From((Stream)null, Encoding.UTF8)); 76Assert.Throws<ArgumentException>(() => SourceText.From(new TestStream(canRead: false, canSeek: true), Encoding.UTF8)); 77Assert.Throws<NotImplementedException>(() => SourceText.From(new TestStream(canRead: true, canSeek: false), Encoding.UTF8));

Text\TextChangeTests.cs (1)

104Assert.Throws<ArgumentException>(() => text.WithChanges(changes));

Text\TextLineCollectionTests.cs (2)

19Assert.Throws<NotSupportedException>(() => default(TextLineCollection.Enumerator).Equals(default(TextLineCollection.Enumerator))); 20Assert.Throws<NotSupportedException>(() => default(TextLineCollection.Enumerator).GetHashCode());

CodeGen\CodeGenTuples.vb (5)

6868Dim ex = Assert.Throws(Of ArgumentException)(Function() comp.CreateTupleTypeSymbol(vt2, ImmutableArray.Create("Item1"))) 6873ex = Assert.Throws(Of ArgumentException)(Function() comp.CreateTupleTypeSymbol(vt2, elementLocations:=ImmutableArray.Create(loc1))) 7194Dim ex = Assert.Throws(Of ArgumentException)(Function() comp.CreateTupleTypeSymbol(vt2, ImmutableArray.Create("123", ""))) 7210Dim ex = Assert.Throws(Of ArgumentException)(Function() comp.CreateTupleTypeSymbol(csType, Nothing)) 8937Assert.Throws(Of ArgumentException)(Function() comp.CreateTupleTypeSymbol(underlyingType:=vt2))

Syntax\SeparatedSyntaxListTests.vb (24)

Syntax\SyntaxTokenFactoryTests.vb (1)

135Assert.Throws(Of ArgumentOutOfRangeException)(Function() SyntaxFactory.Token(CType(localKind, SyntaxKind)))

Options\OptionKeyTests.cs (9)

Remote\ServiceDescriptorTests.cs (1)

194Assert.Throws<NotImplementedException>(() => original.GetBytes("\u1234"));

SolutionTests\DocumentInfoTests.cs (2)

24Assert.Throws<ArgumentNullException>(() => DocumentInfo.Create(id: null, "doc")); 25Assert.Throws<ArgumentNullException>(() => DocumentInfo.Create(documentId, name: null));

SolutionTests\ProjectInfoTests.cs (4)

25Assert.Throws<ArgumentNullException>(() => ProjectInfo.Create(id: null, version: VersionStamp.Default, name: "Goo", assemblyName: "Bar", language: "C#")); 26Assert.Throws<ArgumentNullException>(() => ProjectInfo.Create(pid, VersionStamp.Default, name: null, assemblyName: "Bar", language: "C#")); 27Assert.Throws<ArgumentNullException>(() => ProjectInfo.Create(pid, VersionStamp.Default, name: "Goo", assemblyName: null, language: "C#")); 28Assert.Throws<ArgumentNullException>(() => ProjectInfo.Create(pid, VersionStamp.Default, name: "Goo", assemblyName: "Bar", language: null));

SolutionTests\SolutionInfoTests.cs (1)

23Assert.Throws<ArgumentNullException>(() => SolutionInfo.Create(null, version));

SolutionTests\SolutionTestHelpers.cs (3)

38Assert.Throws<ArgumentNullException>(() => factory(instance, default)); 71Assert.Throws<ArgumentNullException>(() => factory(instanceWithNoItem, new TValue[] { item, default })); 81Assert.Throws<ArgumentException>(() => factory(instanceWithNoItem, new TValue[] { item, item }));

SolutionTests\SolutionTests.cs (71)

SolutionTests\TryApplyChangesTests.cs (1)

105var exception = Assert.Throws<NotSupportedException>(

UtilityTest\SpecializedTasksTests.cs (6)

118var exception = Assert.Throws<TaskCanceledException>(() => task.Result); 195var exception = Assert.Throws<TaskCanceledException>(() => task.Result); 252var exception = Assert.Throws<TaskCanceledException>(() => task.Result); 319var exception = Assert.Throws<TaskCanceledException>(() => task.Result); 400var exception = Assert.Throws<InvalidOperationException>(() => task.Result); 480var exception = Assert.Throws<TaskCanceledException>(() => task.Result);

WorkspaceTests\WorkspaceTests.cs (4)

30Assert.Throws<NotSupportedException>(() => ws.TryApplyChanges(changedDoc.Project.Solution)).Message); 46Assert.Throws<NotSupportedException>(() => ws.TryApplyChanges(changedDoc.Project.Solution)).Message); 81Assert.Throws<NotSupportedException>(() => ws.TryApplyChanges(changedDoc.Project.Solution)).Message); 97Assert.Throws<NotSupportedException>(() => ws.TryApplyChanges(changedDoc.Project.Solution)).Message);

ExampleTests.cs (1)

21var ex = Assert.Throws<InvalidOperationException>(() => TestExampleLanguageServer.CreateBadLanguageServer(logger));

DataFrame.IOTests.cs (4)

231Assert.Throws<System.ArgumentException>(() => DataFrame.LoadCsv(GetStream(data))); 751Assert.Throws<IndexOutOfRangeException>(() => DataFrame.LoadCsv(GetStream(data))); 752Assert.Throws<IndexOutOfRangeException>(() => DataFrame.LoadCsvFromString(data)); 1695Assert.Throws<FormatException>(() => DataFrame.LoadCsvFromString(csvString));

DataFrameGroupByTests.cs (1)

106Assert.Throws<InvalidCastException>(() => df.GroupBy<double>("Tens"));

DataFrameTests.BinaryOperations.cs (10)

DataFrameTests.Computations.cs (92)

DataFrameTests.cs (25)

PrimitiveDataFrameColumnTests.cs (1)

470Assert.Throws<IndexOutOfRangeException>(() => column.Clone(indicesMap));

TextFieldParserTests.cs (8)

36Assert.Throws<ObjectDisposedException>(() => stream.ReadByte()); 54Assert.Throws<ObjectDisposedException>(() => reader.ReadToEnd()); 193Assert.Throws<Exception>(() => parser.ReadFields()); 254Assert.Throws<ArgumentException>(() => parser.PeekChars(0)); 291Assert.Throws<InvalidOperationException>(() => parser.ReadFields()); 318Assert.Throws<Exception>(() => parser.ReadFields()); 367Assert.Throws<Exception>(() => parser.ReadFields()); 383Assert.Throws<Exception>(() => parser.ReadFields());

ExceptionAssertsTests.cs (7)

ApplicationMetadataExtensionsTests.cs (7)

38Assert.Throws<ArgumentNullException>(() => ((IServiceCollection)null!).AddApplicationMetadata(config.GetSection(string.Empty))); 39Assert.Throws<ArgumentNullException>(() => ((IServiceCollection)null!).AddApplicationMetadata(_ => { })); 40Assert.Throws<ArgumentNullException>(() => serviceCollection.AddApplicationMetadata((Action<ApplicationMetadata>)null!)); 41Assert.Throws<ArgumentNullException>(() => serviceCollection.AddApplicationMetadata((IConfigurationSection)null!)); 42Assert.Throws<ArgumentNullException>(() => ((IHostBuilder)null!).UseApplicationMetadata(_fixture.Create<string>())); 43Assert.Throws<ArgumentNullException>(() => new ConfigurationBuilder().AddApplicationMetadata(null!)); 44Assert.Throws<ArgumentNullException>(() => ((IConfigurationBuilder)null!).AddApplicationMetadata(null!));

AsyncContextServiceCollectionExtensionsTests.cs (1)

16Assert.Throws<ArgumentNullException>(() => AsyncStateExtensions.AddAsyncState(null!));

StampedeTests.cs (2)

207var ex = Assert.Throws<OperationCanceledException>(() => result.GetAwaiter().GetResult()); 290var ex = Assert.Throws<OperationCanceledException>(() => result.GetAwaiter().GetResult());

Redaction\NullRedactorTest.cs (1)

44Assert.Throws<ArgumentException>(() => r.Redact("ABCD".AsSpan(), new char[1].AsSpan()));

Redaction\RedactionAbstractionsExtensionsTest.cs (2)

17Assert.Throws<ArgumentNullException>(() => RedactionStringBuilderExtensions.AppendRedacted(null!, NullRedactor.Instance, s)); 18Assert.Throws<ArgumentNullException>(() => RedactionStringBuilderExtensions.AppendRedacted(new StringBuilder(), null!, ""));

HmacRedactorTest.cs (1)

87Assert.Throws<ArgumentException>(() => new HmacRedactor(Microsoft.Extensions.Options.Options.Create<HmacRedactorOptions>(null!)));

RedactionAcceptanceTests.cs (2)

56Assert.Throws<ArgumentNullException>(() => ((IServiceCollection)null!).AddRedaction(_ => { })); 57Assert.Throws<ArgumentNullException>(() => new ServiceCollection().AddRedaction(null!));

FakeRedactorTests.cs (1)

36Assert.Throws<ArgumentException>(() => FakeRedactor.Create(new FakeRedactorOptions { RedactionFormat = "{{{{{23123{}}" }));

RedactionFakesAcceptanceTests.cs (8)

RedactionFakesEventCollectorTests.cs (3)

18Assert.Throws<InvalidOperationException>(() => c.LastRedactorRequested); 19Assert.Throws<InvalidOperationException>(() => c.LastRedactedData); 27Assert.Throws<InvalidOperationException>(() => sp.GetFakeRedactionCollector());

KeyPerFileTests.cs (1)

35var e = Assert.Throws<ArgumentException>(() => new ConfigurationBuilder().AddKeyPerFile("nonexistent", false).Build());

ApplicationLifecycleHealthChecksExtensionsTests.cs (2)

49Assert.Throws<ArgumentNullException>(() => ((IHealthChecksBuilder)null!).AddApplicationLifecycleHealthCheck()); 50Assert.Throws<ArgumentNullException>(() => ((IHealthChecksBuilder)null!).AddApplicationLifecycleHealthCheck(null!));

ManualHealthCheckExtensionsTests.cs (2)

44Assert.Throws<ArgumentNullException>(() => ((IServiceCollection)null!).AddHealthChecks().AddManualHealthCheck()); 45Assert.Throws<ArgumentNullException>(() => ((IServiceCollection)null!).AddHealthChecks().AddManualHealthCheck(null!));

ResourceMonitoringExtensionsTests.cs (4)

25Assert.Throws<ArgumentNullException>(() => ((IResourceMonitorBuilder)null!).ConfigureMonitor(_ => { })); 26Assert.Throws<ArgumentNullException>(() => ((IResourceMonitorBuilder)null!).ConfigureMonitor((IConfigurationSection)null!)); 27Assert.Throws<ArgumentNullException>(() => services.AddResourceMonitoring((b) => b.ConfigureMonitor((IConfigurationSection)null!))); 28Assert.Throws<ArgumentNullException>(() => services.AddResourceMonitoring((b) => b.ConfigureMonitor((Action<ResourceMonitoringOptions>)null!)));

ResourceUtilizationTests.cs (1)

33Assert.Throws<ArgumentOutOfRangeException>(() => new ResourceUtilization(-50.0, 500, _systemResources));

SystemResourcesTests.cs (4)

29Assert.Throws<ArgumentOutOfRangeException>(() => new SystemResources(0.0, 1.0, 1000UL, 1000UL)); 31Assert.Throws<ArgumentOutOfRangeException>(() => new SystemResources(1.0, 0.0, 1000UL, 1000UL)); 34Assert.Throws<ArgumentOutOfRangeException>(() => new SystemResources(1.0, 1.0, 0UL, 1000UL)); 36Assert.Throws<ArgumentOutOfRangeException>(() => new SystemResources(1.0, 1.0, 1000UL, 0UL));

Logging\FakeLogCollectorTests.cs (2)

113Assert.Throws<ArgumentNullException>(() => new FakeLogCollector(null!)); 114Assert.Throws<ArgumentException>(() => new FakeLogCollector(Microsoft.Extensions.Options.Options.Create((FakeLogCollectorOptions)null!)));

Logging\FakeLoggerExtensionsTests.cs (1)

85Assert.Throws<InvalidOperationException>(() => serviceProvider.GetFakeLogCollector());

Logging\FakeLoggerTests.cs (1)

64Assert.Throws<InvalidOperationException>(() => logger.LatestRecord.Level);

Metrics\MetricCollectorTests.cs (12)

FeatureCollectionExtensionsTests.cs (1)

36Assert.Throws<InvalidOperationException>(() => features.GetRequiredFeature<object>());

FeatureCollectionTests.cs (1)

55var ex = Assert.Throws<InvalidOperationException>(() => interfaces.Get<int>());

EmbeddedFileProviderTests.cs (1)

19Assert.Throws<ArgumentNullException>(() => new EmbeddedFileProvider(null));

FakeHostTests.cs (1)

36Assert.Throws<ObjectDisposedException>(() => host.Services.GetService<IHost>());

HostingFakesExtensionsTests.cs (2)

301Assert.Throws<ArgumentNullException>(() => FakeHost.CreateBuilder().AddFakeLoggingOutputSink(null!)); 307Assert.Throws<ArgumentNullException>(() => ((IHostBuilder)null!).AddFakeLoggingOutputSink(_ => { }));

Hedging\StandardHedgingTests.cs (5)

49Assert.Throws<OptionsValidationException>(CreateClientWithHandler); 57Assert.Throws<OptionsValidationException>(CreateClientWithHandler); 139Assert.Throws<InvalidOperationException>(() => 157Assert.Throws<ArgumentException>(() => 166Assert.Throws<ArgumentException>(() =>

Resilience\HttpClientBuilderExtensionsTests.BySelector.cs (1)

55Assert.Throws<InvalidOperationException>(() => provider(request));

Resilience\HttpClientBuilderExtensionsTests.Resilience.cs (8)

Resilience\HttpClientBuilderExtensionsTests.Standard.cs (2)

150Assert.Throws<InvalidOperationException>(() => HttpClientBuilderExtensionsTests.GetPipeline(builder.Services, "test-standard")); 197Assert.Throws<OptionsValidationException>(() => GetPipeline(builder.Services, "test-standard"));

Resilience\HttpResilienceContextExtensionsTests.cs (1)

18Assert.Throws<ArgumentNullException>(context.GetRequestMessage);

ResourceManagerStringLocalizerFactoryTest.cs (1)

297Assert.Throws<ArgumentNullException>(() => factory.Create("baseName", location: null!));

StringLocalizerOfTTest.cs (3)

16var exception = Assert.Throws<ArgumentNullException>( 47var exception = Assert.Throws<ArgumentNullException>(() => localizer[name: null!]); 82var exception = Assert.Throws<ArgumentNullException>(() => localizer[name: null!]);

FileLoaderTests.cs (2)

35Assert.Throws<InvalidOperationException>(() => loaderUnderTest.GetModel()); 36Assert.Throws<InvalidOperationException>(() => loaderUnderTest.GetReloadToken());

UriLoaderTests.cs (2)

35Assert.Throws<InvalidOperationException>(() => loaderUnderTest.GetModel()); 36Assert.Throws<InvalidOperationException>(() => loaderUnderTest.GetReloadToken());

DependencyInjectionExtensionsTests.cs (5)

19Assert.Throws<ArgumentNullException>(() => ObjectPoolServiceCollectionExtensions.AddPooled<TestClass>(null!)); 20Assert.Throws<ArgumentNullException>(() => ObjectPoolServiceCollectionExtensions.AddPooled<ITestClass, TestClass>(null!)); 33var exception = Assert.Throws<ArgumentException>( 81Assert.Throws<ArgumentNullException>(() => new ServiceCollection().ConfigurePools(null!)); 217Assert.Throws<InvalidOperationException>(() => provider.GetRequiredService<ObjectPool<ITestClass>>().Get());

DisposableObjectPoolTest.cs (1)

107Assert.Throws<ObjectDisposedException>(() => pool.Get());

ContextualOptionsServiceCollectionExtensionsTests.cs (1)

20Assert.Throws<ArgumentNullException>(() => ((IServiceCollection)null!).AddContextualOptions());

DnsServicePublicApiTests.cs (6)

19var exception = Assert.Throws<ArgumentNullException>(action); 31var exception = Assert.Throws<ArgumentNullException>(action); 43var exception = Assert.Throws<ArgumentNullException>(action); 54var exception = Assert.Throws<ArgumentNullException>(action); 66var exception = Assert.Throws<ArgumentNullException>(action); 78var exception = Assert.Throws<ArgumentNullException>(action);

YarpServiceDiscoveryPublicApiTests.cs (3)

20var exception = Assert.Throws<ArgumentNullException>(action); 31var exception = Assert.Throws<ArgumentNullException>(action); 42var exception = Assert.Throws<ArgumentNullException>(action);

Enrichment\EnricherExtensionsTests.cs (3)

16Assert.Throws<ArgumentNullException>(() => new ServiceCollection().AddLogEnricher(null!)); 26Assert.Throws<ArgumentNullException>(() => 29Assert.Throws<ArgumentNullException>(() =>

Latency\LatencyRegistryExtensionsTests.cs (9)

16Assert.Throws<ArgumentNullException>( 18Assert.Throws<ArgumentNullException>( 20Assert.Throws<ArgumentNullException>( 22Assert.Throws<ArgumentNullException>( 24Assert.Throws<ArgumentNullException>( 26Assert.Throws<ArgumentNullException>( 33Assert.Throws<ArgumentException>(() => LatencyRegistryServiceCollectionExtensions.RegisterCheckpointNames(new ServiceCollection(), "")); 34Assert.Throws<ArgumentException>(() => LatencyRegistryServiceCollectionExtensions.RegisterMeasureNames(new ServiceCollection(), "")); 35Assert.Throws<ArgumentException>(() => LatencyRegistryServiceCollectionExtensions.RegisterTagNames(new ServiceCollection(), ""));

Latency\NoopLatencyContextTests.cs (1)

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

Logging\TagNameAttributeTests.cs (1)

17Assert.Throws<ArgumentNullException>(() => new TagNameAttribute(null!));

Logging\TagProviderAttributeTests.cs (4)

26Assert.Throws<ArgumentNullException>(() => new TagProviderAttribute(null!, "test")); 27Assert.Throws<ArgumentNullException>(() => new TagProviderAttribute(typeof(object), null!)); 33Assert.Throws<ArgumentException>(() => new TagProviderAttribute(typeof(object), string.Empty)); 34Assert.Throws<ArgumentException>(() => new TagProviderAttribute(typeof(object), new string(' ', 3)));

Enrichment\ApplicationEnricherExtensionsTests.cs (4)

20Assert.Throws<ArgumentNullException>(() => 23Assert.Throws<ArgumentNullException>(() => 26Assert.Throws<ArgumentNullException>(() => 29Assert.Throws<ArgumentNullException>(() =>

Enrichment\ProcessEnricherExtensionsTests.cs (5)

20Assert.Throws<ArgumentNullException>(() => 23Assert.Throws<ArgumentNullException>(() => 26Assert.Throws<ArgumentNullException>(() => 29Assert.Throws<ArgumentNullException>(() => 32Assert.Throws<ArgumentNullException>(() =>

Latency\Internal\LatencyContextProviderTests.cs (3)

87Assert.Throws<ArgumentException>(() => tokenissuer.GetCheckpointToken("ca1")); 88Assert.Throws<ArgumentException>(() => tokenissuer.GetMeasureToken("ma1")); 89Assert.Throws<ArgumentException>(() => tokenissuer.GetTagToken("ta1"));

Latency\LatencyConsoleExtensionsTests.cs (3)

20Assert.Throws<ArgumentNullException>(() => LatencyConsoleExtensions.AddConsoleLatencyDataExporter(null!)); 21Assert.Throws<ArgumentNullException>(() => LatencyConsoleExtensions.AddConsoleLatencyDataExporter(s, configure: null!)); 22Assert.Throws<ArgumentNullException>(() => LatencyConsoleExtensions.AddConsoleLatencyDataExporter(s, section: null!));

Latency\LatencyContextExtensionTests.cs (1)

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

Logging\ExtendedLoggerFactoryTests.cs (2)

41Assert.Throws<ObjectDisposedException>(() => factory.CreateLogger("d")); 237Assert.Throws<ArgumentException>(() =>

Infrastructure\ByteArrayJsonConverterTest.cs (8)

Infrastructure\DotNetDispatcherTest.cs (6)

169var ex = Assert.Throws<InvalidOperationException>(() => 238var ex = Assert.Throws<ArgumentException>( 257var ex = Assert.Throws<ArgumentException>( 506var ex = Assert.Throws<ArgumentException>(() => DotNetDispatcher.Invoke(jsRuntime, new DotNetInvocationInfo(thisAssemblyName, methodIdentifier, 0, default), "[7]")); 521var ex = Assert.Throws<ArgumentException>(() => DotNetDispatcher.Invoke(jsRuntime, new DotNetInvocationInfo(null, methodIdentifier, 1, default), argsJson)); 535Assert.Throws<JsonException>(() =>

Infrastructure\DotNetObjectReferenceJsonConverterTest.cs (2)

23var ex = Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<DotNetObjectReference<TestModel>>(json, JsonSerializerOptions)); 37var ex = Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<DotNetObjectReference<TestModel>>(json, JsonSerializerOptions));

Infrastructure\DotNetStreamReferenceJsonConverterTest.cs (1)

26var ex = Assert.Throws<NotSupportedException>(() => JsonSerializer.Deserialize<DotNetStreamReference>(json, JsonSerializerOptions));

Infrastructure\JSObjectReferenceJsonConverterTest.cs (2)

27var ex = Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<IJSObjectReference>(json, JsonSerializerOptions)); 38var ex = Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<IJSObjectReference>(json, JsonSerializerOptions));

Infrastructure\JSStreamReferenceJsonConverterTest.cs (3)

27var ex = Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<IJSStreamReference>(json, JsonSerializerOptions)); 38var ex = Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<IJSStreamReference>(json, JsonSerializerOptions)); 72var ex = Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<IJSStreamReference>(json, JsonSerializerOptions));

JSObjectReferenceTest.cs (1)

65Assert.Throws<ObjectDisposedException>(() => jsObject.Invoke<object>("test", "arg1", "arg2"));

ColumnInferenceTests.cs (1)

54Assert.Throws<ArgumentOutOfRangeException>(() => new MLContext(1).Auto().InferColumns(DatasetUtil.GetUciAdultDataset(), 100));

OnnxTransformTests.cs (1)

417Assert.Throws<InvalidOperationException>(() => ML.Transforms.ApplyOnnxModel("softmaxout_1", "data_0", modelFile, gpuDeviceId: _gpuDeviceId, fallbackToCpu: _fallbackToCpu));

AnomalyDetectionTests.cs (1)

50Assert.Throws<ArgumentOutOfRangeException>(() => ML.AnomalyDetection.Evaluate(transformedData));

ImagesTests.cs (16)

1264Assert.Throws<ArgumentNullException>(() => MLImage.CreateFromFile(null)); 1265Assert.Throws<ArgumentException>(() => MLImage.CreateFromFile("This is Invalid Path")); 1266Assert.Throws<ArgumentNullException>(() => MLImage.CreateFromStream(null)); 1267Assert.Throws<ArgumentException>(() => MLImage.CreateFromStream(new MemoryStream(new byte[10]))); 1268Assert.Throws<ArgumentException>(() => MLImage.CreateFromPixels(10, 10, MLPixelFormat.Unknown, Array.Empty<byte>())); 1269Assert.Throws<ArgumentException>(() => MLImage.CreateFromPixels(10, 10, MLPixelFormat.Bgra32, Array.Empty<byte>())); 1270Assert.Throws<ArgumentException>(() => MLImage.CreateFromPixels(0, 10, MLPixelFormat.Bgra32, new byte[10])); 1271Assert.Throws<ArgumentException>(() => MLImage.CreateFromPixels(10, 0, MLPixelFormat.Bgra32, new byte[10])); 1272Assert.Throws<ArgumentException>(() => MLImage.CreateFromPixels(10, 10, MLPixelFormat.Bgra32, new byte[401])); 1319Assert.Throws<InvalidOperationException>(() => image.Tag); 1320Assert.Throws<InvalidOperationException>(() => image.Tag = "Something"); 1321Assert.Throws<InvalidOperationException>(() => image.Width); 1322Assert.Throws<InvalidOperationException>(() => image.Height); 1323Assert.Throws<InvalidOperationException>(() => image.PixelFormat); 1324Assert.Throws<InvalidOperationException>(() => image.BitsPerPixel); 1325Assert.Throws<InvalidOperationException>(() => image.Pixels[0]);

Scenarios\Api\TestApi.cs (1)

240Assert.Throws<ArgumentOutOfRangeException>(() => idv.Schema[1].Annotations.Schema[kindFloat]);

SvmLightTests.cs (3)

406ex = Assert.Throws<InvalidOperationException>(() => ML.Data.LoadFromSvmLightFile(path)); 443var ex = Assert.Throws<InvalidOperationException>(() => ML.Data.CreateSvmLightLoader()); 445ex = Assert.Throws<InvalidOperationException>(() => ML.Data.CreateSvmLightLoaderWithFeatureNames());

TextLoaderTests.cs (1)

584var ex = Assert.Throws<ArgumentOutOfRangeException>(() => mlContext.Data.LoadFromTextFile<ModelWithoutColumnAttribute>("fakefile.txt"));

Transformers\SelectColumnsTests.cs (1)

125Assert.Throws<ArgumentOutOfRangeException>(() => est.Fit(dataView));

LlamaTests.cs (1)

347Assert.Throws<ArgumentNullException>(() => llamaTokenizer.Decode(null!));

TiktokenTests.cs (6)

488Assert.Throws<ArgumentNullException>(() => TiktokenTokenizer.CreateForEncoding(null!)); 489Assert.Throws<ArgumentException>(() => TiktokenTokenizer.CreateForEncoding("r50k_base_")); 490Assert.Throws<ArgumentException>(() => TiktokenTokenizer.CreateForEncoding("p50k_base_")); 491Assert.Throws<ArgumentException>(() => TiktokenTokenizer.CreateForEncoding("p50k_edit_")); 492Assert.Throws<ArgumentException>(() => TiktokenTokenizer.CreateForEncoding("cl100k_base_")); 493Assert.Throws<ArgumentException>(() => TiktokenTokenizer.CreateForEncoding("o200k_base_"));

TokenizerTests.cs (4)

221Assert.Throws<ArgumentOutOfRangeException>(() => tokenizer.GetIndexByTokenCount(input, maxTokenCount: 0, out _, out _)); 222Assert.Throws<ArgumentOutOfRangeException>(() => tokenizer.GetIndexByTokenCount(input, maxTokenCount: -1, out _, out _)); 223Assert.Throws<ArgumentOutOfRangeException>(() => tokenizer.GetIndexByTokenCountFromEnd(input, maxTokenCount: 0, out _, out _)); 224Assert.Throws<ArgumentOutOfRangeException>(() => tokenizer.GetIndexByTokenCountFromEnd(input, maxTokenCount: -1, out _, out _));

CacheControlHeaderValueTest.cs (1)

575Assert.Throws<FormatException>(() => CacheControlHeaderValue.Parse(input));

ContentDispositionHeaderValueTest.cs (6)

14Assert.Throws<ArgumentException>(() => new ContentDispositionHeaderValue(null)); 21Assert.Throws<ArgumentException>(() => new ContentDispositionHeaderValue(string.Empty)); 382Assert.Throws<ArgumentOutOfRangeException>(() => contentDisposition.Size = -279172874240); 636Assert.Throws<FormatException>(() => ContentDispositionHeaderValue.Parse(input)); 687Assert.Throws<FormatException>(() => ContentDispositionHeaderValue.Parse(input)); 704Assert.Throws<FormatException>(() => new ContentDispositionHeaderValue(contentDisposition));

ContentRangeHeaderValueTest.cs (16)

CookieHeaderValueTest.cs (5)

154Assert.Throws<ArgumentNullException>(() => new CookieHeaderValue(null, "value")); 161Assert.Throws<ArgumentException>(() => new CookieHeaderValue(name, "value")); 168Assert.Throws<ArgumentException>(() => new CookieHeaderValue("name", value)); 231Assert.Throws<FormatException>(() => CookieHeaderValue.Parse(value)); 305Assert.Throws<FormatException>(() => CookieHeaderValue.ParseStrictList(input));

EntityTagHeaderValueTest.cs (5)

11Assert.Throws<ArgumentException>(() => new EntityTagHeaderValue(null)); 13Assert.Throws<ArgumentException>(() => new EntityTagHeaderValue(string.Empty)); 442Assert.Throws<FormatException>(() => EntityTagHeaderValue.ParseStrictList(inputs)); 501Assert.Throws<FormatException>(() => EntityTagHeaderValue.Parse(input)); 518Assert.Throws<FormatException>(() => new EntityTagHeaderValue(tag));

HeaderUtilitiesTest.cs (1)

115Assert.Throws<ArgumentOutOfRangeException>(() => HeaderUtilities.FormatNonNegativeInt64(value));

MediaTypeHeaderValueTest.cs (8)

13Assert.Throws<ArgumentException>(() => new MediaTypeHeaderValue(null)); 15Assert.Throws<ArgumentException>(() => new MediaTypeHeaderValue(string.Empty)); 185Assert.Throws<NotSupportedException>(() => mediaType1.Parameters.Remove(new NameValueHeaderValue("name"))); 316Assert.Throws<ArgumentOutOfRangeException>(() => new MediaTypeHeaderValue("application/xml", -0.01)); 323Assert.Throws<ArgumentOutOfRangeException>(() => mediaType.Quality = 1.01); 643Assert.Throws<FormatException>(() => MediaTypeHeaderValue.ParseStrictList(inputs)); 928Assert.Throws<FormatException>(() => MediaTypeHeaderValue.Parse(input)); 945Assert.Throws<FormatException>(() => new MediaTypeHeaderValue(mediaType));

NameValueHeaderValueTest.cs (5)

11Assert.Throws<ArgumentException>(() => new NameValueHeaderValue(null)); 13Assert.Throws<ArgumentException>(() => new NameValueHeaderValue(string.Empty)); 512Assert.Throws<FormatException>(() => NameValueHeaderValue.ParseStrictList(inputs)); 658Assert.Throws<FormatException>(() => NameValueHeaderValue.Parse(input)); 681Assert.Throws<FormatException>(() => new NameValueHeaderValue(name, value));

RangeConditionHeaderValueTest.cs (3)

16Assert.Throws<ArgumentNullException>(() => new RangeConditionHeaderValue(input)); 26Assert.Throws<ArgumentException>(() => new RangeConditionHeaderValue((string?)null)); 120Assert.Throws<FormatException>(() => RangeConditionHeaderValue.Parse(input));

RangeHeaderValueTest.cs (7)

11Assert.Throws<ArgumentOutOfRangeException>(() => new RangeHeaderValue(5, 2)); 21Assert.Throws<ArgumentException>(() => range.Unit = null); 22Assert.Throws<ArgumentException>(() => range.Unit = ""); 23Assert.Throws<FormatException>(() => range.Unit = " x"); 24Assert.Throws<FormatException>(() => range.Unit = "x "); 25Assert.Throws<FormatException>(() => range.Unit = "x y"); 160Assert.Throws<FormatException>(() => RangeHeaderValue.Parse(input));

RangeItemHeaderValueTest.cs (4)

11Assert.Throws<ArgumentException>(() => new RangeItemHeaderValue(null, null)); 17Assert.Throws<ArgumentOutOfRangeException>(() => new RangeItemHeaderValue(-1, null)); 23Assert.Throws<ArgumentOutOfRangeException>(() => new RangeItemHeaderValue(2, 1)); 29Assert.Throws<ArgumentOutOfRangeException>(() => new RangeItemHeaderValue(null, -1));

SetCookieHeaderValueTest.cs (5)

300Assert.Throws<ArgumentNullException>(() => new SetCookieHeaderValue(null, "value")); 307Assert.Throws<ArgumentException>(() => new SetCookieHeaderValue(name, "value")); 314Assert.Throws<ArgumentException>(() => new SetCookieHeaderValue("name", value)); 388Assert.Throws<FormatException>(() => SetCookieHeaderValue.Parse(value)); 474Assert.Throws<FormatException>(() => SetCookieHeaderValue.ParseStrictList(input));

StringWithQualityHeaderValueTest.cs (10)

InteractionTests.cs (2)

101_ = Assert.Throws<ArgumentNullException>(() => Interaction.Shell(null)).ToString(); 109_ = Assert.Throws<FileNotFoundException>(() => Interaction.Shell(path)).ToString();

Microsoft\VisualBasic\ApplicationServices\ApplicationBaseTests.cs (1)

59var ex = Assert.Throws<ArgumentException>(() => app.GetEnvironmentVariable($"{key}z"));

Microsoft\VisualBasic\Devices\MouseTests.cs (3)

28Assert.Throws<InvalidOperationException>(() => mouse.ButtonsSwapped); 46Assert.Throws<InvalidOperationException>(() => mouse.WheelExists); 67Assert.Throws<InvalidOperationException>(() => mouse.WheelScrollLines);

Microsoft\VisualBasic\Devices\NetworkTests.cs (1)

38Assert.Throws<ArgumentNullException>(() => network.Ping((string)null));

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

31Assert.Throws<ArgumentNullException>(() => _fileSystem.CombinePath(null, "Test2")); 32Assert.Throws<ArgumentNullException>(() => _fileSystem.CombinePath("", "Test2"));

Microsoft\VisualBasic\MyServices\Internal\ContextValueTests.cs (1)

12Assert.Throws<NullReferenceException>(() => (new ContextValue<int>()).Value);

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

27Assert.Throws<ArgumentException>(() => registry.GetValue(keyName, "", null));

CodeModel\FileCodeClassTests.cs (11)

CodeModel\FileCodeFunctionTests.cs (13)

CodeModel\FileCodeImportTests.cs (16)

CodeModel\FileCodeNamespaceTests.cs (14)

CodeModel\FileCodeVariableTests.cs (14)

BinaryFormat\DataObjectTests.cs (1)

33Assert.Throws<System.Runtime.InteropServices.COMException>(() => ClipboardDataObject.GetData(DataFormats.Serializable));

Data.Validation\LengthAttributeTests.cs (5)

343Assert.Throws<InvalidOperationException>(() => _ = Validator.TryValidateObject(options0, context, results, true)); 348Assert.Throws<InvalidOperationException>(() => _ = Validator.TryValidateObject(options1, context, results, true)); 353Assert.Throws<InvalidOperationException>(() => _ = Validator.TryValidateObject(options2, context, results, true)); 358Assert.Throws<InvalidOperationException>(() => _ = Validator.TryValidateObject(options3, context, results, true)); 363Assert.Throws<InvalidOperationException>(() => _ = Validator.TryValidateObject(options4, context, results, true));

Data.Validation\TimeSpanAttributeTests.cs (3)

230Assert.Throws<InvalidOperationException>(() => _ = Validator.TryValidateObject(options0, context, results, true)); 235Assert.Throws<InvalidOperationException>(() => _ = Validator.TryValidateObject(options1, context, results, true)); 240Assert.Throws<InvalidOperationException>(() => _ = Validator.TryValidateObject(options3, context, results, true));

EmptyCollections\EmptyReadonlyDictionaryTests.cs (2)

46Assert.Throws<KeyNotFoundException>(() => dict[1]); 47Assert.Throws<NotSupportedException>(() => dict[1] = "One");

EmptyCollections\EmptyReadOnlyListTests.cs (2)

48Assert.Throws<InvalidOperationException>(() => enumerator.Current); 49Assert.Throws<InvalidOperationException>(() => ((IEnumerator)enumerator).Current);

src\Servers\Kestrel\test\FunctionalTests\Http2\HandshakeTests.cs (1)

48var ex = Assert.Throws<NotSupportedException>(() => new TestServer(context =>

src\Servers\Kestrel\test\FunctionalTests\RequestTests.cs (1)

720Assert.Throws<SocketException>(() => socket.Receive(new byte[32]));

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

114Assert.Throws<InvalidOperationException>(() => bmp.LockBits(r, ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb)); 355public void FileDoesNotExists() => Assert.Throws<ArgumentException>(() => new Bitmap("FileDoesNotExists.jpg"));

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

426Assert.Throws<ArgumentException>(() => g.Transform = matrix); 1596Assert.Throws<ArgumentNullException>(() => g.MeasureString("a", null)); 1597Assert.Throws<ArgumentNullException>(() => g.MeasureString("a".AsSpan(), null)); 1884Assert.Throws<ArgumentNullException>(() => g.MeasureCharacterRanges("a", null, default, null)); 1885Assert.Throws<ArgumentNullException>(() => g.MeasureCharacterRanges("a".AsSpan(), null, default, null)); 2000Assert.Throws<ArgumentException>(() => g.MeasureCharacterRanges("Mono", _font, default, null)); 2001Assert.Throws<ArgumentException>(() => g.MeasureCharacterRanges("Mono".AsSpan(), _font, default, null));

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

146Assert.Throws<ArgumentException>(() => header.WmfHeader);

System\Drawing\BitmapTests.cs (13)

System\Drawing\BufferedGraphicsContextTests.cs (2)

166Assert.Throws<InvalidOperationException>(() => context.Allocate(graphics, largeRectangle)); 167Assert.Throws<InvalidOperationException>(() => context.Allocate(graphics, Rectangle.Empty));

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

29Assert.Throws<OverflowException>(() => new Blend(-1)); 35Assert.Throws<OutOfMemoryException>(() => new Blend(int.MaxValue));

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

29Assert.Throws<OverflowException>(() => new ColorBlend(-1)); 35Assert.Throws<OutOfMemoryException>(() => new ColorBlend(int.MaxValue));

System\Drawing\Drawing2D\CustomLineCapTests.cs (1)

83Assert.Throws<NotImplementedException>(() => new CustomLineCap(fillPath, null));

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

293Assert.Throws<ArgumentNullException>(() => gpi.Enumerate(ref points, ref types)); 311Assert.Throws<ArgumentNullException>(() => gpi.CopyData(ref points, ref types, 0, 1));

System\Drawing\Drawing2D\LinearGradientBrushTests.cs (8)

69Assert.Throws<OutOfMemoryException>(() => new LinearGradientBrush(new Point(x, y), new Point(x, y), Color.Fuchsia, Color.GhostWhite)); 70Assert.Throws<OutOfMemoryException>(() => new LinearGradientBrush(new PointF(x, y), new PointF(x, y), Color.Fuchsia, Color.GhostWhite)); 312Assert.Throws<ArgumentNullException>(() => brush.Blend = null); 319Assert.Throws<ArgumentNullException>(() => brush.Blend = new Blend { Factors = null }); 419Assert.Throws<NullReferenceException>(() => brush.InterpolationColors = new ColorBlend { Colors = null }); 437Assert.Throws<ArgumentException>(() => brush.InterpolationColors = new ColorBlend { Colors = new Color[2], Positions = null }); 543Assert.Throws<NullReferenceException>(() => brush.LinearColors = null); 552Assert.Throws<IndexOutOfRangeException>(() => brush.LinearColors = new Color[length]);

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

147Assert.Throws<OutOfMemoryException>(() => new Matrix(new Rectangle(1, 1, 0, 1), new Point[3])); 148Assert.Throws<OutOfMemoryException>(() => new Matrix(new RectangleF(1, 1, 0, 1), new PointF[3])); 154Assert.Throws<OutOfMemoryException>(() => new Matrix(new Rectangle(1, 1, 1, 0), new Point[3])); 155Assert.Throws<OutOfMemoryException>(() => new Matrix(new RectangleF(1, 1, 1, 0), new PointF[3]));

System\Drawing\Drawing2D\PathGradientBrushTests.cs (12)

78Assert.Throws<ArgumentException>(() => new PathGradientBrush(new Point[pointsLength])); 79Assert.Throws<ArgumentException>(() => new PathGradientBrush(new Point[pointsLength], WrapMode.Clamp)); 80Assert.Throws<ArgumentException>(() => new PathGradientBrush(new PointF[pointsLength])); 81Assert.Throws<ArgumentException>(() => new PathGradientBrush(new PointF[pointsLength], WrapMode.Clamp)); 113Assert.Throws<OutOfMemoryException>(() => new PathGradientBrush(path)); 115Assert.Throws<OutOfMemoryException>(() => new PathGradientBrush(path)); 325Assert.Throws<ArgumentNullException>(() => brush.Blend = null); 326Assert.Throws<ArgumentNullException>(() => brush.Blend = new Blend() { Factors = null, Positions = null }); 575Assert.Throws<ArgumentNullException>(() => brush.InterpolationColors = null); 582Assert.Throws<NullReferenceException>(() => 585Assert.Throws<NullReferenceException>(() => 624Assert.Throws<ArgumentException>(() =>

System\Drawing\FontConverterTests.cs (2)

35Assert.Throws<NotSupportedException>(() => converter.ConvertFrom(null)); 36Assert.Throws<NotSupportedException>(() => converter.ConvertFrom(1));

System\Drawing\FontTests.cs (1)

308Assert.Throws<NullReferenceException>(() => new Font(null, FontStyle.Regular));

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

30Assert.Throws<InvalidOperationException>(() => graphics.TransformElements); 31Assert.Throws<InvalidOperationException>(() => graphics.TransformElements = Matrix3x2.Identity);

System\Drawing\GraphicsTests.cs (30)

System\Drawing\IconConverterTests.cs (26)

System\Drawing\IconTests.cs (8)

260Assert.Throws<NullReferenceException>(() => new Icon(null, "48x48_multiple_entries_4bit.ico")); 307Assert.Throws<ObjectDisposedException>(() => icon.Handle); 316Assert.Throws<ObjectDisposedException>(() => icon.Handle); 394Assert.Throws<FileNotFoundException>(() => Icon.ExtractAssociatedIcon("http://microsoft.com")); 413Assert.Throws<FileNotFoundException>(() => Icon.ExtractAssociatedIcon("no-such-file.png")); 709Assert.Throws<ObjectDisposedException>(() => icon.Width); 710Assert.Throws<ObjectDisposedException>(() => icon.Height); 711Assert.Throws<ObjectDisposedException>(() => icon.Size);

System\Drawing\ImageConverterTests.cs (28)

System\Drawing\ImageFormatConverterTests.cs (22)

System\Drawing\ImageTests.cs (8)

496Assert.Throws<OutOfMemoryException>(() => Image.FromFile(file.Path)); 497Assert.Throws<OutOfMemoryException>(() => Image.FromFile(file.Path, useEmbeddedColorManagement: true)); 522Assert.Throws<PathTooLongException>(() => Image.FromFile(fileName)); 523Assert.Throws<PathTooLongException>(() => Image.FromFile(fileName, 530Assert.Throws<FileNotFoundException>(() => Image.FromFile(fileName)); 531Assert.Throws<FileNotFoundException>(() => Image.FromFile(fileName, 539Assert.Throws<FileNotFoundException>(() => Image.FromFile("NoSuchFile")); 540Assert.Throws<FileNotFoundException>(() => Image.FromFile("NoSuchFile", useEmbeddedColorManagement: true));

System\Drawing\Imaging\CachedBitmapTests.cs (2)

15Assert.Throws<ArgumentNullException>(() => new CachedBitmap(bitmap, null)); 16Assert.Throws<ArgumentNullException>(() => new CachedBitmap(null, graphics));

System\Drawing\Imaging\EncoderParameterTests.cs (15)

System\Drawing\Imaging\MetafileTests.cs (16)

System\Drawing\PenTests.cs (3)

325Assert.Throws<ArgumentNullException>(() => pen.CompoundArray = null); 600Assert.Throws<InvalidOperationException>(() => pen.DashPattern); 1214Assert.Throws<InvalidOperationException>(() => pen.DashPattern);

System\Drawing\Printing\MarginsConverterTests.cs (7)

56Assert.Throws<ArgumentException>(() => mc.CreateInstance(context, values)); 109Assert.Throws<NotSupportedException>(() => mc.ConvertFrom(context, null, null)); 110Assert.Throws<NotSupportedException>(() => mc.ConvertFrom(context, culture, null)); 111Assert.Throws<NotSupportedException>(() => mc.ConvertFrom(context, culture, Guid.NewGuid())); 139Assert.Throws<NotSupportedException>(() => mc.ConvertTo(context, culture, new object(), typeof(object))); 140Assert.Throws<NotSupportedException>(() => mc.ConvertTo(context, culture, 12, typeof(int))); 141Assert.Throws<NotSupportedException>(() => mc.ConvertTo(context, culture, guid, typeof(Guid)));

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

37Assert.Throws<NullReferenceException>(() => controller.OnStartPage(null, e)); 45Assert.Throws<NullReferenceException>(() => controller.OnStartPage(document, null)); 56Assert.Throws<NullReferenceException>(() => controller.OnStartPage(document, printEventArgs)); 65Assert.Throws<NullReferenceException>(() => controller.OnStartPage(document, e));

System\Drawing\Printing\PrinterSettingsTests.cs (3)

503Assert.Throws<NullReferenceException>(() => printerSettings.CreateMeasurementGraphics(null)); 504Assert.Throws<NullReferenceException>(() => printerSettings.CreateMeasurementGraphics(null, true)); 528Assert.Throws<NullReferenceException>(() => printerSettings.GetHdevmode(null));

System\Drawing\RegionTests.cs (3)

142Assert.Throws<ExternalException>(() => new Region(regionData)); 151Assert.Throws<ExternalException>(() => new Region(regionData)); 160Assert.Throws<NullReferenceException>(() => new Region(regionData));

System\Drawing\SystemIconsTests.cs (1)

52Assert.Throws<ArgumentException>(() => SystemIcons.GetStockIcon((StockIconId)(-1)));

System\Drawing\TextureBrushTests.cs (6)

291Assert.Throws<OutOfMemoryException>(() => new TextureBrush(image, rectangle)); 292Assert.Throws<OutOfMemoryException>(() => new TextureBrush(image, (RectangleF)rectangle)); 293Assert.Throws<OutOfMemoryException>(() => new TextureBrush(image, WrapMode.Tile, rectangle)); 294Assert.Throws<OutOfMemoryException>(() => new TextureBrush(image, WrapMode.Tile, (RectangleF)rectangle)); 295Assert.Throws<OutOfMemoryException>(() => new TextureBrush(image, rectangle, null)); 296Assert.Throws<OutOfMemoryException>(() => new TextureBrush(image, (RectangleF)rectangle, null));

Channels\HttpRequestMessagePropertyTest.cs (2)

67Assert.Throws<ArgumentNullException>(() => requestMsgProperty.Method = null); 83Assert.Throws<ArgumentNullException>(() => requestMsgProperty.QueryString = null);

Channels\WebSocketTransportSettingsTest.cs (2)

17Assert.Throws<PlatformNotSupportedException>(() => setting.DisablePayloadMasking = true); 25Assert.Throws<PlatformNotSupportedException>(() => disablePayloadMasking = setting.DisablePayloadMasking);

ServiceModel\BasicHttpBindingTest.cs (11)

ServiceModel\BasicHttpsBindingTest.cs (12)

ServiceModel\BasicHttpSecurityTest.cs (1)

22Assert.Throws<PlatformNotSupportedException>(() => security.Mode = value);

ServiceModel\HttpIdentityTests.cs (2)

20Assert.Throws<InvalidOperationException>(() => channel.Echo("")); 32Assert.Throws<InvalidOperationException>(() => channel.Echo(""));

Channels\TcpConnectionPoolSettingsTest.cs (4)

32Assert.Throws<ArgumentNullException>(() => settings.GroupName = null); 53Assert.Throws<ArgumentOutOfRangeException>(() => settings.IdleTimeout = timeSpan); 74Assert.Throws<ArgumentOutOfRangeException>(() => settings.LeaseTimeout = timeSpan); 96Assert.Throws<ArgumentOutOfRangeException>(() => settings.MaxOutboundConnectionsPerEndpoint = value);

ServiceModel\NetTcpBindingTest.cs (3)

68Assert.Throws<ArgumentOutOfRangeException>(() => binding.MaxBufferSize = value); 87Assert.Throws<ArgumentOutOfRangeException>(() => binding.MaxReceivedMessageSize = value); 103Assert.Throws<ArgumentNullException>(() => binding.Security = null);

ServiceModel\NetTcpSecurityTest.cs (1)

37Assert.Throws<ArgumentOutOfRangeException>(() => security.Mode = (SecurityMode)999);

ServiceModel\TcpTransportSecurityTest.cs (1)

38Assert.Throws<ArgumentOutOfRangeException>(() => transport.ClientCredentialType = (TcpClientCredentialType)999);

Channels\BinaryMessageEncodingBindingElementTest.cs (5)

58Assert.Throws<ArgumentOutOfRangeException>(() => bindingElement.MaxSessionSize = value); 75Assert.Throws<InvalidOperationException>(() => bindingElement.MessageVersion = version); 82Assert.Throws<ArgumentNullException>(() => bindingElement.MessageVersion = null); 109Assert.Throws<ArgumentOutOfRangeException>(() => bindingElement.MaxReadPoolSize = value); 136Assert.Throws<ArgumentOutOfRangeException>(() => bindingElement.MaxWritePoolSize = value);

Channels\CustomChannelTest.cs (2)

468Assert.Throws<InvalidOperationException>(() => factory.CreateChannel()); 722Assert.Throws<InvalidOperationException>(() => channel.Process(inputMessage));

Channels\TextMessageEncodingBindingElementTest.cs (2)

37Assert.Throws<ArgumentException>(() => element.WriteEncoding = encoding); 53Assert.Throws<ArgumentNullException>(() => element.MessageVersion = null);

IdentityModel\SecurityTokenSerializerTest.cs (9)

Security\SecurityTokenRequirementTest.cs (1)

47Assert.Throws<ArgumentException>(() => tokenrequirement.TryGetProperty(tokenrequirement.TokenType, out int Tvalue));

ServiceModel\ClientBaseTest.cs (6)

46Assert.Throws<InvalidOperationException>(() => MyClientBase.CacheSetting = CacheSetting.AlwaysOn); 67Assert.Throws<InvalidOperationException>(() => MyClientBase.CacheSetting = CacheSetting.AlwaysOn); 96Assert.Throws<InvalidOperationException>(() => MyClientBase2.CacheSetting = CacheSetting.Default); 132Assert.Throws<InvalidOperationException>(() => MyClientBase2.CacheSetting = CacheSetting.Default); 152Assert.Throws<InvalidOperationException>(() => MyClientBase.CacheSetting = CacheSetting.AlwaysOn); 173Assert.Throws<InvalidOperationException>(() => MyClientBase.CacheSetting = CacheSetting.AlwaysOn);

ServiceModel\MessageContractTest.cs (2)

52Assert.Throws<ArgumentOutOfRangeException>(() => messageCA.WrapperName = wrapperName); 60Assert.Throws<ArgumentNullException>(() => messageCA.WrapperName = wrapperName);

ServiceModel\UnixDomainSocketBindingTest.cs (3)

69Assert.Throws<ArgumentOutOfRangeException>(() => binding.MaxBufferSize = value); 88Assert.Throws<ArgumentOutOfRangeException>(() => binding.MaxReceivedMessageSize = value); 104Assert.Throws<ArgumentNullException>(() => binding.Security = null);

ServiceModel\UnixDomainSocketSecurityTest.cs (1)

37Assert.Throws<ArgumentOutOfRangeException>(() => security.Mode = (UnixDomainSocketSecurityMode)999);

ServiceModel\UnixDomainSocketTransportSecurityTest.cs (1)

40Assert.Throws<ArgumentOutOfRangeException>(() => transport.ClientCredentialType = (UnixDomainSocketClientCredentialType)999);

Serialization\TypeCodeDomSerializerTests.cs (4)

21Assert.Throws<ArgumentNullException>(() => underTest.Serialize(null, null, null)); 29Assert.Throws<ArgumentNullException>(() => underTest.Serialize(mockSerializationManager.Object, null, null)); 36Assert.Throws<ArgumentNullException>(() => underTest.Deserialize(null, null)); 44Assert.Throws<ArgumentNullException>(() => underTest.Deserialize(mockSerializationManager.Object, null));

System\ComponentModel\Design\ArrayEditorTests.cs (1)

130TargetInvocationException ex = Assert.Throws<TargetInvocationException>(() => editor.GetDisplayText(new ClassWithNonStringDefaultProperty()));

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

812TargetInvocationException ex = Assert.Throws<TargetInvocationException>(() => editor.GetDisplayText(new ClassWithNonStringDefaultProperty())); 930Assert.Throws<NotSupportedException>(() => editor.SetItems(new object[1], new object[1]));

System\ComponentModel\Design\CollectionFormTests.cs (1)

382Assert.Throws<StackOverflowException>(() => form.Items = value);

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

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

44Assert.Throws<InvalidCastException>(() => mockSet.Object.Verbs); 65Assert.Throws<InvalidCastException>(() => mockSet.Object.ActionLists);

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

1452Assert.Throws<InvalidOperationException>(() => component1.Site.Name = "name2"); 1453Assert.Throws<InvalidOperationException>(() => component1.Site.Name = "NAME2");

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

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

41Assert.Throws<ArgumentException>(() => new ExceptionCollection(exceptions));

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

705Assert.Throws<PlatformNotSupportedException>(() => service.LoadStore(null));

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

System\Drawing\Design\ImageEditorTests.cs (1)

146Assert.Throws<ArgumentException>(() => editor.LoadFromStream(stream));

System\Drawing\Design\MetafileEditorTests.cs (1)

60Assert.Throws<ExternalException>(() => editor.LoadFromStream(stream));

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

591Assert.Throws<InvalidOperationException>(() => item.CreateComponents(mockDesignerHost.Object)); 595Assert.Throws<InvalidOperationException>(() => item.CreateComponents(mockDesignerHost.Object, null)); 599Assert.Throws<InvalidOperationException>(() => item.CreateComponents(mockDesignerHost.Object, new Hashtable())); 607Assert.Throws<InvalidOperationException>(() => item.CreateComponents(mockDesignerHost.Object)); 914Assert.Throws<InvalidOperationException>(() => item.CreateComponentsCore(mockDesignerHost.Object, null)); 918Assert.Throws<InvalidOperationException>(() => item.CreateComponentsCore(mockDesignerHost.Object, new Hashtable())); 1321Assert.Throws<ArgumentException>(() => item.GetType(mockDesignerHost.Object, new AssemblyName(), "typeName", false)); 1322Assert.Throws<ArgumentException>(() => item.GetType(null, new AssemblyName(), "typeName", false));

System\Resources\Tools\StronglyTypedResourceBuilderTests.cs (1)

180Assert.Throws<ArgumentException>(() => StronglyTypedResourceBuilder.Create(

System\Windows\Forms\Design\DataMemberFieldConverterTests.cs (1)

45Assert.Throws<NotSupportedException>(

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

24Assert.Throws<ArgumentNullException>(() => service.GetHandler(null));

Interop\Oleaut32\VARIANTTests.cs (3)

5662Assert.Throws<ArgumentException>(() => Marshal.GetObjectForNativeVariant(pv)); 5759Assert.Throws<T>(() => Marshal.GetObjectForNativeVariant(pv)); 5772Assert.Throws<T>(() => Marshal.GetObjectForNativeVariant(pv));

Extensions\AssertExtensions.cs (2)

61T exception = Assert.Throws<T>(testCode); 131T exception = Assert.Throws<T>(testCode);

BindingNavigatorTests.cs (1)

43ArgumentNullException ex = Assert.Throws<ArgumentNullException>(() => new BindingNavigator(nullContainer));

CheckedListBoxTests.cs (2)

111ArgumentException ex = Assert.Throws<ArgumentException>(() => box.SelectionMode = expected); 259ArgumentOutOfRangeException ex = Assert.Throws<ArgumentOutOfRangeException>(() => box.GetItemCheckState(index));

ContextMenuStripTests.cs (1)

27ArgumentNullException ex = Assert.Throws<ArgumentNullException>(() => new ContextMenuStrip(nullContainer));

SerializableTypesTests.cs (3)

312Assert.Throws<NullReferenceException>(() => result.ColumnCount); 313Assert.Throws<NullReferenceException>(() => result.GrowStyle); 314Assert.Throws<NullReferenceException>(() => result.RowCount);

System\Resources\ResXResourceReaderTests.cs (1)

50Assert.Throws<ArgumentException>(resxReader.GetEnumerator);

System\Windows\Forms\AccessibleObjects\ButtonBase.ButtonBaseAccessibleObjectTests.cs (2)

14Assert.Throws<ArgumentException>(() => new ButtonBase.ButtonBaseAccessibleObject(null)); 21Assert.Throws<ArgumentException>(() => new ButtonBase.ButtonBaseAccessibleObject(textBox));

System\Windows\Forms\AccessibleObjects\CheckBox.CheckBoxAccessibleObjectTests.cs (2)

15Assert.Throws<ArgumentException>(() => new CheckBoxAccessibleObject(null)); 22Assert.Throws<ArgumentException>(() => new CheckBoxAccessibleObject(textBox));

System\Windows\Forms\AccessibleObjects\ComboBox.ChildAccessibleObjectTests.cs (1)

11Assert.Throws<ArgumentNullException>(() => new ComboBox.ChildAccessibleObject(null, IntPtr.Zero));

System\Windows\Forms\AccessibleObjects\Control.ControlAccessibleObjectTests.cs (5)

1049Assert.Throws<InvalidOperationException>(() => accessibleObject.RaiseLiveRegionChanged()); 1436Assert.Throws<ArgumentException>(() => toolStrip.Items.Add(host)); 1503Assert.Throws<ArgumentException>(() => toolStrip.Items.Add(host)); 1540Assert.Throws<ArgumentException>(() => toolStrip.Items.Add(host)); 1577Assert.Throws<ArgumentException>(() => toolStrip.Items.Add(host));

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

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

105Assert.Throws<InvalidOperationException>(()

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

21Assert.Throws<InvalidOperationException>(() => new DataGridViewColumnHeaderCellAccessibleObject(null).Parent);

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

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

21Assert.Throws<InvalidOperationException>(() => new DataGridViewRowHeaderCellAccessibleObject(null).Parent);

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

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

System\Windows\Forms\AccessibleObjects\ListViewItem.ListViewItemAccessibleObjectTests.cs (2)

1760Assert.Throws<InvalidOperationException>(() => accessibleObject.GetChild(0)); 1793Assert.Throws<InvalidOperationException>(() => accessibleObject.GetChildCount());

System\Windows\Forms\AccessibleObjects\ListViewItem.ListViewItemBaseAccessibleObjectTests.cs (1)

16Assert.Throws<ArgumentNullException>(() => new SubListViewItemBaseAccessibleObject(null));

System\Windows\Forms\AccessibleObjects\MonthCalendar.MonthCalendarChildAccessibleObjectTests.cs (1)

15Assert.Throws<ArgumentNullException>(() => new SubObject(null));

System\Windows\Forms\AccessibleObjects\RadioButton.RadioButtonAccessibleObjectTests.cs (1)

15Assert.Throws<ArgumentNullException>(() => new RadioButtonAccessibleObject(null));

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

13Assert.Throws<ArgumentNullException>(() => new ToolStripDropDownItemAccessibleObject(null));

System\Windows\Forms\AccessibleObjects\ToolStripTextBox.ToolStripTextBoxControlAccessibleObjectTests.cs (1)

30Assert.Throws<TargetInvocationException>(() => Activator.CreateInstance(type, (Control)null));

System\Windows\Forms\AccessibleObjects\TrackBar.TrackBarAccessibleObjectTests.cs (1)

116Assert.Throws<COMException>(() => accessibilityObject.Value = value);

System\Windows\Forms\AccessibleObjects\TrackBar.TrackBarChildAccessibleObjectTests.cs (1)

15Assert.Throws<ArgumentNullException>(() => new SubTrackBarChildAccessibleObject(null));

System\Windows\Forms\AutoCompleteStringCollectionTests.cs (12)

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

732Assert.Throws<TargetInvocationException>(() => property.GetValue(new object()));

System\Windows\Forms\AxHost.ConnectionPointCookieTests.cs (5)

37Assert.Throws<InvalidCastException>(() => new AxHost.ConnectionPointCookie(source, null, null)); 38Assert.Throws<InvalidCastException>(() => new AxHost.ConnectionPointCookie(source, new object(), typeof(int))); 46Assert.Throws<NullReferenceException>(() => new AxHost.ConnectionPointCookie(source, null, null)); 58Assert.Throws<InvalidCastException>(() => new AxHost.ConnectionPointCookie(source, null, eventInterface)); 74Assert.Throws<InvalidCastException>(() => new AxHost.ConnectionPointCookie(source, sink, eventInterface));

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

225Assert.Throws<FormatException>(() => new SubAxHost(clsid)); 1440Assert.Throws<InvalidCastException>(() => SubAxHost.GetFontFromIFont(new object())); 1655Assert.Throws<COMException>(() => SubAxHost.GetIPictureDispFromPicture(original)); 1723Assert.Throws<COMException>(() => SubAxHost.GetIPictureFromPicture(original)); 1735Assert.Throws<InvalidCastException>(() => SubAxHost.GetPictureFromIPicture(new object()));

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

14Assert.Throws<NullReferenceException>(() => collection.Count);

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

538Assert.Throws<ArgumentException>(() => context[dataSource, "Property"]); 566Assert.Throws<ArgumentException>(() => context[dataSource, dataMember]);

System\Windows\Forms\BindingSourceTests.cs (7)

25Assert.Throws<IndexOutOfRangeException>(() => source.CurrencyManager.Current); 84Assert.Throws<IndexOutOfRangeException>(() => source.CurrencyManager.Current); 149Assert.Throws<IndexOutOfRangeException>(() => source.CurrencyManager.Current); 414Assert.Throws<IndexOutOfRangeException>(() => source.CurrencyManager.Current); 465Assert.Throws<NotSupportedException>(() => new BindingSource(dataSource, "dataMember")); 471Assert.Throws<ArgumentException>(() => new BindingSource(new DataClass(), "NoSuchProperty")); 488Assert.Throws<IndexOutOfRangeException>(() => source.CurrencyManager.Current);

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

96Assert.Throws<NullReferenceException>(() => control.PreferredSize); 3027Assert.Throws<ArgumentException>(() => control.Parent = control); 5018Assert.Throws<NullReferenceException>(() => control.GetPreferredSize(proposedSize)); 5022Assert.Throws<NullReferenceException>(() => control.GetPreferredSize(proposedSize)); 5045Assert.Throws<NullReferenceException>(() => control.GetPreferredSize(proposedSize)); 5052Assert.Throws<NullReferenceException>(() => control.GetPreferredSize(proposedSize));

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

98Assert.Throws<NotSupportedException>(() => collection[index] = new ColumnHeader());

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

31Assert.Throws<NotSupportedException>(() => converter.ConvertFrom(value)); 107Assert.Throws<ArgumentException>(() => converter.ConvertTo(value, typeof(InstanceDescriptor))); 130Assert.Throws<NotSupportedException>(() => converter.ConvertTo(1, typeof(InstanceDescriptor))); 139Assert.Throws<NotSupportedException>(() => converter.ConvertTo(new ColumnHeader(), destinationType));

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

498Assert.Throws<InvalidOperationException>(() => header.ImageIndex = 0); 712Assert.Throws<InvalidOperationException>(() => header.ImageKey = "Key");

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

116Assert.Throws<ArgumentException>(() => comboBoxObjectCollection.Add("a")); 1373Assert.Throws<ArgumentException>(() => comboBoxObjectCollection[0] = 1); 1394Assert.Throws<InvalidOperationException>(() => enumerator.Current); 1397Assert.Throws<InvalidOperationException>(() => enumerator.Current); 1401Assert.Throws<InvalidOperationException>(() => enumerator.Current); 1429Assert.Throws<InvalidOperationException>(() => enumerator.Current); 1435Assert.Throws<InvalidOperationException>(() => enumerator.Current); 1439Assert.Throws<InvalidOperationException>(() => enumerator.Current);

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

224Assert.Throws<Win32Exception>(() => dialog.ShowDialog(owner.Object));

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

82Assert.Throws<ArgumentNullException>(() => ControlPaint.CreateHBitmap16Bit(null, Color.Red)); 193Assert.Throws<ArgumentNullException>(() => ControlPaint.CreateHBitmapColorMask(null, IntPtr.Zero));

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

1581Assert.Throws<ArgumentException>(() => collection.GetChildIndex(child)); 1582Assert.Throws<ArgumentException>(() => collection.GetChildIndex(child));

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

3907DivideByZeroException exception = Assert.Throws<DivideByZeroException>(() => control.Invoke((MethodInvoker)FaultingMethod)); 4026var exception = Assert.Throws<DivideByZeroException>(() => control.Invoke((MethodInvoker)FaultingMethod)); 4093var exception = Assert.Throws<DivideByZeroException>(() => control.Invoke((MethodInvoker)FaultingMethod)); 4133Assert.Throws<InvalidOperationException>(() => control.Invoke(method, Array.Empty<object>())); 4142Assert.Throws<TargetParameterCountException>(() => control.Invoke(method)); 4143Assert.Throws<TargetParameterCountException>(() => control.Invoke(method, null)); 4144Assert.Throws<TargetParameterCountException>(() => control.Invoke(method, Array.Empty<object>()));

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

291Assert.Throws<InvalidOperationException>(() => control.AllowDrop = true); 1598Assert.Throws<ArgumentException>(() => control.BackColor = Color.FromArgb(254, 1, 2, 3)); 9808Assert.Throws<ArgumentException>(() => control.Parent = control); 9819Assert.Throws<ArgumentException>(() => control.Parent = child); 9830Assert.Throws<ArgumentException>(() => control.Parent = parent);

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

52Assert.Throws<NotSupportedException>(() => converter.ConvertFrom(value)); 106Assert.Throws<NotSupportedException>(() => converter.ConvertTo(new Cursor(Cursors.AppStarting.Handle), typeof(InstanceDescriptor))); 120Assert.Throws<NotSupportedException>(() => converter.ConvertTo(null, typeof(InstanceDescriptor))); 147Assert.Throws<FormatException>(() => converter.ConvertTo(Cursors.AppStarting, typeof(byte[]))); 148Assert.Throws<InvalidOperationException>(() => converter.ConvertTo(new Cursor(Cursors.AppStarting.Handle), typeof(byte[]))); 178Assert.Throws<NotSupportedException>(() => converter.ConvertTo(1, destinationType));

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

142Assert.Throws<FileNotFoundException>(() => new Cursor("NoSuchFile")); 344Assert.Throws<ObjectDisposedException>(() => cursor.Handle); 345Assert.Throws<ObjectDisposedException>(() => cursor.HotSpot); 348Assert.Throws<ObjectDisposedException>(() => cursor.Handle); 349Assert.Throws<ObjectDisposedException>(() => cursor.HotSpot);

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

121Assert.Throws<Win32Exception>(() => DataFormats.GetFormat(format));

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

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

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

21Assert.Throws<ArgumentNullException>(() => new DataGridViewColumnStateChangedEventArgs(null, DataGridViewElementStates.Displayed));

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

268Assert.Throws<InvalidOperationException>(() => column.AutoSizeMode = DataGridViewAutoSizeColumnMode.ColumnHeader); 307Assert.Throws<InvalidOperationException>(() => column.AutoSizeMode = DataGridViewAutoSizeColumnMode.NotSet); 323Assert.Throws<InvalidOperationException>(() => column.AutoSizeMode = DataGridViewAutoSizeColumnMode.Fill); 360Assert.Throws<InvalidOperationException>(() => column.AutoSizeMode = DataGridViewAutoSizeColumnMode.NotSet); 1772Assert.Throws<ArgumentException>(() => column.GetPreferredWidth(autoSizeColumnMode, fixedHeight: true)); 1773Assert.Throws<ArgumentException>(() => column.GetPreferredWidth(autoSizeColumnMode, fixedHeight: false));

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

61Assert.Throws<ArgumentException>(() => e.ThrowException = true);

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

19Assert.Throws<ArgumentNullException>(() => new DataGridViewEditingControlShowingEventArgs(control, cellStyle));

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

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

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

280Assert.Throws<NotSupportedException>(() => iList[index] = value); 297Assert.Throws<NotSupportedException>(() => iList.Add(value)); 388Assert.Throws<InvalidOperationException>(() => enumerator.Current); 391Assert.Throws<InvalidOperationException>(() => enumerator.Current); 394Assert.Throws<InvalidOperationException>(() => enumerator.Current); 416Assert.Throws<InvalidOperationException>(() => enumerator.Current); 425Assert.Throws<InvalidOperationException>(() => enumerator.Current); 428Assert.Throws<InvalidOperationException>(() => enumerator.Current);

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

312Assert.Throws<NotSupportedException>(() => iList[index] = value); 329Assert.Throws<NotSupportedException>(() => iList.Add(value)); 428Assert.Throws<InvalidOperationException>(() => enumerator.Current); 431Assert.Throws<InvalidOperationException>(() => enumerator.Current); 434Assert.Throws<InvalidOperationException>(() => enumerator.Current); 460Assert.Throws<InvalidOperationException>(() => enumerator.Current); 469Assert.Throws<InvalidOperationException>(() => enumerator.Current); 472Assert.Throws<InvalidOperationException>(() => enumerator.Current);

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

272Assert.Throws<NotSupportedException>(() => iList[index] = value); 289Assert.Throws<NotSupportedException>(() => iList.Add(value)); 378Assert.Throws<InvalidOperationException>(() => enumerator.Current); 381Assert.Throws<InvalidOperationException>(() => enumerator.Current); 384Assert.Throws<InvalidOperationException>(() => enumerator.Current); 405Assert.Throws<InvalidOperationException>(() => enumerator.Current); 414Assert.Throws<InvalidOperationException>(() => enumerator.Current); 417Assert.Throws<InvalidOperationException>(() => enumerator.Current);

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

946Assert.Throws<ArgumentException>(() => control.Parent = control);

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

263Assert.Throws<InvalidOperationException>(() => control.EditingControlFormattedValue = "text"); 285Assert.Throws<InvalidCastException>(() => control.EditingControlFormattedValue = new object()); 395Assert.Throws<InvalidOperationException>(() => control.Text = "text");

System\Windows\Forms\Design\PropertyTabTests.cs (4)

56Assert.Throws<ArgumentException>(() => bitmap.Size); 61Assert.Throws<ArgumentException>(() => bitmap.Size); 100Assert.Throws<ArgumentException>(() => bitmap.Size); 112Assert.Throws<ArgumentException>(() => bitmap.Size);

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

361Assert.Throws<ArgumentException>(() => provider.DataMember = "NoSuchValue");

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

93Assert.Throws<TargetException>(() => FeatureSupport.GetVersionPresent(featureClassType.AssemblyQualifiedName, featureConstName)); 156Assert.Throws<TargetException>(() => FeatureSupport.IsPresent(featureClassType.AssemblyQualifiedName, featureConstName)); 157Assert.Throws<TargetException>(() => FeatureSupport.IsPresent(featureClassType.AssemblyQualifiedName, featureConstName, new Version(1, 2, 3, 4)));

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

122Assert.Throws<NotSupportedException>(() => settings.GetFlowBreak(new object()));

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

1196Assert.Throws<ArgumentException>(() => control.Parent = control); 1205Assert.Throws<ArgumentException>(() => control.Parent = parent);

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

30Assert.Throws<NotSupportedException>(() => item.Expanded = value);

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

546Assert.Throws<COMException>(() => document.Domain = value); 670Assert.Throws<ArgumentException>(() => document.Encoding = value); 1565Assert.Throws<ArgumentException>(() => document.CreateElement(null)); 1647Assert.Throws<InvalidCastException>(() => document.Equals(new object())); 1736Assert.Throws<ArgumentException>(() => document.GetElementById(null)); 1812Assert.Throws<ArgumentException>(() => document.GetElementsByTagName(null));

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

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

340Assert.Throws<ArgumentException>(() => collection[0] = value); 808Assert.Throws<ArgumentException>(() => collection.Add(value, Color.Transparent)); 1067Assert.Throws<NotSupportedException>(() => collection.Contains(image)); 1122Assert.Throws<InvalidOperationException>(() => enumerator.Current); 1125Assert.Throws<InvalidOperationException>(() => enumerator.Current); 1142Assert.Throws<InvalidOperationException>(() => enumerator.Current); 1145Assert.Throws<InvalidOperationException>(() => enumerator.Current); 1167Assert.Throws<InvalidOperationException>(() => enumerator.Current); 1182Assert.Throws<InvalidOperationException>(() => enumerator.Current); 1205Assert.Throws<InvalidOperationException>(() => enumerator.Current); 1220Assert.Throws<InvalidOperationException>(() => enumerator.Current); 1281Assert.Throws<NotSupportedException>(() => collection.IndexOf(image)); 1724Assert.Throws<ArgumentException>(() => collection[0] = value); 1739Assert.Throws<NotSupportedException>(() => collection.Contains(value)); 1770Assert.Throws<NotSupportedException>(() => collection.IndexOf(value));

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

838Assert.Throws<ObjectDisposedException>(list.Images.GetEnumerator);

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

12Assert.Throws<ArgumentNullException>(() => new ItemCheckedEventArgs(null));

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

636Assert.Throws<ArgumentOutOfRangeException>(() => label.ImageIndex = -2); 735Assert.Throws<InvalidEnumArgumentException>(() => label.LiveSetting = (AutomationLiveSetting)999);

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

281Assert.Throws<NotSupportedException>(() => engine.Layout("container", new LayoutEventArgs(control, "affectedProperty")));

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

42Assert.Throws<NotSupportedException>(() => engine.Layout("container", new LayoutEventArgs(new Component(), "affectedProperty")));

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

System\Windows\Forms\Layout\TableLayoutSettingsTypeConverterTests.cs (9)

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

48Assert.Throws<NotSupportedException>(() => converter.ConvertFrom(value)); 57Assert.Throws<ArgumentException>(() => converter.ConvertFrom(value)); 101Assert.Throws<NotSupportedException>(() => converter.ConvertTo(1, typeof(InstanceDescriptor))); 110Assert.Throws<NotSupportedException>(() => converter.ConvertTo(default(LinkArea), destinationType));

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

46Assert.Throws<NotSupportedException>(() => converter.ConvertFrom(value)); 55Assert.Throws<ArgumentException>(() => converter.ConvertFrom(value)); 110Assert.Throws<NotSupportedException>(() => converter.ConvertTo(1, typeof(InstanceDescriptor))); 119Assert.Throws<NotSupportedException>(() => converter.ConvertTo(new LinkLabel.Link(), destinationType));

System\Windows\Forms\ListBindingHelperTests.cs (9)

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

1740Assert.Throws<ArgumentException>(() => collection[index] = item); 1960Assert.Throws<ArgumentException>(() => collection.Add(item)); 2242Assert.Throws<InvalidOperationException>(() => enumerator.Current); 2245Assert.Throws<InvalidOperationException>(() => enumerator.Current); 2249Assert.Throws<InvalidOperationException>(() => enumerator.Current); 2268Assert.Throws<InvalidOperationException>(() => enumerator.Current); 2274Assert.Throws<InvalidOperationException>(() => enumerator.Current); 2278Assert.Throws<InvalidOperationException>(() => enumerator.Current);

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

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

62Assert.Throws<NotSupportedException>(() => collection[index] = value); 73Assert.Throws<NotSupportedException>(() => collection.Add(value));

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

62Assert.Throws<NotSupportedException>(() => collection[index] = value); 73Assert.Throws<NotSupportedException>(() => collection.Add(value));

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

5284Assert.Throws<Win32Exception>(() => control.GetItemHeight(0));

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

2013Assert.Throws<IndexOutOfRangeException>(() => control.SelectedValue); 2085Assert.Throws<InvalidOperationException>(() => control.SelectedValue = value); 2087Assert.Throws<IndexOutOfRangeException>(() => control.SelectedValue); 2548Assert.Throws<StackOverflowException>(() => control.GetItemText(item)); 2551Assert.Throws<StackOverflowException>(() => control.GetItemText(item));

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

164Assert.Throws<ArgumentException>(() => collection[0] = group); 495Assert.Throws<ArgumentException>(() => collection.Add(group)); 1064Assert.Throws<InvalidOperationException>(() => listView.Groups.Add(new ListViewGroup())); 1080Assert.Throws<InvalidOperationException>(() => listView.Groups.Add(key: "key", headerText: "text"));

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

113Assert.Throws<NotSupportedException>(() => converter.ConvertFrom(mockContext.Object, null, "value")); 114Assert.Throws<NotSupportedException>(() => converter.ConvertFrom(mockContext.Object, null, "HEADER")); 124Assert.Throws<NotSupportedException>(() => converter.ConvertFrom(value)); 228Assert.Throws<NotSupportedException>(() => converter.ConvertTo(1, typeof(InstanceDescriptor))); 237Assert.Throws<NotSupportedException>(() => converter.ConvertTo(new ListViewGroup(), destinationType));

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

1374Assert.Throws<SerializationException>(() => info.GetString("Name")); 1376Assert.Throws<SerializationException>(() => info.GetInt32("ItemsCount")); 1392Assert.Throws<SerializationException>(() => info.GetString("Name")); 1394Assert.Throws<SerializationException>(() => info.GetInt32("ItemsCount")); 1410Assert.Throws<SerializationException>(() => info.GetString("Name"));

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

33Assert.Throws<NotSupportedException>(() => converter.ConvertFrom(value)); 283Assert.Throws<NotSupportedException>(() => converter.ConvertTo(1, typeof(InstanceDescriptor))); 292Assert.Throws<NotSupportedException>(() => converter.ConvertTo(new ListViewItem(), destinationType));

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

207Assert.Throws<InvalidOperationException>(() => collection.Add(new ListViewItem.ListViewSubItem())); 641Assert.Throws<InvalidOperationException>(() => collection.Add(new ListViewItem.ListViewSubItem()));

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

33Assert.Throws<NotSupportedException>(() => converter.ConvertFrom(value)); 96Assert.Throws<NotSupportedException>(() => converter.ConvertTo(1, typeof(InstanceDescriptor))); 105Assert.Throws<NotSupportedException>(() => converter.ConvertTo(new ListViewItem.ListViewSubItem(), destinationType));

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

143Assert.Throws<InvalidOperationException>(() => control.TopItem); 1084Assert.Throws<NotSupportedException>(() => listView.CheckBoxes = true);

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

26Assert.Throws<ArgumentException>(() => new ListViewVirtualItemsSelectionRangeChangedEventArgs(1, 0, false));

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

2490Assert.Throws<InvalidOperationException>(() => control.SingleMonthSize);

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

310Assert.Throws<NullReferenceException>(() => notifyIcon.Icon = value); 565Assert.Throws<NullReferenceException>(() => notifyIcon.Visible = !value);

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

51Assert.Throws<NotSupportedException>(() => converter.ConvertFrom(value)); 67Assert.Throws<FormatException>(() => converter.ConvertFrom(value)); 103Assert.Throws<NotSupportedException>(() => converter.ConvertTo(1, typeof(InstanceDescriptor))); 113Assert.Throws<NotSupportedException>(() => converter.ConvertTo(1.1, destinationType));

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

50Assert.Throws<NotSupportedException>(() => converter.ConvertFrom(value)); 113Assert.Throws<NotSupportedException>(() => converter.ConvertTo(1, typeof(InstanceDescriptor))); 122Assert.Throws<NotSupportedException>(() => converter.ConvertTo(default(Padding), destinationType));

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

443Assert.Throws<ArgumentException>(() => dialog.ShowDialog());

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

1213Assert.Throws<ArgumentException>(() => control.Parent = control);

System\Windows\Forms\PropertyGridInternal\AccessibleObjects\PropertyGridView.GridViewTextBox.GridViewTextBoxAccessibleObjectTests.cs (1)

114Assert.Throws<TargetInvocationException>(() => Activator.CreateInstance(accessibleObjectType, (TextBox)null));

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

1026Assert.Throws<ArgumentException>(() => control.CommandsBackColor = Color.FromArgb(254, 1, 2, 3)); 1814Assert.Throws<ArgumentException>(() => control.HelpBackColor = Color.FromArgb(254, 1, 2, 3)); 2395Assert.Throws<InvalidCastException>(() => control.SelectedGridItem = mockGridItem.Object); 3284Assert.Throws<ArgumentException>(() => control.ViewBackColor = Color.FromArgb(254, 1, 2, 3));

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

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

462Assert.Throws<NotSupportedException>(() => control.Height = value); 481Assert.Throws<NotSupportedException>(() => control.Height = value); 1184Assert.Throws<NotSupportedException>(() => control.Width = value); 1203Assert.Throws<NotSupportedException>(() => control.Width = value);

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

729Assert.Throws<ArgumentException>(() => control.Dock = value);

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

614Assert.Throws<NotSupportedException>(() => control.RenderMode = ToolStripRenderMode.Custom);

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

1368Assert.Throws<ArgumentOutOfRangeException>(() => owner.SelectedTab); 1373Assert.Throws<ArgumentOutOfRangeException>(() => owner.SelectedTab); 1378Assert.Throws<ArgumentOutOfRangeException>(() => owner.SelectedTab);

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

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

3903Assert.Throws<InvalidCastException>(() => control.GetItems(baseType)); 3914Assert.Throws<InvalidCastException>(() => control.GetItems(typeof(int))); 3925Assert.Throws<ArrayTypeMismatchException>(() => control.GetItems(typeof(SubTabPage)));

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

28Assert.Throws<InvalidCastException>(() => collection.Add(style)); 64Assert.Throws<InvalidCastException>(() => collection.Add(new RowStyle())); 65Assert.Throws<InvalidCastException>(() => collection[0]);

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

133Assert.Throws<NotSupportedException>(() => converter.ConvertFrom(value)); 192Assert.Throws<NotSupportedException>(() => converter.ConvertTo(1, typeof(InstanceDescriptor))); 201Assert.Throws<NotSupportedException>(() => converter.ConvertTo(default(TableLayoutPanelCellPosition), destinationType));

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

579Assert.Throws<NotSupportedException>(() => control.LayoutSettings = null); 588Assert.Throws<NotSupportedException>(() => control.LayoutSettings = otherControl.LayoutSettings);

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

65Assert.Throws<InvalidCastException>(() => collection[0]);

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

63Assert.Throws<InvalidCastException>(() => collection.Add(new object())); 169Assert.Throws<ArgumentException>(() => collection[0] = new object());

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

149Assert.Throws<NotSupportedException>(() => converter.ConvertTo(new SubTableLayoutStyle { SizeType = sizeType }, typeof(InstanceDescriptor))); 163Assert.Throws<NotSupportedException>(() => converter.ConvertTo(1, typeof(InstanceDescriptor))); 172Assert.Throws<NotSupportedException>(() => converter.ConvertTo(new RowStyle(), destinationType));

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

2606Assert.Throws<ArgumentException>(() => control.Parent = control); 2615Assert.Throws<ArgumentException>(() => control.Parent = parent);

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

48Assert.Throws<InvalidOperationException>(separateTask.GetAwaiter().GetResult);

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

14Assert.Throws<ArgumentNullException>(() => new ToolStripArrowRenderEventArgs(null, toolStripButton, Rectangle.Empty, Color.Empty, ArrowDirection.Up));

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

24Assert.Throws<ArgumentNullException>(() => new ToolStripContentPanelRenderEventArgs(g, toolStripContentPanel));

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

1429Assert.Throws<NotSupportedException>(() => control.RenderMode = ToolStripRenderMode.Custom);

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

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

466Assert.Throws<NullReferenceException>(() => item.DropDown); 467Assert.Throws<NullReferenceException>(() => item.DropDown);

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

281Assert.Throws<InvalidOperationException>(() => control.AllowItemReorder = true); 341Assert.Throws<ArgumentException>(() => control.AllowItemReorder = true);

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

24Assert.Throws<ArgumentNullException>(() => new ToolStripGripRenderEventArgs(g, toolStrip));

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

24Assert.Throws<ArgumentNullException>(() => new ToolStripItemImageRenderEventArgs(g, toolStripItem, Rectangle.Empty));

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

24Assert.Throws<ArgumentNullException>(() => new ToolStripItemRenderEventArgs(g, toolStripItem));

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

763Assert.Throws<InvalidOperationException>(() => item.AllowDrop = true);

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

145Assert.Throws<InvalidEnumArgumentException>(() => item.ShortcutKeys = keys);

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

24Assert.Throws<ArgumentNullException>(() => new ToolStripPanelRenderEventArgs(g, toolStripPanel));

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

24Assert.Throws<ArgumentNullException>(() => new ToolStripRenderEventArgs(g, toolStrip));

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

24Assert.Throws<ArgumentNullException>(() => new ToolStripSeparatorRenderEventArgs(g, toolStripSeparator, true));

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

506Assert.Throws<InvalidOperationException>(() => control.AllowDrop = true); 577Assert.Throws<ArgumentException>(() => control.AllowDrop = true); 618Assert.Throws<InvalidOperationException>(() => control.AllowItemReorder = true); 678Assert.Throws<ArgumentException>(() => control.AllowItemReorder = true); 803Assert.Throws<NotSupportedException>(() => control.AutoScroll = value); 850Assert.Throws<NotSupportedException>(() => control.AutoScrollMinSize = new Size(1, 2)); 3440Assert.Throws<NotSupportedException>(() => control.RenderMode = ToolStripRenderMode.Custom);

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

86Assert.Throws<ArgumentNullException>(() => collection[0] = null); 108Assert.Throws<ArgumentException>(() => collection[1] = node); 121Assert.Throws<ArgumentException>(() => collection[0] = nodeOfAnotherTreeView);

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

23Assert.Throws<InvalidOperationException>(() => node.FullPath); 63Assert.Throws<InvalidOperationException>(() => node.FullPath); 111Assert.Throws<InvalidOperationException>(() => node.FullPath); 154Assert.Throws<InvalidOperationException>(() => node.FullPath); 202Assert.Throws<InvalidOperationException>(() => node.FullPath);

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

4745Assert.Throws<ArgumentException>(() => node.Nodes.Add(node));

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

55Assert.Throws<ArgumentException>(() => new VisualStyleRenderer(element.ClassName, element.Part, element.State)); 73Assert.Throws<NullReferenceException>(() => new VisualStyleRenderer(null)); 80Assert.Throws<ArgumentException>(() => new VisualStyleRenderer(element));

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

TestAccessorTests.cs (2)

95Assert.Throws<RuntimeBinderException>(() => access.PublicField = 1918); 105Assert.Throws<RuntimeBinderException>(() => access.PublicProperty = "What?");

TextBoxBaseTests.cs (1)

2753Assert.Throws<ObjectDisposedException>(() => control.SelectedText = value);

WebBrowserBaseTests.cs (1)

856Assert.Throws<NotSupportedException>(() => control.UseWaitCursor = true);

System\Windows\Markup\ArrayExtensionTests.cs (3)

70Assert.Throws<RankException>(() => new ArrayExtension(new int[1, 1])); 108Assert.Throws<InvalidOperationException>(() => extension.ProvideValue(null)); 116Assert.Throws<InvalidOperationException>(() => extension.ProvideValue(null));

System\Windows\Markup\DateTimeValueSerializerTests.cs (2)

51Assert.Throws<NotSupportedException>(() => serializer.ConvertToString(value, null)); 83Assert.Throws<NotSupportedException>(() => serializer.ConvertFromString(null!, null));

System\Windows\Markup\NameReferenceConverterTests.cs (5)

85Assert.Throws<InvalidOperationException>(() => converter.ConvertFrom(context, null, "name")); 100Assert.Throws<InvalidCastException>(() => converter.ConvertFrom(context, null, "name")); 118Assert.Throws<InvalidOperationException>(() => converter.ConvertFrom(context, null, value)); 177Assert.Throws<InvalidOperationException>(() => converter.ConvertTo(context, null, "value", null)); 192Assert.Throws<InvalidCastException>(() => converter.ConvertTo(context, null, "value", null));

System\Windows\Markup\ReferenceTests.cs (2)

79Assert.Throws<InvalidOperationException>(() => reference.ProvideValue(provider)); 92Assert.Throws<InvalidOperationException>(() => reference.ProvideValue(provider));

System\Windows\Markup\StaticExtensionTests.cs (7)

95Assert.Throws<InvalidOperationException>(() => extension.ProvideValue(null)); 112Assert.Throws<ArgumentException>(() => extension.ProvideValue(provider)); 132Assert.Throws<ArgumentException>(() => extension.ProvideValue(provider)); 143Assert.Throws<ArgumentException>(() => extension.ProvideValue(null)); 165Assert.Throws<ArgumentException>(() => extension.ProvideValue(provider)); 235Assert.Throws<ArgumentException>(() => converter.ConvertTo(1, typeof(InstanceDescriptor))); 243Assert.Throws<NotSupportedException>(() => converter.ConvertTo(extension, typeof(int)));

System\Windows\Markup\StringValueSerializerTests.cs (1)

37Assert.Throws<InvalidCastException>(() => serializer.ConvertToString(1, null));

System\Windows\Markup\TypeExtensionTests.cs (5)

83Assert.Throws<InvalidOperationException>(() => extension.ProvideValue(null)); 103Assert.Throws<InvalidOperationException>(() => extension.ProvideValue(provider)); 121Assert.Throws<InvalidOperationException>(() => extension.ProvideValue(provider)); 196Assert.Throws<ArgumentException>(() => converter.ConvertTo(1, typeof(InstanceDescriptor))); 204Assert.Throws<NotSupportedException>(() => converter.ConvertTo(extension, typeof(int)));

System\Windows\Markup\ValueSerializerTests.cs (12)

43Assert.Throws<NotSupportedException>(() => serializer.ConvertToString(value, null)); 44Assert.Throws<NotSupportedException>(() => serializer.ConvertToString(value, new CustomValueSerializerContext())); 67Assert.Throws<NotSupportedException>(() => serializer.ConvertFromString(null!, null)); 68Assert.Throws<NotSupportedException>(() => serializer.ConvertFromString(null!, new CustomValueSerializerContext())); 77Assert.Throws<NotSupportedException>(() => serializer.ConvertFromString(value, null)); 78Assert.Throws<NotSupportedException>(() => serializer.ConvertFromString(value, new CustomValueSerializerContext())); 213Assert.Throws<ArgumentException>(() => ValueSerializer.GetSerializerFor(typeof(ClassWithEmptyTypeConverterAttribute))); 214Assert.Throws<ArgumentException>(() => ValueSerializer.GetSerializerFor(typeof(ClassWithEmptyTypeConverterAttribute), null!)); 235Assert.Throws<InvalidCastException>(() => ValueSerializer.GetSerializerFor(typeof(ClassWithInvalidValueSerializerAttribute))); 236Assert.Throws<InvalidCastException>(() => ValueSerializer.GetSerializerFor(typeof(ClassWithInvalidValueSerializerAttribute), null)); 301Assert.Throws<InvalidCastException>(() => ValueSerializer.GetSerializerFor(descriptor)); 302Assert.Throws<InvalidCastException>(() => ValueSerializer.GetSerializerFor(descriptor, null));

System\Windows\SizeTests.cs (6)

11Assert.Throws<ArgumentException>(() => new Size(-1, 0)); 17Assert.Throws<ArgumentException>(() => new Size(0, -1)); 24Assert.Throws<InvalidOperationException>(() => size.Width = 0); 31Assert.Throws<InvalidOperationException>(() => size.Height = 0); 38Assert.Throws<ArgumentException>(() => size.Height = -1); 45Assert.Throws<ArgumentException>(() => size.Width = -1);

System\Windows\SplashScreenTests.cs (1)

11Assert.Throws<ArgumentNullException>(() => new SplashScreen(null));

ExceptionAsserts.cs (1)

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