Null

ConfigurationTests.cs (1)

12=> Assert.Null(new AzureSecurityKeyVaultSettings().VaultUri);

ConformanceTests.cs (1)

245Assert.Null(host.Services.GetService<TService>());

ConsoleLogsTests\TimestampParserTests.cs (1)

42Assert.Null(parseResult);

DashboardOptionsTests.cs (1)

35Assert.Null(result.FailureMessage);

Integration\OtlpGrpcServiceTests.cs (1)

44Assert.Null(headers.GetValue("content-security-policy"));

Model\ApplicationsSelectHelpersTests.cs (2)

35Assert.Null(app.Id!.InstanceId); 79Assert.Null(app.Id!.InstanceId);

Model\ResourceEndpointHelpersTests.cs (1)

91Assert.Null(e.Url);

OtlpApiKeyAuthenticationHandlerTests.cs (1)

55Assert.Null(result.Failure);

TelemetryRepositoryTests\ApplicationTests.cs (1)

54Assert.Null(notFound);

TelemetryRepositoryTests\TraceTests.cs (1)

239Assert.Null(trace.RootSpan);

ContainerImageAnnotationTests.cs (4)

20Assert.Null(annotation.Tag); 23Assert.Null(annotation.SHA256); 35Assert.Null(annotation.SHA256); 38Assert.Null(annotation.Tag);

ContainerResourceTests.cs (2)

30Assert.Null(containerAnnotation.Registry); 49Assert.Null(containerAnnotation.Registry);

Dashboard\DashboardResourceTests.cs (1)

417Assert.Null(manifest);

DistributedApplicationBuilderTests.cs (2)

47Assert.Null(options.Value.Publisher); 48Assert.Null(options.Value.OutputPath);

Garnet\AddGarnetTests.cs (3)

31Assert.Null(endpoint.Port); 191Assert.Null(persistenceAnnotation); 222Assert.Null(persistenceAnnotation);

Kafka\AddKafkaTests.cs (2)

33Assert.Null(primaryEndpoint.Port); 42Assert.Null(internalEndpoint.Port);

Milvus\AddMilvusTests.cs (2)

43Assert.Null(endpoint.Port); 74Assert.Null(endpoint.Port);

MongoDB\AddMongoDBTests.cs (1)

33Assert.Null(endpoint.Port);

MySql\AddMySqlTests.cs (1)

58Assert.Null(endpoint.Port);

Nats\AddNatsTests.cs (1)

32Assert.Null(endpoint.Port);

Oracle\AddOracleDatabaseTests.cs (1)

56Assert.Null(endpoint.Port);

Postgres\AddPostgresTests.cs (1)

58Assert.Null(endpoint.Port);

Qdrant\AddQdrantTests.cs (3)

62Assert.Null(endpoint.Port); 102Assert.Null(endpoint.Port); 135Assert.Null(endpoint.Port);

RabbitMQ\AddRabbitMQTests.cs (2)

60Assert.Null(primaryEndpoint.Port); 77Assert.Null(mangementEndpoint.Port);

Redis\AddRedisTests.cs (3)

32Assert.Null(endpoint.Port); 280Assert.Null(persistenceAnnotation); 311Assert.Null(persistenceAnnotation);

SqlServer\AddSqlServerTests.cs (1)

52Assert.Null(endpoint.Port);

Valkey\AddValkeyTests.cs (3)

31Assert.Null(endpoint.Port); 191Assert.Null(persistenceAnnotation); 222Assert.Null(persistenceAnnotation);

WithEndpointTests.cs (4)

53Assert.Null(endpoint.TargetPort); 61Assert.Null(endpoint.TargetPort); 88Assert.Null(endpoint.Port); 96Assert.Null(endpoint.Port);

ConfigurationTests.cs (1)

12=> Assert.Null(new MicrosoftAzureCosmosSettings().ConnectionString);

ConfigurationTests.cs (1)

12=> Assert.Null(new MicrosoftDataSqlClientSettings().ConnectionString);

AspireAzureEfCoreCosmosDBExtensionsTests.cs (1)

198Assert.Null(exception);

AspireSqlServerEFCoreSqlClientExtensionsTests.cs (2)

153Assert.Null(extension.ExecutionStrategyFactory); 299Assert.Null(exception);

AspireMilvusExtensionTests.cs (1)

170Assert.Null(healthCheckService);

ConfigurationTests.cs (2)

11=> Assert.Null(new MilvusClientSettings().Endpoint); 15=> Assert.Null(new MilvusClientSettings().Database);

AspireMongoDBDriverExtensionsTests.cs (4)

54Assert.Null(mongoDatabase); 87Assert.Null(mongoDatabase); 129Assert.Null(healthCheckService); 173Assert.Null(healthCheckService);

ConfigurationTests.cs (1)

12=> Assert.Null(new MySqlConnectorSettings().ConnectionString);

AspireNatsClientExtensionsTests.cs (1)

175Assert.Null(healthCheckService);

ConfigurationTests.cs (1)

12=> Assert.Null(new NatsClientSettings().ConnectionString);

AspireEFPostgreSqlExtensionsTests.cs (2)

161Assert.Null(extension.ExecutionStrategyFactory); 306Assert.Null(exception);

ConfigurationTests.cs (1)

12=> Assert.Null(new NpgsqlEntityFrameworkCorePostgreSQLSettings().ConnectionString);

ConfigurationTests.cs (1)

12=> Assert.Null(new NpgsqlSettings().ConnectionString);

AspireOracleEFCoreDatabaseExtensionsTests.cs (2)

154Assert.Null(extension.ExecutionStrategyFactory); 300Assert.Null(exception);

AspireEFMySqlExtensionsTests.cs (2)

172Assert.Null(extension.ExecutionStrategyFactory); 294Assert.Null(exception);

ConfigurationTests.cs (1)

12=> Assert.Null(new PomeloEntityFrameworkCoreMySqlSettings().ConnectionString);

ConfigurationTests.cs (1)

11=> Assert.Null(new QdrantClientSettings().Endpoint);

OperationContextTests.cs (1)

44Assert.Null(OperationContext.Current);

OperationContextAsyncFlowTests.cs (3)

30Assert.Null(OperationContext.Current); 65Assert.Null(OperationContext.Current); 85Assert.Null(OperationContext.Current);

DuplexChannelWithSynchronizationContext.cs (1)

197Assert.Null(callbackSyncContext);

CallbackDebugBehaviorTests.cs (1)

55Assert.Null(response);

ResponseAbortTests.cs (1)

122Assert.Null(exception);

TlsHandshakeFeatureTests.cs (1)

74Assert.Null(tlsHandshakeFeature);

BadHttpRequestTests.cs (3)

387Assert.Null(loggedException); 451Assert.Null(loggedException); 504Assert.Null(loggedException);

Http2\Http2ConnectionTests.cs (1)

517Assert.Null(persistedState);

Http2\Http2KeepAliveTests.cs (1)

18Assert.Null(_connection._keepAlive);

Http2\Http2StreamTests.cs (1)

236Assert.Null(context.Request.ContentLength);

Http3\Http3ConnectionTests.cs (1)

190Assert.Null(await Http3Api.MultiplexedConnectionContext.AcceptAsync().DefaultTimeout());

HttpsConnectionMiddlewareTests.cs (33)

HttpsTests.cs (8)

66Assert.Null(opt.ServerCertificate); 113Assert.Null(options.ServerCertificate); 132Assert.Null(serverOptions.DevelopmentCertificate); 141Assert.Null(options.ServerCertificate); 142Assert.Null(options.ServerCertificateSelector); 154Assert.Null(opt.ServerCertificate); 165Assert.Null(serverOptions.DevelopmentCertificate); 764Assert.Null(authOptions.ServerCertificate);

RequestTests.cs (3)

354Assert.Null(local.Value); 462Assert.Null(local.Value); 2178Assert.Null(firstRequestState);

ResponseDrainingTests.cs (1)

68Assert.Null(transportConnection.AbortReason);

UpgradeTests.cs (1)

234Assert.Null(context.Request.ContentLength);

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

335Assert.Null(ctx.Features.Get<IHttpResponseFeature>().ReasonPhrase);

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

123Assert.Null(context.Features.Get<IHttpMaxRequestBodySizeFeature>().MaxRequestBodySize);

Http3\Http3RequestTests.cs (1)

870Assert.Null(firstRequestState);

Http3\Http3TlsTests.cs (1)

43Assert.Null(context); // The context isn't available durring the quic handshake.

HttpClientHttp2InteropTests.cs (2)

1665Assert.Null(context.Connection.ClientCertificate); 1666Assert.Null(await context.Connection.GetClientCertificateAsync());

AntiforgeryOptionsSetupTest.cs (1)

44Assert.Null(o.Cookie.Name);

AntiforgeryTokenTest.cs (2)

33Assert.Null(token.ClaimUid); 42Assert.Null(token.ClaimUid);

DefaultAntiforgeryTest.cs (8)

203Assert.Null(tokenset.CookieToken); 210Assert.Null(antiforgeryFeature.NewCookieToken); 238Assert.Null(tokenset.CookieToken); 241Assert.Null(antiforgeryFeature.NewCookieToken); 273Assert.Null(tokenSet.CookieToken); 280Assert.Null(antiforgeryFeature.NewCookieToken); 306Assert.Null(tokenSet.CookieToken); 337Assert.Null(tokenSet.CookieToken);

DefaultAntiforgeryTokenGeneratorTest.cs (6)

71Assert.Null(fieldToken.ClaimUid); 136Assert.Null(fieldToken.ClaimUid); 204Assert.Null(fieldToken.ClaimUid); 531Assert.Null(message); 565Assert.Null(message); 598Assert.Null(message);

DefaultAntiforgeryTokenStoreTest.cs (2)

30Assert.Null(token); 49Assert.Null(token);

DefaultClaimUidExtractorTest.cs (1)

29Assert.Null(claimUid);

RouteEmbeddedLanguage\FrameworkParametersCompletionProviderTests.cs (1)

847Assert.Null(item);

RouteEmbeddedLanguage\RoutePatternCompletionProviderTests.cs (1)

39Assert.Null(result.Completions);

SharedFxTests.cs (2)

132Assert.Null(runtimeLibrary["dependencies"]); 156Assert.Null(runtimeLibrary["native"]);

AuthenticationPropertiesTests.cs (23)

TokenExtensionTests.cs (5)

48Assert.Null(props.GetTokenValue("One")); 49Assert.Null(props.GetTokenValue("Two")); 50Assert.Null(props.GetTokenValue("Three")); 117Assert.Null(props.GetTokenValue("ONE")); 118Assert.Null(props.GetTokenValue("Jigglypuff"));

UserJwtsTests.cs (1)

225Assert.Null(exception);

ServerDeferralTests.cs (1)

22Assert.Null(options.ForwardDefault);

AuthenticationMiddlewareTests.cs (2)

100Assert.Null(authenticateResultFeature); 126Assert.Null(authenticateResultFeature.AuthenticateResult);

CertificateTests.cs (1)

36Assert.Null(scheme.DisplayName);

CookieTests.cs (41)

GoogleTests.cs (2)

455Assert.Null(ctx.AccessDeniedPath.Value); 979Assert.Null(transaction.FindClaimValue(ClaimTypes.Name));

OAuthChallengePropertiesTest.cs (8)

31Assert.Null(properties.Scope); 61Assert.Null(properties.MaxAge); 83Assert.Null(properties.Prompt); 120Assert.Null(properties.AccessType); 123Assert.Null(properties.ApprovalPrompt); 126Assert.Null(properties.LoginHint); 129Assert.Null(properties.Prompt); 147Assert.Null(properties.IncludeGrantedScopes);

OAuthTests.cs (3)

349Assert.Null(transaction.Response.Headers.Location); 385Assert.Null(transaction.Response.Headers.Location); 421Assert.Null(transaction.Response.Headers.Location);

OpenIdConnect\OpenIdConnectChallengeTests.cs (2)

389Assert.Null(res.Headers.Location); 418Assert.Null(res.Headers.Location);

OpenIdConnect\OpenIdConnectEventTests.cs (5)

721Assert.Null(context.Principal); 755Assert.Null(context.Principal); 997Assert.Null(response.Headers.Location); 1106Assert.Null(response.Headers.Location); 1133Assert.Null(response.Headers.Location);

OpenIdConnect\OpenIdConnectEventTests_Handler.cs (5)

721Assert.Null(context.Principal); 755Assert.Null(context.Principal); 997Assert.Null(response.Headers.Location); 1106Assert.Null(response.Headers.Location); 1133Assert.Null(response.Headers.Location);

SecureDataFormatTests.cs (2)

59Assert.Null(result); 62Assert.Null(result);

TokenExtensionTests.cs (5)

44Assert.Null(props.GetTokenValue("One")); 45Assert.Null(props.GetTokenValue("Two")); 46Assert.Null(props.GetTokenValue("Three")); 113Assert.Null(props.GetTokenValue("ONE")); 114Assert.Null(props.GetTokenValue("Jigglypuff"));

AuthorizationBuilderTests.cs (1)

40Assert.Null(options.FallbackPolicy);

AuthorizationEndpointConventionBuilderExtensionsTests.cs (5)

47Assert.Null(authMetadata.Policy); 85Assert.Null(authMetadata.Policy); 104Assert.Null(authMetadata.Policy); 138Assert.Null(authMetadata.Policy); 161Assert.Null(authMetadata.Policy);

AuthorizationMiddlewareTests.cs (2)

810Assert.Null(authenticateResultFeature); 878Assert.Null(authenticateResultFeature.AuthenticateResult);

AuthorizeRouteViewTest.cs (1)

146Assert.Null(call.resource);

AuthorizeViewTest.cs (11)

43Assert.Null(call.user.Identity); 44Assert.Null(call.resource); 79Assert.Null(call.resource); 107Assert.Null(call.resource); 143Assert.Null(call.resource); 179Assert.Null(call.resource); 226Assert.Null(call.resource); 343Assert.Null(call.resource); 401Assert.Null(call.resource); 424Assert.Null(call.resource); 447Assert.Null(call.resource);

Binding\FormDataMapperTests.cs (1)

188Assert.Null(result);

Builder\RazorComponentsEndpointConventionBuilderExtensionsTest.cs (3)

37Assert.Null(metadata); 56Assert.Null(metadata); 215Assert.Null(metadata);

EndpointHtmlRendererTest.cs (52)

Circuits\CircuitHostTest.cs (2)

114Assert.Null(SynchronizationContext.Current); 117Assert.Null(SynchronizationContext.Current);

Circuits\RevalidatingServerAuthenticationStateProviderTest.cs (1)

213Assert.Null(newAuthState.User.Identity.Name);

Circuits\ServerComponentDeserializerTest.cs (1)

423Assert.Null(parsed);

ProtectedBrowserStorageTest.cs (1)

161Assert.Null(result.Value);

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

409Assert.Null(message);

BindConverterTest.cs (3)

279Assert.Null(actual); 355Assert.Null(actual); 369Assert.Null(actual);

ComponentFactoryTest.cs (2)

94Assert.Null(component.Property4); 115Assert.Null(component.Property2);

DependencyInjectionTest.cs (4)

26Assert.Null(component.SomeProperty); 27Assert.Null(component.PrivatePropertyValue); 37Assert.Null(HasStaticProperties.StaticPropertyWithInject); 38Assert.Null(HasStaticProperties.StaticPropertyWithoutInject);

EventCallbackFactoryBinderExtensionsTest.cs (1)

94Assert.Null(value); // Setter called

EventCallbackFactoryTest.cs (8)

89Assert.Null(callback.Delegate); 156Assert.Null(callback.Delegate); 239Assert.Null(callback.Delegate); 290Assert.Null(callback.Delegate); 376Assert.Null(callback.Delegate); 425Assert.Null(callback.Delegate); 510Assert.Null(callback.Delegate); 577Assert.Null(callback.Delegate);

EventCallbackTest.cs (4)

106Assert.Null(arg); 214Assert.Null(arg); 322Assert.Null(arg); 394Assert.Null(arg);

Lifetime\ComponentApplicationStateTest.cs (2)

133Assert.Null(JsonSerializer.Deserialize<byte[]>(stored)); 169Assert.Null(stored);

ParameterViewTest.Assignment.cs (1)

600Assert.Null(target.StringProp);

ParameterViewTest.cs (1)

124Assert.Null(value);

RendererTest.cs (19)

Rendering\RenderTreeBuilderTest.cs (2)

1787Assert.Null(frame.ElementKey); 1808Assert.Null(frame.ComponentKey);

Routing\RouteTableFactoryTests.cs (7)

250Assert.Null(context.Handler); 272Assert.Null(context.Handler); 288Assert.Null(context.Handler); 653Assert.Null(context.Handler); 778Assert.Null(context.Parameters); 796Assert.Null(context.Parameters); 922Assert.Null(context.Parameters);

Forms\InputBaseTest.cs (3)

129Assert.Null(inputComponent.EditContext); 385Assert.Null(component.AdditionalAttributes); 527Assert.Null(component.AdditionalAttributes);

Forms\InputSelectTest.cs (1)

81Assert.Null(inputSelectComponent.CurrentValue);

Hosting\WebAssemblyHostConfigurationTest.cs (1)

120Assert.Null(exception);

ConcurrencyLimiterEventSourceTests.cs (1)

39Assert.Null(eventData.Message);

CookieConsentTests.cs (2)

230Assert.Null(testCookie.Expires); 404Assert.Null(testCookie.Expires);

CorsEndpointConventionBuilderExtensionsTests.cs (1)

72Assert.Null(metadata.PolicyName);

CorsPolicyBuilderTests.cs (3)

57Assert.Null(corsPolicy.PreflightMaxAge); 84Assert.Null(corsPolicy.PreflightMaxAge); 108Assert.Null(corsPolicy.PreflightMaxAge);

CorsPolicyTests.cs (1)

23Assert.Null(corsPolicy.PreflightMaxAge);

CorsResultTests.cs (2)

19Assert.Null(result.AllowedOrigin); 20Assert.Null(result.PreflightMaxAge);

CorsServiceTests.cs (2)

43Assert.Null(result.AllowedOrigin); 410Assert.Null(result.PreflightMaxAge);

ActivatorTests.cs (2)

49Assert.Null(retVal2.Services); 52Assert.Null(retVal3.Services);

AuthenticatedEncryption\CngCbcAuthenticatedEncryptorFactoryTest.cs (1)

29Assert.Null(encryptor);

AuthenticatedEncryption\CngGcmAuthenticatedEncryptorFactoryTest.cs (1)

29Assert.Null(encryptor);

AuthenticatedEncryption\ManagedAuthenticatedEncryptorFactoryTest.cs (1)

27Assert.Null(encryptor);

DataProtectionUtilityExtensionsTests.cs (2)

109Assert.Null(((IServiceProvider)null).GetApplicationUniqueIdentifier()); 122Assert.Null(services.GetApplicationUniqueIdentifier());

KeyManagement\DefaultKeyResolverTests.cs (7)

26Assert.Null(resolution.DefaultKey); 121Assert.Null(resolution.DefaultKey); 137Assert.Null(resolution.DefaultKey); 167Assert.Null(resolution.DefaultKey); 322Assert.Null(resolution.DefaultKey); 323Assert.Null(resolution.FallbackKey); 401Assert.Null(resolution.DefaultKey);

RegistryPolicyResolverTests.cs (2)

27Assert.Null(context.EncryptorConfiguration); 28Assert.Null(context.DefaultKeyLifetime);

ServiceCollectionTests.cs (1)

57Assert.Null(services.GetService<ILoggerFactory>());

HealthCheckMiddlewareTests.cs (1)

467Assert.Null(response.Headers.CacheControl);

DeveloperExceptionPageMiddlewareTest.cs (4)

225Assert.Null(listener.DiagnosticHandledException?.HttpContext); 226Assert.Null(listener.DiagnosticHandledException?.Exception); 569Assert.Null(listener.DiagnosticHandledException?.HttpContext); 570Assert.Null(listener.DiagnosticHandledException?.Exception);

ExceptionHandlerMiddlewareTest.cs (2)

92Assert.Null(context.GetEndpoint()); 224Assert.Null(meter.Version);

ExceptionHandlerTest.cs (9)

334Assert.Null(exception); 499Assert.Null(listener.HostingUnhandledException?.HttpContext); 500Assert.Null(listener.HostingUnhandledException?.Exception); 501Assert.Null(listener.DiagnosticUnhandledException?.HttpContext); 502Assert.Null(listener.DiagnosticUnhandledException?.Exception); 720Assert.Null(exception); 771Assert.Null(exception); 826Assert.Null(exception); 877Assert.Null(exception);

StatusCodeMiddlewareTest.cs (1)

149Assert.Null(context.GetEndpoint());

ConverterTests\MessageTypeInfoResolverTests.cs (3)

20Assert.Null(resolver.GetTypeInfo(typeof(IMessage), new JsonSerializerOptions())); 28Assert.Null(resolver.GetTypeInfo(typeof(IMessage<HelloRequest>), new JsonSerializerOptions())); 36Assert.Null(resolver.GetTypeInfo(typeof(IBufferMessage), new JsonSerializerOptions()));

HttpRoutePatternParserTests.cs (2)

20Assert.Null(pattern.Verb); 49Assert.Null(pattern.Verb);

UnaryServerCallHandlerTests.cs (1)

218Assert.Null(request!.Sub);

Binding\BodyTests.cs (2)

31Assert.Null(bodySchema.Reference); 50Assert.Null(bodySchema.Reference);

Binding\ResponseBodyTests.cs (1)

46Assert.Null(bodySchema.Reference);

SchemaGeneratorIntegrationTests.cs (4)

129Assert.Null(schema.Items.Type); 148Assert.Null(resolvedSchema.AdditionalProperties.Type); 161Assert.Null(schema.AdditionalProperties.Type); 180Assert.Null(schema.AdditionalProperties);

XmlComments\XmlDocumentationIntegrationTests.cs (2)

75Assert.Null(path.Operations[OperationType.Get].Description); 97Assert.Null(path.Operations[OperationType.Post].RequestBody.Description);

GenericWebHostBuilderTests.cs (1)

39Assert.Null(config[randomEnvKey]);

HostingApplicationDiagnosticsTests.cs (4)

302Assert.Null(Activity.Current); 342Assert.Null(Activity.Current); 373Assert.Null(Activity.Current); 814Assert.Null(Activity.Current);

HostingApplicationTests.cs (1)

48Assert.Null(context.HttpContext);

HostingEnvironmentExtensionsTests.cs (1)

53Assert.Null(env.WebRootPath);

HostingMetricsTests.cs (3)

33Assert.Null(meter.Version); 131Assert.Null(meter.Version); 167Assert.Null(meter.Version);

Http\DefaultHttpContextFactoryTests.cs (1)

48Assert.Null(accessor.HttpContext);

Internal\HostingEventSourceTests.cs (5)

43Assert.Null(eventData.Message); 66Assert.Null(eventData.Message); 122Assert.Null(eventData.Message); 150Assert.Null(eventData.Message); 172Assert.Null(eventData.Message);

WebHostBuilderTests.cs (2)

1054Assert.Null(builder.GetSetting("testhostingstartup1")); 1171Assert.Null(builder.GetSetting("testhostingstartup"));

CookieBuilderTests.cs (2)

31Assert.Null(new CookieBuilder().Build(new DefaultHttpContext()).Expires); 41Assert.Null(new CookieBuilder().Build(new DefaultHttpContext()).MaxAge);

EndpointFilterInvocationContextOfTTests.cs (2)

77Assert.Null(context.GetArgument<string>(0)); 78Assert.Null(context.GetArgument<Todo>(3));

EndpointHttpContextExtensionsTests.cs (4)

20Assert.Null(endpoint); 37Assert.Null(endpoint); 68Assert.Null(context.Features.Get<IEndpointFeature>()); 127Assert.Null(context.GetEndpoint());

HostStringTest.cs (1)

74Assert.Null(result);

QueryStringTests.cs (2)

23Assert.Null(query.Value); 27Assert.Null(query.Value);

HttpConnectionDispatcherTests.cs (5)

73Assert.Null(connectionToken); 165Assert.Null(connectionId); 193Assert.Null(connectionId); 2307Assert.Null(connection.Features.Get<IStatefulReconnectFeature>()); 2336Assert.Null(connection.Features.Get<IStatefulReconnectFeature>());

HttpConnectionManagerTests.cs (3)

52Assert.Null(connection.ApplicationTask); 53Assert.Null(connection.TransportTask); 54Assert.Null(connection.Cancellation);

MapConnectionHandlerTests.cs (2)

311Assert.Null(endpoint.Metadata.GetMetadata<NegotiateMetadata>()); 350Assert.Null(endpoint.Metadata.GetMetadata<NegotiateMetadata>());

HeaderDictionaryTypeExtensionsTest.cs (4)

29Assert.Null(result); 40Assert.Null(result); 143Assert.Null(result); 152Assert.Null(result);

ParameterBindingMethodCacheTests.cs (2)

429Assert.Null(await parseHttpContext(httpContext)); 445Assert.Null(await parseHttpContext(httpContext));

RequestDelegateFactoryTests.cs (11)

RequestDelegateGenerator\RequestDelegateCreationTestBase.cs (1)

190Assert.Null(generatedCodeAttribute);

RequestDelegateGenerator\RequestDelegateCreationTests.BindAsync.cs (2)

110Assert.Null(httpContext.Items["uri"]); 139Assert.Null(httpContext.Items["uri"]);

RequestDelegateGenerator\RequestDelegateCreationTests.cs (1)

487Assert.Null(httpContext.Items["id"]);

RequestDelegateGenerator\RequestDelegateCreationTests.Filters.cs (1)

37Assert.Null(httpContext.Items["invoked"]);

RequestDelegateGenerator\RequestDelegateCreationTests.Forms.cs (5)

232Assert.Null(httpContext.Items["file2"]); 714Assert.Null(httpContext.Items["additionalMessage"]); 937Assert.Null(httpContext.Items["invoked"]); 969Assert.Null(httpContext.Items["invoked"]); 1006Assert.Null(httpContext.Items["invoked"]);

RequestDelegateGenerator\RequestDelegateCreationTests.KeyServices.cs (1)

144Assert.Null(httpContext.Items["arg"]);

RequestDelegateGenerator\RequestDelegateCreationTests.Logging.cs (12)

RequestDelegateGenerator\RequestDelegateCreationTests.Metadata.cs (4)

36Assert.Null(metadata.Type); 82Assert.Null(metadata.Type); 108Assert.Null(metadata.Type); 192Assert.Null(responseMetadata.Type);

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

190Assert.Null(generatedCodeAttribute);

ContentResultTests.cs (1)

167Assert.Null(result.StatusCode);

JsonResultTests.cs (2)

199Assert.Null(responseDetails.Type); 286Assert.Null(result.StatusCode);

ProblemResultTests.cs (2)

73Assert.Null(responseDetails.Type); 134Assert.Null(responseDetails.Type);

ResultsTests.cs (45)

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

292Assert.Null(httpResponse.ContentLength); 326Assert.Null(httpResponse.ContentLength);

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

284Assert.Null(httpResponse.ContentLength); 320Assert.Null(httpResponse.ContentLength);

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

121Assert.Null(sendFile.Length); 148Assert.Null(sendFile.Length); 177Assert.Null(sendFile.Length); 232Assert.Null(httpResponse.ContentLength); 259Assert.Null(httpResponse.ContentLength); 339Assert.Null(sendFile.Length); 359Assert.Null(sendFile.Length);

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

144Assert.Null(sendFileFeature.Length); 177Assert.Null(sendFileFeature.Length); 212Assert.Null(sendFileFeature.Length); 278Assert.Null(httpResponse.ContentLength); 281Assert.Null(sendFileFeature.Name); // Not called 309Assert.Null(httpResponse.ContentLength); 313Assert.Null(sendFileFeature.Name); // Not called

TypedResultsTests.cs (39)

ValidationProblemResultTests.cs (1)

75Assert.Null(responseDetails.Type);

DefaultHttpContextTests.cs (6)

100Assert.Null(context.User.Identity); 111Assert.Null(context.Features.Get<IItemsFeature>()); 125Assert.Null(context.Features.Get<IHttpRequestIdentifierFeature>()); 139Assert.Null(context.Features.Get<IItemsFeature>()); 226Assert.Null(context.RequestServices); 253Assert.Null(context.RequestServices);

HttpContextAccessorTests.cs (6)

27Assert.Null(accessor.HttpContext); 53Assert.Null(accessor.HttpContext); 70Assert.Null(accessor.HttpContext); 98Assert.Null(accessor.HttpContext); 138Assert.Null(accessor.HttpContext); 165Assert.Null(accessor.HttpContext);

Internal\DefaultHttpRequestTests.cs (5)

34Assert.Null(request.ContentLength); 48Assert.Null(request.ContentLength); 58Assert.Null(request.ContentType); 171Assert.Null(cookies0["key0"]); 204Assert.Null(routeValuesFeature);

Internal\DefaultHttpResponseTests.cs (3)

32Assert.Null(response.ContentLength); 46Assert.Null(response.ContentLength); 56Assert.Null(response.ContentType);

HttpLoggingMiddlewareTests.cs (1)

1414Assert.Null(

HttpLoggingServicesExtensionsTests.cs (1)

65Assert.Null(exception);

CertificateForwardingTest.cs (7)

53Assert.Null(context.Connection.ClientCertificate); 91Assert.Null(context.Connection.ClientCertificate); 130Assert.Null(context.Connection.ClientCertificate); 168Assert.Null(context.Connection.ClientCertificate); 174Assert.Null(context.Connection.ClientCertificate); 206Assert.Null(context.Connection.ClientCertificate); 212Assert.Null(context.Connection.ClientCertificate);

ForwardedHeadersMiddlewareTest.cs (2)

280Assert.Null(context.Connection.RemoteIpAddress); 959Assert.Null(context.Connection.RemoteIpAddress);

IPNetworkTest.cs (1)

134Assert.Null(network);

CustomPocoTest.cs (4)

42Assert.Null(db.Users.SingleOrDefault(u => u.UserName == oldName)); 64Assert.Null(db.Users.SingleOrDefault(u => u.UserName == oldName)); 127Assert.Null(db.Users.SingleOrDefault(u => u.UserName == oldName)); 149Assert.Null(db.Set<User<int>>().SingleOrDefault(u => u.UserName == oldName));

SqlStoreOnlyUsersTestBase.cs (1)

116Assert.Null(await userMgr.GetAuthenticationTokenAsync(user, "provider", "test"));

SqlStoreTestBase.cs (2)

171Assert.Null(await roleMgr.FindByNameAsync(roleName)); 215Assert.Null(await userMgr.GetAuthenticationTokenAsync(user, "provider", "test"));

UserStoreEncryptPersonalDataTest.cs (2)

79Assert.Null(await manager.FindByNameAsync(newName)); 90Assert.Null(await manager.FindByNameAsync(name));

ManagementTests.cs (3)

53Assert.Null(await UserStories.EnableTwoFactorAuthentication(index, consent: false)); 320Assert.Null((string)jsonData["Authenticator Key"]); 329Assert.Null((string)jsonData["Contoso external login provider key"]);

MapIdentityApiTests.cs (1)

868Assert.Null(updated2faContent.GetProperty("recoveryCodes").GetString());

FunctionalTest.cs (16)

IdentitySpecificationTestBase.cs (2)

275Assert.Null(await manager.FindByIdAsync(await manager.GetRoleIdAsync(role))); 290Assert.Null(await manager.FindByNameAsync(roleName));

UserManagerSpecificationTests.cs (11)

IdentityBuilderTest.cs (1)

49Assert.Null(sp.GetService<IRoleStore<PocoRole>>());

PrincipalExtensionsTest.cs (1)

16Assert.Null(id.FindFirstValue("bogus"));

SecurityStampValidatorTest.cs (2)

149Assert.Null(context.Principal); 231Assert.Null(context.Principal);

ConditionalTheoryTest.cs (1)

131Assert.Null(skippable.Skip);

LoggedTestXunitTests.cs (1)

125Assert.Null(argument);

CustomNamingStrategyTests.cs (1)

85Assert.Null(valueFromDictionary);

IntegrationTests\DictionaryIntegrationTest.cs (1)

220Assert.Null(actualValue1.Name);

IntegrationTests\DynamicObjectIntegrationTest.cs (4)

104Assert.Null(valueFromDictionary); 124Assert.Null(valueFromDictionary); 143Assert.Null(valueFromDictionary); 194Assert.Null(dynamicTestObject.SimpleObject.IntegerList);

IntegrationTests\ExpandoObjectIntegrationTest.cs (5)

213Assert.Null(targetObject.AnotherStringProperty); 236Assert.Null(valueFromDictionary); 258Assert.Null(valueFromDictionary); 298Assert.Null(valueFromDictionary); 339Assert.Null(valueFromDictionary);

IntegrationTests\NestedObjectIntegrationTest.cs (3)

155Assert.Null(targetObject.SimpleObject.StringProperty); 201Assert.Null(targetObject.SimpleObject.AnotherStringProperty); 330Assert.Null(targetObject.InheritedObject);

IntegrationTests\SimpleObjectIntegrationTest.cs (1)

66Assert.Null(targetObject.AnotherStringProperty);

Internal\DictionaryAdapterTest.cs (2)

82Assert.Null(outValue); 109Assert.Null(outValue);

Internal\DynamicObjectAdapterTest.cs (10)

26Assert.Null(errorMessage); 46Assert.Null(errorMessage); 64Assert.Null(errorMessage); 72Assert.Null(getErrorMessage); 90Assert.Null(getValue); 110Assert.Null(errorMessage); 147Assert.Null(errorMessage); 201Assert.Null(errorMessage); 223Assert.Null(errorMessage); 231Assert.Null(removeErrorMessage);

Internal\ListAdapterTest.cs (1)

61Assert.Null(message);

Internal\ObjectVisitorTest.cs (4)

220Assert.Null(adapter); 221Assert.Null(message); 236Assert.Null(adapter); 237Assert.Null(message);

Internal\PocoAdapterTest.cs (2)

94Assert.Null(value); 114Assert.Null(model.Name);

Filters\FilterContextTest.cs (1)

108Assert.Null(result);

ModelBinding\BindingInfoTest.cs (1)

93Assert.Null(bindingInfo);

ModelBinding\ModelMetadataTest.cs (8)

217Assert.Null(elementType); 251Assert.Null(metadata.ContainerType); 263Assert.Null(metadata.ContainerType); 286Assert.Null(metadata.Name); 287Assert.Null(metadata.ParameterName); 288Assert.Null(metadata.PropertyName); 302Assert.Null(metadata.PropertyName); 314Assert.Null(metadata.ParameterName);

ModelBinding\ModelStateDictionaryTest.cs (17)

78Assert.Null(result); 599Assert.Null(item.AttemptedValue); 600Assert.Null(item.RawValue); 876Assert.Null(error.Exception); 1416Assert.Null(entry.Value.RawValue); 1417Assert.Null(entry.Value.AttemptedValue); 1424Assert.Null(entry.Value.RawValue); 1425Assert.Null(entry.Value.AttemptedValue); 1440Assert.Null(entry.Value.RawValue); 1441Assert.Null(entry.Value.AttemptedValue); 1538Assert.Null(value.RawValue); 1539Assert.Null(value.AttemptedValue); 1545Assert.Null(value.RawValue); 1546Assert.Null(value.AttemptedValue); 1559Assert.Null(value.RawValue); 1560Assert.Null(value.AttemptedValue); 1581Assert.Null(property2);

ModelBinding\ValueProviderResultTest.cs (3)

19Assert.Null(result.FirstValue); 34Assert.Null(result.FirstValue); 49Assert.Null(result.FirstValue);

ApiResponseTypeProviderTest.cs (1)

703Assert.Null(format.Formatter);

DefaultApiDescriptionProviderTest.cs (12)

133Assert.Null(description.HttpMethod); 200Assert.Null(parameter.RouteInfo.DefaultValue); 246Assert.Null(parameter.RouteInfo.DefaultValue); 341Assert.Null(id.RouteInfo); 714Assert.Null(responseType.ModelMetadata); 817Assert.Null(responseType.ModelMetadata); 887Assert.Null(responseType.ModelMetadata); 957Assert.Null(responseType.ModelMetadata); 1063Assert.Null(responseType.ModelMetadata); 1088Assert.Null(responseType.ModelMetadata); 1457Assert.Null(requestFormat.Formatter); 2207Assert.Null(description.DefaultValue);

EndpointMetadataApiDescriptionProviderTest.cs (12)

68Assert.Null(requestFormat.Formatter); 94Assert.Null(requestFormat0.Formatter); 98Assert.Null(requestFormat1.Formatter); 143Assert.Null(responseFormat.Formatter); 162Assert.Null(responseFormat.Formatter); 1040Assert.Null(defaultRequestFormat.Formatter); 1069Assert.Null(defaultRequestFormat.Formatter); 1098Assert.Null(defaultRequestFormat.Formatter); 1111Assert.Null(requestFormat0.Formatter); 1115Assert.Null(requestFormat1.Formatter); 1185Assert.Null(defaultRequestFormat.Formatter); 1217Assert.Null(parameter.RouteInfo);

AcceptedAtActionResultTests.cs (2)

66Assert.Null(result.RouteValues); 113Assert.Null(result.UrlHelper);

ApiExplorer\ApiConventionResultTest.cs (1)

20Assert.Null(conventionResult);

ApplicationModels\ApiVisibilityConventionTest.cs (1)

51Assert.Null(action.ApiExplorer.IsVisible);

ApplicationModels\AttributeRouteModelTests.cs (1)

244Assert.Null(combined);

ApplicationModels\AuthorizationApplicationModelProviderTest.cs (3)

143Assert.Null(authorizationFilter.AuthorizeData); 144Assert.Null(authorizationFilter.PolicyProvider); 169Assert.Null(actionFilter.Policy);

ApplicationModels\ControllerActionDescriptorProviderTests.cs (16)

130Assert.Null(id.BindingInfo?.BindingSource); 149Assert.Null(id.BindingInfo?.BindingSource); 174Assert.Null(id.BindingInfo?.BindingSource); 180Assert.Null(upperCaseId.BindingInfo?.BindingSource); 186Assert.Null(id.BindingInfo?.BindingSource); 228Assert.Null(entity.BindingInfo?.BindingSource); 749Assert.Null(action.ActionConstraints); 974Assert.Null(action.GetProperty<ApiDescriptionActionData>()); 991Assert.Null(action.GetProperty<ApiDescriptionActionData>()); 1006Assert.Null(action.GetProperty<ApiDescriptionActionData>().GroupName); 1069Assert.Null(action.GetProperty<ApiDescriptionActionData>()); 1086Assert.Null(action.GetProperty<ApiDescriptionActionData>()); 1120Assert.Null(action.GetProperty<ApiDescriptionActionData>()); 1316Assert.Null(context.Results[0].RouteValues["page"]); 1319Assert.Null(context.Results[1].RouteValues["controller"]); 1321Assert.Null(context.Results[1].RouteValues["action"]);

ApplicationModels\DefaultApplicationModelProviderTest.cs (2)

107Assert.Null(property.BindingInfo); 203Assert.Null(parameter.BindingInfo);

ApplicationModels\InferParameterBindingInfoConventionTest.cs (7)

49Assert.Null(parameterModel.BindingInfo.BindingSource); 260Assert.Null(bindingInfo.BinderModelName); 663Assert.Null(bindingInfo.BinderModelName); 746Assert.Null(bindingInfo.BinderModelName); 767Assert.Null(bindingInfo.BinderModelName); 809Assert.Null(bindingInfo.BinderModelName); 896Assert.Null(bindingInfo.BinderModelName);

ApplicationModels\RouteTokenTransformerConventionTest.cs (1)

48Assert.Null(model.RouteParameterTransformer);

Authorization\AuthorizeFilterTest.cs (12)

Builder\MvcAreaRouteBuilderExtensionsTest.cs (2)

26Assert.Null(route.Name); 240Assert.Null(route.Name);

ConsumesAttributeTests.cs (2)

350Assert.Null(resourceExecutingContext.Result); 378Assert.Null(resourceExecutingContext.Result);

ControllerBaseTest.cs (10)

534Assert.Null(resultTemporary.ActionName); 554Assert.Null(resultTemporary.ActionName); 624Assert.Null(resultPermanent.ActionName); 644Assert.Null(resultPermanent.ActionName); 1316Assert.Null(result.Location); 1347Assert.Null(result.Location); 2191Assert.Null(actualContentResult.ContentType); 2206Assert.Null(MediaType.GetEncoding(actualContentResult.ContentType)); 2237Assert.Null(contentResult.ContentType); 2254Assert.Null(MediaType.GetEncoding(contentResult.ContentType));

Controllers\ControllerActivatorProviderTest.cs (1)

106Assert.Null(releaseDelegate);

Controllers\ControllerBinderDelegateProviderTest.cs (10)

Controllers\DefaultControllerFactoryTest.cs (3)

128Assert.Null(controller.ActionContext); 155Assert.Null(controller.ActionContext); 156Assert.Null(controller.ControllerContext);

CreatedResultTests.cs (2)

48Assert.Null(result.Location); 58Assert.Null(result.Location);

Filters\DisableRequestSizeLimitFilterTest.cs (2)

29Assert.Null(httpMaxRequestBodySize.MaxRequestBodySize); 49Assert.Null(httpMaxRequestBodySize.MaxRequestBodySize);

Filters\FilterFactoryTest.cs (1)

46Assert.Null(f.Filter);

Filters\MiddlewareFilterBuilderTest.cs (2)

215Assert.Null(exception.InnerException); 283Assert.Null(exception.InnerException);

Formatters\FormatFilterTest.cs (5)

46Assert.Null(resourceExecutingContext.Result); 167Assert.Null(resourceExecutingContext.Result); 189Assert.Null(resourceExecutingContext.Result); 210Assert.Null(resourceExecutingContext.Result); 276Assert.Null(resourceExecutingContext.Result);

Formatters\FormatterMappingsTest.cs (1)

125Assert.Null(options.GetMediaTypeMappingForFormat(format));

Formatters\InputFormatterTest.cs (2)

329Assert.Null(results); 428Assert.Null(result.Model);

Formatters\JsonInputFormatterTestBase.cs (1)

464Assert.Null(result.Model);

Formatters\NoContentFormatterTests.cs (1)

150Assert.Null(context.HttpContext.Response.ContentLength);

Formatters\OutputFormatterTests.cs (2)

46Assert.Null(contentTypes); 184Assert.Null(contentTypes);

Formatters\TextInputFormatterTest.cs (1)

82Assert.Null(result);

Formatters\TextOutputFormatterTests.cs (1)

202Assert.Null(MediaTypeHeaderValue.Parse(context.ContentType.Value).Encoding);

Infrastructure\ActionSelectorTest.cs (6)

578Assert.Null(action); 612Assert.Null(action); 902Assert.Null(result); 920Assert.Null(result); 940Assert.Null(result); 1182Assert.Null(item.Constraint);

Infrastructure\ControllerActionInvokerTest.cs (4)

495Assert.Null(context.Result); 555Assert.Null(context.Result); 598Assert.Null(context.Result); 641Assert.Null(context.Result);

Infrastructure\DefaultOutputFormatterSelectorTest.cs (3)

101Assert.Null(formatter); 266Assert.Null(formatter); 295Assert.Null(formatter);

Infrastructure\ModelStateInvalidFilterTest.cs (1)

49Assert.Null(context.Result);

Infrastructure\ObjectResultExecutorTest.cs (1)

455Assert.Null(formatterContext.Object);

Infrastructure\ProblemDetailsFactoryTest.cs (10)

25Assert.Null(problemDetails.Instance); 26Assert.Null(problemDetails.Detail); 46Assert.Null(problemDetails.Instance); 47Assert.Null(problemDetails.Detail); 69Assert.Null(problemDetails.Instance); 92Assert.Null(problemDetails.Instance); 93Assert.Null(problemDetails.Detail); 122Assert.Null(problemDetails.Instance); 123Assert.Null(problemDetails.Detail); 155Assert.Null(problemDetails.Detail);

Infrastructure\ProblemDetalsClientErrorFactoryTest.cs (5)

34Assert.Null(problemDetails.Title); 35Assert.Null(problemDetails.Detail); 36Assert.Null(problemDetails.Instance); 63Assert.Null(problemDetails.Detail); 64Assert.Null(problemDetails.Instance);

ModelBinding\Binders\ArrayModelBinderProviderTest.cs (1)

24Assert.Null(result);

ModelBinding\Binders\BinderTypeModelBinderProviderTest.cs (1)

20Assert.Null(result);

ModelBinding\Binders\BodyModelBinderProviderTest.cs (1)

38Assert.Null(result);

ModelBinding\Binders\BodyModelBinderTests.cs (15)

ModelBinding\Binders\ByteArrayModelBinderProviderTest.cs (1)

23Assert.Null(result);

ModelBinding\Binders\ByteArrayModelBinderTests.cs (2)

29Assert.Null(bindingContext.Result.Model); 98Assert.Null(bindingContext.Result.Model);

ModelBinding\Binders\CancellationTokenModelBinderProviderTest.cs (1)

23Assert.Null(result);

ModelBinding\Binders\CollectionModelBinderProviderTest.cs (1)

27Assert.Null(result);

ModelBinding\Binders\CollectionModelBinderTest.cs (1)

342Assert.Null(bindingContext.Result.Model);

ModelBinding\Binders\ComplexObjectModelBinderProviderTest.cs (1)

25Assert.Null(result);

ModelBinding\Binders\ComplexObjectModelBinderTest.cs (2)

622Assert.Null(modelError.Exception); 687Assert.Null(modelError.Exception);

ModelBinding\Binders\ComplexTypeModelBinderProviderTest.cs (1)

25Assert.Null(result);

ModelBinding\Binders\ComplexTypeModelBinderTest.cs (2)

800Assert.Null(modelError.Exception); 834Assert.Null(modelError.Exception);

ModelBinding\Binders\DateTimeModelBinderProviderTest.cs (1)

24Assert.Null(result);

ModelBinding\Binders\DateTimeModelBinderTest.cs (6)

46Assert.Null(bindingContext.Result.Model); 69Assert.Null(bindingContext.Result.Model); 73Assert.Null(error.Exception); 125Assert.Null(bindingContext.Result.Model); 129Assert.Null(error.Exception); 149Assert.Null(bindingContext.Result.Model);

ModelBinding\Binders\DictionaryModelBinderProviderTest.cs (1)

26Assert.Null(result);

ModelBinding\Binders\DictionaryModelBinderTest.cs (2)

261Assert.Null(bindingContext.Result.Model); 536Assert.Null(bindingContext.Result.Model);

ModelBinding\Binders\EnumTypeModelBinderProviderTest.cs (1)

56Assert.Null(result);

ModelBinding\Binders\EnumTypeModelBinderTest.cs (4)

24Assert.Null(bindingContext.Result.Model); 41Assert.Null(bindingContext.Result.Model); 146Assert.Null(bindingContext.Result.Model); 229Assert.Null(bindingContext.Result.Model);

ModelBinding\Binders\FloatingPointTypeModelBinderProviderTest.cs (2)

25Assert.Null(result); 45Assert.Null(result);

ModelBinding\Binders\FloatingPointTypeModelBinderTestOfT.cs (12)

68Assert.Null(bindingContext.Result.Model); 92Assert.Null(bindingContext.Result.Model); 96Assert.Null(error.Exception); 116Assert.Null(bindingContext.Result.Model); 120Assert.Null(error.Exception); 140Assert.Null(bindingContext.Result.Model); 144Assert.Null(error.Exception); 164Assert.Null(bindingContext.Result.Model); 168Assert.Null(error.Exception); 206Assert.Null(bindingContext.Result.Model); 210Assert.Null(error.Exception); 230Assert.Null(bindingContext.Result.Model);

ModelBinding\Binders\FormCollectionModelBinderProviderTest.cs (1)

41Assert.Null(result);

ModelBinding\Binders\FormFileModelBinderProviderTest.cs (1)

26Assert.Null(result);

ModelBinding\Binders\FormFileModelBinderTest.cs (12)

34Assert.Null(entry.Metadata); 68Assert.Null(entry.Metadata); 108Assert.Null(entry.Metadata); 150Assert.Null(entry.Metadata); 184Assert.Null(entry.Metadata); 220Assert.Null(entry.Metadata); 241Assert.Null(entry.Metadata); 305Assert.Null(bindingContext.Result.Model); 325Assert.Null(bindingContext.Result.Model); 375Assert.Null(bindingContext.Result.Model); 395Assert.Null(bindingContext.Result.Model); 429Assert.Null(bindingContext.Result.Model);

ModelBinding\Binders\HeaderModelBinderProviderTest.cs (3)

42Assert.Null(result); 136Assert.Null(result); 175Assert.Null(result);

ModelBinding\Binders\HeaderModelBinderTests.cs (2)

171Assert.Null(bindingContext.Result.Model); 190Assert.Null(bindingContext.Result.Model);

ModelBinding\Binders\KeyValuePairModelBinderProviderTest.cs (1)

26Assert.Null(result);

ModelBinding\Binders\KeyValuePairModelBinderTest.cs (2)

29Assert.Null(bindingContext.Result.Model); 53Assert.Null(bindingContext.Result.Model);

ModelBinding\Binders\ServicesModelBinderProviderTest.cs (1)

37Assert.Null(result);

ModelBinding\Binders\ServicesModelBinderTest.cs (2)

29Assert.Null(entry.Key); 30Assert.Null(entry.Metadata);

ModelBinding\Binders\SimpleTypeModelBinderProviderTest.cs (1)

25Assert.Null(result);

ModelBinding\Binders\SimpleTypeModelBinderTest.cs (7)

127Assert.Null(bindingContext.Result.Model); 131Assert.Null(error.Exception); 152Assert.Null(bindingContext.Result.Model); 214Assert.Null(bindingContext.Result.Model); 332Assert.Null(error.Exception); 373Assert.Null(bindingContext.Result.Model); 377Assert.Null(error.Exception);

ModelBinding\Binders\TryParseTypeModelBinderProviderTest.cs (1)

22Assert.Null(result);

ModelBinding\Binders\TryParseTypeModelBinderTest.cs (8)

76Assert.Null(bindingContext.Result.Model); 80Assert.Null(error.Exception); 101Assert.Null(bindingContext.Result.Model); 258Assert.Null(error.Exception); 299Assert.Null(bindingContext.Result.Model); 303Assert.Null(error.Exception); 408Assert.Null(error.Exception); 458Assert.Null(error.Exception);

ModelBinding\BindingSourceValueProviderTest.cs (1)

59Assert.Null(result);

ModelBinding\CompositeValueProviderTest.cs (1)

187Assert.Null(result);

ModelBinding\DefaultModelBindingContextTest.cs (1)

55Assert.Null(bindingContext.Model);

ModelBinding\EnumerableValueProviderTest.cs (1)

287Assert.Null(result);

ModelBinding\JQueryFormValueProviderTest.cs (1)

30Assert.Null(result);

ModelBinding\JQueryQueryStringValueProviderTest.cs (1)

33Assert.Null(result);

ModelBinding\Metadata\DefaultBindingMetadataProviderTest.cs (7)

671Assert.Null(result); 689Assert.Null(result); 707Assert.Null(result); 726Assert.Null(result); 774Assert.Null(result); 796Assert.Null(result); 868Assert.Null(result);

ModelBinding\Metadata\DefaultModelMetadataProviderTest.cs (1)

195Assert.Null(property.PropertyGetter(null));

ModelBinding\Metadata\DefaultModelMetadataTest.cs (20)

ModelBinding\Metadata\DefaultValidationMetadataProviderTest.cs (2)

44Assert.Null(context.ValidationMetadata.PropertyValidationFilter); 61Assert.Null(context.ValidationMetadata.PropertyValidationFilter);

ModelBinding\Metadata\HasValidatorsValidationMetadataProviderTest.cs (2)

30Assert.Null(context.ValidationMetadata.HasValidators); 48Assert.Null(context.ValidationMetadata.HasValidators);

ModelBinding\Metadata\ModelAttributesTest.cs (6)

152Assert.Null(attributes.PropertyAttributes); 191Assert.Null(attributes.PropertyAttributes); 214Assert.Null(attributes.PropertyAttributes); 237Assert.Null(attributes.PropertyAttributes); 259Assert.Null(attributes.PropertyAttributes); 283Assert.Null(attributes.ParameterAttributes);

ModelBinding\Metadata\ModelBinderAttributeTest.cs (1)

20Assert.Null(source);

ModelBinding\Metadata\SystemTextJsonValidationMetadataProviderTest.cs (1)

60Assert.Null(context.ValidationMetadata.ValidationModelName);

ModelBinding\ModelBindingHelperTest.cs (13)

ModelBinding\ModelBindingResultTest.cs (1)

30Assert.Null(result.Model);

ModelBinding\RouteValueProviderTests.cs (1)

268Assert.Null(result);

ModelBinding\UnsupportedContentTypeFilterTest.cs (3)

69Assert.Null(context.Result); 93Assert.Null(context.Result); 125Assert.Null(context.Result);

ModelBinding\Validation\DefaultComplexObjectValidationStrategyTest.cs (3)

109Assert.Null(entry.Model); 115Assert.Null(entry.Model); 121Assert.Null(entry.Model);

ObjectResultTests.cs (2)

30Assert.Null(result.StatusCode); 31Assert.Null(result.DeclaredType);

ProducesResponseTypeAttributeTests.cs (1)

67Assert.Null(producesResponseTypeAttribute.ContentTypes);

RedirectToPageResultTest.cs (3)

111Assert.Null(context.RouteName); 165Assert.Null(context.RouteName); 288Assert.Null(value.Value);

RequireHttpsAttributeTests.cs (1)

29Assert.Null(authContext.Result);

ResponseCacheAttributeTest.cs (1)

173Assert.Null(responseCacheFilter.VaryByQueryKeys);

Routing\AttributeRouteTest.cs (2)

107Assert.Null(context.Handler); 109Assert.Null(selected);

Routing\ControllerActionEndpointDataSourceTest.cs (10)

Routing\DynamicControllerEndpointMatcherPolicyTest.cs (2)

154Assert.Null(candidates[0].Endpoint); 155Assert.Null(candidates[0].Values);

Routing\EndpointRoutingUrlHelperTest.cs (1)

113Assert.Null(url);

Routing\RouteTemplateProviderAttributesTest.cs (1)

13Assert.Null(routeTemplateProvider.Order);

Routing\UrlHelperExtensionsTest.cs (35)

Routing\UrlHelperTestBase.cs (1)

521Assert.Null(url);

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

292Assert.Null(httpResponse.ContentLength); 326Assert.Null(httpResponse.ContentLength);

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

284Assert.Null(httpResponse.ContentLength); 320Assert.Null(httpResponse.ContentLength);

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

121Assert.Null(sendFile.Length); 148Assert.Null(sendFile.Length); 177Assert.Null(sendFile.Length); 232Assert.Null(httpResponse.ContentLength); 259Assert.Null(httpResponse.ContentLength); 339Assert.Null(sendFile.Length); 359Assert.Null(sendFile.Length);

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

144Assert.Null(sendFileFeature.Length); 177Assert.Null(sendFileFeature.Length); 212Assert.Null(sendFileFeature.Length); 278Assert.Null(httpResponse.ContentLength); 281Assert.Null(sendFileFeature.Name); // Not called 309Assert.Null(httpResponse.ContentLength); 313Assert.Null(sendFileFeature.Name); // Not called

CommonFilterTest.cs (1)

39Assert.Null(context.Result);

CommonResourceInvokerTest.cs (5)

113Assert.Null(resultFromAction); 159Assert.Null(resultFromAction); 1267Assert.Null(context.Exception); 1268Assert.Null(context.ExceptionDispatchInfo); 1616Assert.Null(context.Result);

DisableCorsAuthorizationFilterTest.cs (2)

31Assert.Null(authorizationFilterContext.Result); 50Assert.Null(authorizationFilterContext.Result);

DataAnnotationsClientModelValidatorProviderTest.cs (1)

132Assert.Null(validatorItem.Validator);

DataAnnotationsMetadataProviderTest.cs (6)

1218Assert.Null(context.ValidationMetadata.IsRequired); 1277Assert.Null(context.ValidationMetadata.IsRequired); 1298Assert.Null(context.ValidationMetadata.IsRequired); 1375Assert.Null(context.ValidationMetadata.IsRequired); 1396Assert.Null(context.ValidationMetadata.IsRequired); 1438Assert.Null(context.ValidationMetadata.IsRequired);

ModelMetadataProviderTest.cs (4)

505Assert.Null(result); 618Assert.Null(metadata.BinderType); 781Assert.Null(metadata.PropertySetter); 795Assert.Null(metadata.Properties[propertyName]);

EnumerableWrapperProviderFactoryTest.cs (1)

162Assert.Null(wrapperProvider);

EnumerableWrapperProviderTest.cs (1)

68Assert.Null(wrapped);

ProblemDetailsWrapperProviderFactoryTest.cs (2)

19Assert.Null(provider); 68Assert.Null(provider);

SerializableErrorWrapperTests.cs (1)

51Assert.Null(serializableError.GetSchema());

SerializableWrapperProviderFactoryTest.cs (1)

36Assert.Null(wrapperProvider);

ApiExplorerTest.cs (3)

392Assert.Null(description.HttpMethod); 907Assert.Null(responseFormat.FormatterType); 1122Assert.Null(parameter.DefaultValue);

BasicTests.cs (3)

152Assert.Null(response.Content.Headers.ContentType); 567Assert.Null(data.IdFromRoute); 588Assert.Null(data.BindNeverProperty);

GlobalAuthorizationFilterTestBase.cs (1)

80Assert.Null(response.Headers.Location);

HtmlGenerationTest.cs (1)

398Assert.Null(validation);

InputFormatterTests.cs (4)

227Assert.Null(content.Headers.ContentType); 272Assert.Null(content.Headers.ContentType); 287Assert.Null(content.Headers.ContentType); 302Assert.Null(content.Headers.ContentType);

OutputFormatterTest.cs (3)

75Assert.Null(response.Content.Headers.ContentType); 93Assert.Null(response.Content.Headers.ContentType); 113Assert.Null(response.Content.Headers.ContentType);

RoutingTestsBase.cs (1)

1118Assert.Null(result.RouteName);

TempDataInCookiesTest.cs (7)

84Assert.Null(cookieTempDataProviderCookie.Domain.Value); 102Assert.Null(setCookieHeaderValue.Domain.Value); 134Assert.Null(setCookieHeader.Domain.Value); 136Assert.Null(setCookieHeader.Expires); 158Assert.Null(setCookieHeader.Domain.Value); 187Assert.Null(setCookieHeader.Domain.Value); 189Assert.Null(setCookieHeader.Expires);

BinderTypeBasedModelBinderIntegrationTest.cs (1)

41Assert.Null(modelBindingResult.Model);

BodyValidationIntegrationTests.cs (6)

427Assert.Null(modelBindingResult.Model); 479Assert.Null(entry.Value!.AttemptedValue); 480Assert.Null(entry.Value.RawValue); 581Assert.Null(boundPerson.Address); 589Assert.Null(state.AttemptedValue); 590Assert.Null(state.RawValue);

ComplexRecordIntegrationTest.cs (76)

ComplexTypeIntegrationTestBase.cs (68)

DictionaryModelBinderIntegrationTest.cs (5)

456Assert.Null(modelBindingResult.Model); 878Assert.Null(modelBindingResult.Model); 1261Assert.Null(kvp.Value); 1324Assert.Null(person.Name); 1477Assert.Null(person.Name);

GenericModelBinderIntegrationTest.cs (1)

249Assert.Null(model[0]);

HeaderModelBinderIntegrationTest.cs (1)

350Assert.Null(product.Manufacturer.NullableLongProperty);

KeyValuePairModelBinderIntegrationTest.cs (4)

81Assert.Null(error.Exception); 131Assert.Null(error.Exception); 173Assert.Null(error.Exception); 223Assert.Null(error.Exception);

ModelPrefixSelectionIntegrationTest.cs (5)

53Assert.Null(model.Name); 102Assert.Null(model.Name); 141Assert.Null(model.Name); 190Assert.Null(model.Name); 236Assert.Null(model.Name);

NullableReferenceTypeIntegrationTest.cs (4)

45Assert.Null(boundPerson.FirstName); 93Assert.Null(boundPerson.FirstName); 132Assert.Null(boundPerson.FirstName); 187Assert.Null(modelBindingResult.Model);

ServicesModelBinderIntegrationTest.cs (2)

257Assert.Null(modelBindingResult.Model); 326Assert.Null(modelBindingResult.Model);

SimpleTypeModelBinderIntegrationTest.cs (9)

389Assert.Null(modelBindingResult.Model); 405Assert.Null(error.Exception); 449Assert.Null(modelBindingResult.Model); 465Assert.Null(error.Exception); 498Assert.Null(modelBindingResult.Model); 508Assert.Null(error.Exception); 552Assert.Null(modelBindingResult.Model); 562Assert.Null(error.Exception); 595Assert.Null(modelBindingResult.Model);

TryUpdateModelIntegrationTest.cs (22)

ValidationIntegrationTests.cs (31)

ValidationWithRecordIntegrationTests.cs (31)

NewtonsoftJsonInputFormatterTest.cs (5)

135Assert.Null(result.Model); 339Assert.Null(modelError.Exception); 370Assert.Null(modelError.Exception); 401Assert.Null(modelError.Exception); 432Assert.Null(modelError.Exception);

NewtonsoftJsonPatchInputFormatterTest.cs (1)

100Assert.Null(result.Model);

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

464Assert.Null(result.Model);

src\Mvc\Mvc.ViewFeatures\test\Infrastructure\TempDataSerializerTestBase.cs (1)

41Assert.Null(values[key]);

FileProviderRazorProjectFileSystemTest.cs (1)

222Assert.Null(item.RelativePhysicalPath);

RuntimeViewCompilerTest.cs (1)

206Assert.Null(precompiledView.ExpirationTokens);

Compilation\DefaultViewCompilerTest.cs (1)

44Assert.Null(compiledView.ExpirationTokens);

RazorPageActivatorTest.cs (2)

68Assert.Null(instance.MyService2); 140Assert.Null(instance.MyService2);

RazorViewEngineTest.cs (12)

1076Assert.Null(result.Page); 1092Assert.Null(result.Page); 1106Assert.Null(result.Page); 1119Assert.Null(result.Page); 1191Assert.Null(result.SearchedLocations); 1250Assert.Null(result.SearchedLocations); 1273Assert.Null(result.Page); 1310Assert.Null(result.SearchedLocations); 1343Assert.Null(result.Page); 1379Assert.Null(result.Page); 1408Assert.Null(result.Page); 1846Assert.Null(c.PageName);

RazorViewTest.cs (1)

1666Assert.Null(v.Layout);

ApplicationModels\CompiledPageRouteModelProviderTest.cs (1)

469Assert.Null(result);

ApplicationModels\DefaultPageApplicationModelProviderTest.cs (6)

157Assert.Null(property.BindingInfo); 305Assert.Null(handler.HandlerName); 313Assert.Null(handler.HandlerName); 346Assert.Null(property.BindingInfo); 1019Assert.Null(httpMethod); 1020Assert.Null(handler);

ApplicationModels\PageRouteModelFactoryTest.cs (1)

25Assert.Null(routeModel.AreaName);

ApplicationModels\PageRouteTransformerConventionTest.cs (1)

40Assert.Null(model.RouteParameterTransformer);

Filters\PageSaveTempDataPropertyFilterTest.cs (2)

75Assert.Null(pageModel.Test2); 156Assert.Null(model.Test2);

Infrastructure\DefaultPageActivatorProviderTest.cs (2)

83Assert.Null(releaser); 103Assert.Null(releaser);

Infrastructure\DefaultPageFactoryProviderTest.cs (3)

279Assert.Null(testPage.DiagnosticSourceWithoutInject); 282Assert.Null(testPage.LoggerWithoutInject); 285Assert.Null(testPage.ModelExpressionProviderWithoutInject);

Infrastructure\DefaultPageLoaderTest.cs (4)

51Assert.Null(c.PageApplicationModel); 130Assert.Null(c.PageApplicationModel); 247Assert.Null(c.PageApplicationModel); 307Assert.Null(c.PageApplicationModel);

Infrastructure\DefaultPageModelActivatorProviderTest.cs (2)

107Assert.Null(releaser); 127Assert.Null(releaser);

Infrastructure\DefaultPageModelFactoryProviderTest.cs (3)

23Assert.Null(factory); 38Assert.Null(disposer); 79Assert.Null(testModel.ContextWithoutAttribute);

Infrastructure\DisallowOptionsRequestsPageFilterTest.cs (3)

23Assert.Null(context.Result); 54Assert.Null(context.Result); 88Assert.Null(context.Result);

Infrastructure\DynamicPageEndpointMatcherPolicyTest.cs (2)

171Assert.Null(candidates[0].Endpoint); 172Assert.Null(candidates[0].Values);

Infrastructure\ExecutorFactoryTest.cs (2)

93Assert.Null(actionResult); 116Assert.Null(actionResult);

Infrastructure\PageActionInvokerProviderTest.cs (2)

70Assert.Null(entry.ModelFactory); 71Assert.Null(entry.ReleaseModel);

Infrastructure\PageActionInvokerTest.cs (7)

257Assert.Null(page.PageContext.ViewData.Model); 261Assert.Null(pageResult.Model); 483Assert.Null(pageResult.Page); 1015Assert.Null(context.Result); 1078Assert.Null(context.Result); 1123Assert.Null(context.Result); 1168Assert.Null(context.Result);

Infrastructure\PageBinderFactoryTest.cs (4)

231Assert.Null(page.PropertyWithNoValue); 293Assert.Null(page.RouteDifferentValue); 297Assert.Null(model.PropertyWithNoValue); 513Assert.Null(model.BindNeverProperty);

Infrastructure\ServiceBasedPageModelActivatorProviderTest.cs (1)

138Assert.Null(releaser);

PageModelTest.cs (12)

525Assert.Null(resultTemporary.ActionName); 545Assert.Null(resultTemporary.ActionName); 615Assert.Null(resultPermanent.ActionName); 635Assert.Null(resultPermanent.ActionName); 970Assert.Null(result.PageName); 1000Assert.Null(result.PageName); 1576Assert.Null(actualContentResult.ContentType); 1591Assert.Null(MediaType.GetEncoding(actualContentResult.ContentType)); 1622Assert.Null(contentResult.ContentType); 1639Assert.Null(MediaType.GetEncoding(contentResult.ContentType)); 1839Assert.Null(pageResult.Page); // This is set by the invoker 1956Assert.Null(result.Model);

PageTest.cs (11)

545Assert.Null(resultTemporary.ActionName); 565Assert.Null(resultTemporary.ActionName); 635Assert.Null(resultPermanent.ActionName); 655Assert.Null(resultPermanent.ActionName); 1044Assert.Null(result.PageName); 1074Assert.Null(result.PageName); 1566Assert.Null(actualContentResult.ContentType); 1581Assert.Null(MediaType.GetEncoding(actualContentResult.ContentType)); 1612Assert.Null(contentResult.ContentType); 1629Assert.Null(MediaType.GetEncoding(contentResult.ContentType)); 1730Assert.Null(result.Model);

CacheTagHelperTest.cs (1)

534Assert.Null(cachedValue);

ComponentTagHelperTest.cs (1)

42Assert.Null(output.TagName);

EnvironmentTagHelperTest.cs (4)

102Assert.Null(output.TagName); 146Assert.Null(output.TagName); 179Assert.Null(output.TagName); 204Assert.Null(output.TagName);

FormActionTagHelperTest.cs (4)

222Assert.Null(param.Host); 223Assert.Null(param.Protocol); 279Assert.Null(param.Host); 280Assert.Null(param.Protocol);

LinkTagHelperTest.cs (1)

404Assert.Null(output.TagName);

PartialTagHelperTest.cs (2)

56Assert.Null(model); 379Assert.Null(v.ViewData.Model);

PersistComponentStateTagHelperTest.cs (4)

51Assert.Null(output.TagName); 73Assert.Null(output.TagName); 100Assert.Null(output.TagName); 130Assert.Null(output.TagName);

ScriptTagHelperTest.cs (1)

380Assert.Null(output.TagName);

SelectTagHelperTest.cs (1)

428Assert.Null(kvp.Value);

TagHelperOutputExtensionsTest.cs (2)

1078Assert.Null(classAttribute); 1122Assert.Null(classAttribute);

ValidationSummaryTagHelperTest.cs (2)

130Assert.Null(output.TagName); 198Assert.Null(output.TagName);

AttributeDictionaryTest.cs (1)

334Assert.Null(value);

Builder\ControllerActionEndpointConventionBuilderResourceCollectionExtensionsTest.cs (8)

37Assert.Null(metadata); 67Assert.Null(metadata); 98Assert.Null(metadata); 129Assert.Null(metadata); 161Assert.Null(metadata); 193Assert.Null(metadata); 228Assert.Null(metadata); 263Assert.Null(metadata);

CachedExpressionCompilerTest.cs (17)

72Assert.Null(result); 330Assert.Null(result); 346Assert.Null(result); 378Assert.Null(result); 475Assert.Null(result); 508Assert.Null(result); 607Assert.Null(result); 628Assert.Null(result); 678Assert.Null(result); 694Assert.Null(result); 710Assert.Null(result); 786Assert.Null(result); 802Assert.Null(result); 816Assert.Null(func); 864Assert.Null(func); 879Assert.Null(func); 892Assert.Null(func);

ControllerTest.cs (12)

ControllerUnitTestabilityTests.cs (26)

143Assert.Null(fileContentResult.FileContents); 176Assert.Null(fileStreamResult.FileStream); 215Assert.Null(jsonResult.Value); 315Assert.Null(httpBadRequest.Value); 349Assert.Null(createdAtRouteResult.RouteName); 350Assert.Null(createdAtRouteResult.RouteValues); 351Assert.Null(createdAtRouteResult.Value); 385Assert.Null(acceptedAtRouteResult.RouteName); 386Assert.Null(acceptedAtRouteResult.RouteValues); 387Assert.Null(acceptedAtRouteResult.Value); 423Assert.Null(createdAtActionResult.ActionName); 424Assert.Null(createdAtActionResult.ControllerName); 425Assert.Null(createdAtActionResult.Value); 426Assert.Null(createdAtActionResult.RouteValues); 462Assert.Null(acceptedAtActionResult.ActionName); 463Assert.Null(acceptedAtActionResult.ControllerName); 464Assert.Null(acceptedAtActionResult.Value); 465Assert.Null(acceptedAtActionResult.RouteValues); 497Assert.Null(redirectToRouteResult.RouteName); 498Assert.Null(redirectToRouteResult.RouteValues); 532Assert.Null(redirectToActionResult.ControllerName); 533Assert.Null(redirectToActionResult.ActionName); 534Assert.Null(redirectToActionResult.RouteValues); 569Assert.Null(controller.ControllerContext.ActionDescriptor); 570Assert.Null(controller.ControllerContext.HttpContext); 571Assert.Null(controller.ControllerContext.RouteData);

CookieTempDataProviderTest.cs (5)

177Assert.Null(cookieInfo.Options.Expires); 178Assert.Null(cookieInfo.Options.Domain); 212Assert.Null(cookieInfo.Options.Expires); 213Assert.Null(cookieInfo.Options.Domain); 262Assert.Null(cookieInfo.Options.Expires);

DefaultHtmlGeneratorTest.cs (3)

42Assert.Null(result); 64Assert.Null(result); 509Assert.Null(result);

ExpressionMetadataProviderTest.cs (5)

32Assert.Null(explorer.Model); 50Assert.Null(explorer.Model); 68Assert.Null(explorer.Model); 90Assert.Null(explorer.Model); 134Assert.Null(explorer.Model);

Filters\AntiforgeryMiddlewareAuthorizationFilterTest.cs (3)

47Assert.Null(context.Result); 64Assert.Null(context.Result); 81Assert.Null(context.Result);

Filters\LifecyclePropertyTest.cs (2)

50Assert.Null(subject.TestProperty); 80Assert.Null(subject.NullableProperty);

Filters\ViewDataAttributePropertyProviderTest.cs (1)

18Assert.Null(result);

Infrastructure\TempDataSerializerTestBase.cs (1)

41Assert.Null(values[key]);

ModelExplorerTest.cs (2)

117Assert.Null(propertyValue); 136Assert.Null(propertyExplorer);

PartialViewResultExecutorTest.cs (4)

131Assert.Null(result.View); 166Assert.Null(result.View); 201Assert.Null(result.View); 306Assert.Null(MediaType.GetEncoding(contentType));

RemoteAttributeBaseTest.cs (3)

39Assert.Null(attribute.ErrorMessage); 40Assert.Null(attribute.ErrorMessageResourceName); 41Assert.Null(attribute.ErrorMessageResourceType);

RemoteAttributeTest.cs (7)

69Assert.Null(attribute.RouteName); 100Assert.Null(attribute.RouteName); 118Assert.Null(attribute.RouteName); 138Assert.Null(attribute.RouteName); 537Assert.Null(routeContext.Protocol); 538Assert.Null(routeContext.Host); 539Assert.Null(routeContext.Fragment);

Rendering\HtmlHelperSelectTest.cs (1)

1563Assert.Null(actualItem.Group);

Rendering\ViewContextTests.cs (1)

39Assert.Null(context.ViewBag.Hello);

ViewComponents\DefaultViewComponentActivatorTests.cs (1)

60Assert.Null(instance.C);

ViewComponentTests.cs (10)

78Assert.Null(actualResult.ViewData.Model); 79Assert.Null(actualResult.ViewName); 98Assert.Null(actualResult.ViewName); 115Assert.Null(actualResult.ViewData.Model); 136Assert.Null(actualResult.ViewName); 155Assert.Null(actualResult.ViewData.Model); 156Assert.Null(actualResult.ViewName); 174Assert.Null(actualResult.ViewData.Model); 193Assert.Null(actualResult.ViewData.Model); 227Assert.Null(viewComponent.ViewContext.TempData);

ViewDataDictionaryOfTModelTest.cs (7)

24Assert.Null(viewData.Model); 90Assert.Null(viewData1.Model); 102Assert.Null(viewData2.Model); 366Assert.Null(viewData1.Model); 367Assert.Null(viewData2.Model); 368Assert.Null(viewData3.Model); 369Assert.Null(viewData4.Model);

ViewDataDictionaryTest.cs (4)

24Assert.Null(viewData.Model); 42Assert.Null(viewData.Model); 509Assert.Null(result); 693Assert.Null(result);

ViewDataOfTTest.cs (1)

63Assert.Null(viewData.Model);

ViewResultExecutorTest.cs (3)

129Assert.Null(result.View); 163Assert.Null(result.View); 197Assert.Null(result.View);

ViewResultTest.cs (1)

31Assert.Null(viewResult.Model);

Services\OpenApiDocumentService\OpenApiDocumentServiceTests.Parameters.cs (2)

162Assert.Null(usersOperation.Parameters); 164Assert.Null(todosOperation.Parameters);

Services\OpenApiDocumentService\OpenApiDocumentServiceTests.RequestBody.cs (1)

398Assert.Null(operation.RequestBody);

Services\OpenApiGeneratorTests.cs (5)

29Assert.Null(operation); 577Assert.Null(operation); 915Assert.Null(operationWithNoParams.RequestBody); 924Assert.Null(operationWithNoBodyParams.RequestBody); 991Assert.Null(operation.RequestBody);

Services\OpenApiSchemaService\OpenApiSchemaService.ResponseSchemas.cs (2)

642Assert.Null(property.Value.Type); 648Assert.Null(property.Value.Type);

Transformers\Implementations\OpenApiSchemaReferenceTransformerTests.cs (2)

206Assert.Null(requestBodySchema.AllOf[1].GetEffective(document).Properties["title"].Reference); 207Assert.Null(requestBodySchema2.AllOf[1].GetEffective(document).Properties["title"].Reference);

Transformers\SchemaTransformerTests.cs (1)

41Assert.Null(context.ParameterDescription);

MemoryOutputCacheStoreTests.cs (2)

86Assert.Null(tag1s); 196Assert.Null(tag1s);

OutputCacheMiddlewareTests.cs (1)

580Assert.Null(context.CachedResponse);

OwinExtensionTests.cs (2)

85Assert.Null(fakeService); 118Assert.Null(fakeService);

RateLimiterEndpointConventionBuilderExtensionsTests.cs (2)

32Assert.Null(metadata.Policy); 54Assert.Null(metadata.PolicyName);

RateLimitingApplicationBuilderExtensionsTests.cs (1)

81Assert.Null(exception);

Runtime\TagHelpers\TagHelperScopeManagerTest.cs (1)

199Assert.Null(executionContext);

TagHelpers\TagHelperOutputTest.cs (5)

85Assert.Null(passedEncoder); 156Assert.Null(passedEncoder); 249Assert.Null(tagHelperOutput.TagName); 262Assert.Null(tagHelperOutput.TagName); 332Assert.Null(tagHelperOutput.TagName);

DefaultRequestDecompressionProviderTests.cs (3)

66Assert.Null(matchingProvider); 93Assert.Null(matchingProvider); 121Assert.Null(matchingProvider);

RequestDecompressionMiddlewareTests.cs (2)

507Assert.Null(exception); 591Assert.Null(exception);

SizeLimitedStreamTests.cs (1)

104Assert.Null(exception);

ResponseCachingMiddlewareTests.cs (1)

661Assert.Null(context.CachedResponse);

MiddlewareTests.cs (2)

528Assert.Null(response.Headers.Location); 755Assert.Null(response.Headers.Location);

PatternSegments\LocalAddressSegmentTests.cs (1)

36Assert.Null(results);

PatternSegments\RemoteAddressSegmentTests.cs (1)

36Assert.Null(results);

Builder\EndpointRoutingApplicationBuilderExtensionsTest.cs (2)

72Assert.Null(httpContext.Features.Get<IEndpointFeature>()); 168Assert.Null(httpContext.Features.Get<IEndpointFeature>());

Builder\RouteHandlerEndpointRouteBuilderExtensionsTest.cs (5)

167Assert.Null(httpContext.Items["input"]); 587Assert.Null(httpContext.Items["input"]); 644Assert.Null(httpContext.Items["value"]); 800Assert.Null(endpointName); 801Assert.Null(routeName);

DataSourceDependentCacheTest.cs (2)

49Assert.Null(cache.Value); 94Assert.Null(cache.Value);

DefaultInlineConstraintResolverTest.cs (2)

101Assert.Null(_constraintResolver.ResolveConstraint("composite")); 352Assert.Null(resolver.ResolveConstraint(constraint));

DefaultLinkGeneratorTest.cs (4)

29Assert.Null(path); 44Assert.Null(path); 59Assert.Null(uri); 74Assert.Null(uri);

DefaultLinkParserTest.cs (2)

33Assert.Null(values); 55Assert.Null(values);

EndpointRoutingMiddlewareFormOptionsTest.cs (1)

186Assert.Null(formFeature);

InlineRouteParameterParserTests.cs (12)

LinkGeneratorEndpointNameExtensionsTest.cs (1)

41Assert.Null(path);

LinkParserEndpointNameExtensionsTest.cs (2)

22Assert.Null(values); 38Assert.Null(values);

Matching\AcceptsMatcherPolicyTest.cs (2)

565Assert.Null(httpContext.GetEndpoint()); 595Assert.Null(httpContext.GetEndpoint());

Matching\CandidateSetTest.cs (4)

37Assert.Null(state.Values); 101Assert.Null(state.Endpoint); 102Assert.Null(state.Values); 132Assert.Null(candidateSet[0].Endpoint);

Matching\ContentEncodingNegotiationMatcherPolicyTest.cs (6)

88Assert.Null(httpContext.GetEndpoint()); 108Assert.Null(httpContext.GetEndpoint()); 128Assert.Null(httpContext.GetEndpoint()); 148Assert.Null(httpContext.GetEndpoint()); 168Assert.Null(httpContext.GetEndpoint()); 229Assert.Null(httpContext.GetEndpoint());

Matching\DefaultEndpointSelectorTest.cs (3)

26Assert.Null(httpContext.GetEndpoint()); 47Assert.Null(httpContext.GetEndpoint()); 167Assert.Null(httpContext.GetEndpoint());

Matching\DfaMatcherBuilderTest.cs (85)

Matching\DfaMatcherTest.cs (8)

100Assert.Null(httpContext.GetEndpoint()); 129Assert.Null(httpContext.GetEndpoint()); 194Assert.Null(httpContext.GetEndpoint()); 656Assert.Null(cs[0].Values); 661Assert.Null(cs[1].Values); 797Assert.Null(httpContext.GetEndpoint()); 827Assert.Null(httpContext.GetEndpoint()); 867Assert.Null(httpContext.GetEndpoint());

Patterns\DefaultRoutePatternTransformerTest.cs (8)

59Assert.Null(actual); 104Assert.Null(actual); 123Assert.Null(actual); 204Assert.Null(actual.GetParameter("controller").Default); 206Assert.Null(actual.GetParameter("action").Default); 248Assert.Null(actual); 289Assert.Null(actual); 397Assert.Null(actual);

Patterns\InlineRouteParameterParserTest.cs (12)

18Assert.Null(templatePart.Default); 42Assert.Null(templatePart.Default); 522Assert.Null(templatePart.Default); 547Assert.Null(templatePart.Default); 772Assert.Null(templatePart.Default); 787Assert.Null(templatePart.Default); 832Assert.Null(templatePart.Default); 847Assert.Null(templatePart.Default); 863Assert.Null(templatePart.Default); 878Assert.Null(templatePart.Default); 893Assert.Null(templatePart.Default); 934Assert.Null(templatePart.Default);

Patterns\RoutePatternFactoryTest.cs (9)

486Assert.Null(paramPartB.Default); 491Assert.Null(paramPartC.Default); 493Assert.Null(actual.Parameters[2].Default); 495Assert.Null(paramPartD.Default); 526Assert.Null(paramPartB.Default); 531Assert.Null(paramPartC.Default); 533Assert.Null(actual.Parameters[2].Default); 535Assert.Null(paramPartD.Default); 574kvp => { Assert.Equal("area", kvp.Key); Assert.Null(kvp.Value); },

Patterns\RoutePatternMatcherTest.cs (4)

400Assert.Null(values["p2"]); 424Assert.Null(values["d"]); 727Assert.Null(values["p2"]); 745Assert.Null(values["p2"]);

RequestDelegateRouteBuilderExtensionsTest.cs (1)

120Assert.Null(context.Handler);

RouteCollectionTest.cs (3)

231Assert.Null(context.Handler); 268Assert.Null(stringVirtualPath); 471Assert.Null(path);

RouteEndpointBuilderTest.cs (1)

17Assert.Null(builder.RequestDelegate);

RouteTest.cs (11)

375Assert.Null(context.Handler); 462Assert.Null(context.Handler); 476Assert.Null(context.Handler); 511Assert.Null(context.RouteData.Values["1controller"]); 578Assert.Null(context.Handler); 626Assert.Null(path); 883Assert.Null(virtualPath); 924Assert.Null(virtualPath); 1137Assert.Null(path); 1186Assert.Null(path); 1744Assert.Null(context.Handler);

RoutingMetricsTests.cs (4)

45Assert.Null(meter.Version); 79Assert.Null(meter.Version); 106Assert.Null(meter.Version); 130Assert.Null(meter.Version);

Template\TemplateBinderTests.cs (5)

135Assert.Null(boundTemplate); 284Assert.Null(boundTemplate); 722Assert.Null(boundTemplate); 1161Assert.Null(boundTemplate); 1175Assert.Null(actualParts.Parameters);

Template\TemplateMatcherTests.cs (4)

399Assert.Null(values["p2"]); 423Assert.Null(values["d"]); 726Assert.Null(values["p2"]); 744Assert.Null(values["p2"]);

Tree\TreeRouterTest.cs (14)

284Assert.Null(context.Handler); 307Assert.Null(context.Handler); 356Assert.Null(context.Handler); 418Assert.Null(context.Handler); 472Assert.Null(context.Handler); 514Assert.Null(context.Handler); 562Assert.Null(context.RouteData.Values["path"]); 698Assert.Null(context.Handler); 786Assert.Null(context.Handler); 982Assert.Null(result); 1168Assert.Null(result); 1198Assert.Null(result); 1287Assert.Null(path); 1431Assert.Null(path);

DelegateTests.cs (2)

174Assert.Null(delegateFeature); 179Assert.Null(delegationProperty);

Http2Tests.cs (4)

120Assert.Null(httpContext.Request.ContentLength); 234Assert.Null(httpContext.Request.ContentLength); 618Assert.Null(feature); 640Assert.Null(feature);

HttpsTests.cs (7)

83Assert.Null(tls.ClientCertificate); 85Assert.Null(cert); 86Assert.Null(tls.ClientCertificate); 108Assert.Null(tls.ClientCertificate); 117Assert.Null(cert); 118Assert.Null(tls.ClientCertificate); 137Assert.Null(tlsFeature);

OpaqueUpgradeTests.cs (3)

30Assert.Null(opaqueFeature); 137Assert.Null(feature.MaxRequestBodySize); // GET/Upgrade requests don't actually have an entity body, so they can't set the limit. 145Assert.Null(feature.MaxRequestBodySize);

RequestBodyLimitTests.cs (9)

96Assert.Null(httpContext.Request.ContentLength); 119Assert.Null(httpContext.Request.ContentLength); 140Assert.Null(httpContext.Request.ContentLength); 239Assert.Null(httpContext.Request.ContentLength); 264Assert.Null(httpContext.Request.ContentLength); 288Assert.Null(httpContext.Request.ContentLength); 316Assert.Null(httpContext.Request.ContentLength); 342Assert.Null(httpContext.Request.ContentLength); 392Assert.Null(httpContext.Request.ContentLength);

RequestBodyTests.cs (1)

269Assert.Null(httpContext.Request.ContentLength);

RequestHeaderTests.cs (2)

159Assert.Null(request.ContentLength); 163Assert.Null(requestHeaders.ContentLength);

RequestTests.cs (13)

ResponseBodyTests.cs (2)

228Assert.Null(response.Headers.TransferEncodingChunked); 308Assert.Null(response.Headers.TransferEncodingChunked);

ResponseCachingTests.cs (1)

358Assert.Null(httpContext.Response.ContentLength);

ResponseHeaderTests.cs (3)

58Assert.Null(response.Headers["Transfer-Encoding"]); 83Assert.Null(response.Headers["Transfer-Encoding"]); 108Assert.Null(response.Headers["Transfer-Encoding"]);

ResponseSendFileTests.cs (3)

229Assert.Null(response.Headers.TransferEncodingChunked); 250Assert.Null(response.Headers.TransferEncodingChunked); 271Assert.Null(response.Headers.TransferEncodingChunked);

ServerTests.cs (2)

359Assert.Null(options.MaxConnections); 399Assert.Null(options.MaxConnections);

IISMiddlewareTests.cs (7)

41Assert.Null(auth); 79Assert.Null(auth); 309Assert.Null(webHostBuilder.GetSetting(WebHostDefaults.ServerUrlsKey)); 310Assert.Null(webHostBuilder.GetSetting(WebHostDefaults.PreferHostingUrlsKey)); 411Assert.Null(windows.DisplayName); 456Assert.Null(windowsAuth.DisplayName); 461Assert.Null(windowsAuth);

ConcurrentPipeWriterTests.cs (1)

167Assert.Null(mockPipeWriter.CompleteException);

Http2\Http2HttpProtocolFeatureCollectionTests.cs (1)

35Assert.Null(_http2Collection.Get<IHttpMinResponseDataRateFeature>());

Http3\Http3HttpProtocolFeatureCollectionTests.cs (1)

35Assert.Null(_http3Collection.Get<IHttpMinResponseDataRateFeature>());

HttpHeadersTests.cs (4)

257Assert.Null(httpHeaders.ContentLength); 274Assert.Null(httpHeaders.ContentLength); 292Assert.Null(httpHeaders.ContentLength); 299Assert.Null(httpHeaders.ContentLength);

HttpRequestHeadersTests.cs (2)

378Assert.Null(entries[0].Key); 390Assert.Null(entries[4].Key);

HttpResponseHeadersTests.cs (2)

380Assert.Null(headers.ContentLength); 392Assert.Null(headers.ContentLength);

KestrelServerLimitsTests.cs (2)

211Assert.Null(new KestrelServerLimits().MaxConcurrentConnections); 212Assert.Null(new KestrelServerLimits().MaxConcurrentUpgradedConnections);

StartLineTests.cs (24)

ConfigurationReaderTests.cs (2)

364Assert.Null(endpoint.SslProtocols); 400Assert.Null(endpoint.ClientCertificateMode);

KestrelConfigurationLoaderTests.cs (9)

QuicConnectionContextTests.cs (1)

97Assert.Null(serverStream);

QuicConnectionListenerTests.cs (2)

204Assert.Null(await acceptTask.AsTask().DefaultTimeout()); 222Assert.Null(await acceptTask.AsTask().DefaultTimeout());

SessionTests.cs (6)

39Assert.Null(context.Session.GetString("NotFound")); 74Assert.Null(context.Session.GetString("Key")); 129Assert.Null(context.Session.GetString("Key")); 523Assert.Null(httpContext.Features.Get<ISessionFeature>()); 574Assert.Null(httpContext.Features.Get<ISessionFeature>()); 655Assert.Null(value);

AdaptiveCapacityDictionaryTests.cs (17)

26Assert.Null(dict._dictionaryStorage); 39Assert.Null(dict._dictionaryStorage); 48Assert.Null(dict._arrayStorage); 56Assert.Null(dict._arrayStorage); 110Assert.Null(value); 123Assert.Null(value); 137Assert.Null(value); 485Assert.Null(dict._dictionaryStorage); 839Assert.Null(removedValue); 853Assert.Null(removedValue); 870Assert.Null(removedValue); 1095Assert.Null(value); 1109Assert.Null(value); 1126Assert.Null(value); 1192Assert.Null(dict._arrayStorage); 1222Assert.Null(dict._arrayStorage); 1252Assert.Null(dict._arrayStorage);

CommandLineApplicationTests.cs (2)

845Assert.Null(nested.Value()); 850Assert.Null(top.Value());

DotNetMuxerTests.cs (1)

38Assert.Null(muxerPath);

NonCapturingTimerTest.cs (1)

34Assert.Null(messageFromTimer);

ObjectMethodExecutorTest.cs (2)

40Assert.Null(result); 244Assert.Null(result);

PropertyHelperTest.cs (2)

561Assert.Null(value); 578Assert.Null(value);

SecurityHelperTests.cs (1)

72Assert.Null(user.Identity.Name);

StackTraceHelperTest.cs (1)

244Assert.Null(frame.FilePath);

HubConnectionTests.cs (8)

224Assert.Null(result); 281Assert.Null(connection.ConnectionId); 287Assert.Null(connection.ConnectionId); 1652Assert.Null(userAgent); 2291Assert.Null(connection.ConnectionId); 2297Assert.Null(newConnectionId); 2298Assert.Null(connection.ConnectionId); 2779Assert.Null(await closedTcs.Task.DefaultTimeout());

HubConnectionTests.cs (4)

79Assert.Null(await closedEventTcs.Task); 484Assert.Null(invocation["invocationId"]); 909Assert.Null(exception); 941Assert.Null(exception);

HubConnectionTests.Protocol.cs (1)

166Assert.Null(closeException);

HubConnectionTests.Reconnect.cs (5)

177Assert.Null(closeError); 465Assert.Null(closeError); 549Assert.Null(closeError); 827Assert.Null(closeError); 947Assert.Null(closeError);

Internal\Protocol\JsonHubProtocolTestsBase.cs (3)

477Assert.Null(completion.Result); 478Assert.Null(completion.Error); 493Assert.Null(completion.Result);

Internal\Protocol\MessagePackHubProtocolTestBase.cs (1)

409Assert.Null(message);

Internal\Protocol\MessagePackHubProtocolTests.cs (2)

255Assert.Null(completion.Result); 268Assert.Null(completion.Result);

HubLifetimeManagerTestBase.cs (3)

86Assert.Null(client2.TryRead()); 116Assert.Null(client2.TryRead()); 147Assert.Null(client2.TryRead());

ScaleoutHubLifetimeManagerTests.cs (6)

91Assert.Null(client2.TryRead()); 167Assert.Null(client.TryRead()); 259Assert.Null(client.TryRead()); 286Assert.Null(client.TryRead()); 317Assert.Null(client.TryRead()); 343Assert.Null(client.TryRead());

AddSignalRTests.cs (7)

89Assert.Null(serviceProvider.GetRequiredService<IOptions<HubOptions>>().Value.HubFilters); 157Assert.Null(globalOptions.MaximumReceiveMessageSize); 158Assert.Null(globalOptions.StreamBufferCapacity); 159Assert.Null(globalOptions.EnableDetailedErrors); 160Assert.Null(globalOptions.KeepAliveInterval); 161Assert.Null(globalOptions.HandshakeTimeout); 162Assert.Null(globalOptions.SupportedProtocols);

DefaultHubLifetimeManagerTests.cs (2)

76Assert.Null(client1.TryRead()); 172Assert.Null(client1.TryRead());

HubConnectionHandlerTests.Activity.cs (1)

349Assert.Null(activity.Parent);

HubConnectionHandlerTests.ClientResult.cs (1)

120Assert.Null(closeMessage.Error);

HubConnectionHandlerTests.cs (42)

HubFilterTests.cs (12)

129Assert.Null(message.Error); 162Assert.Null(completion.Error); 208Assert.Null(message.Error); 258Assert.Null(message.Error); 309Assert.Null(message.Error); 363Assert.Null(message.Error); 423Assert.Null(message.Error); 485Assert.Null(message.Error); 557Assert.Null(message.Error); 604Assert.Null(message.Error); 702Assert.Null(message.Error); 703Assert.Null(message.Result);

Internal\DefaultHubProtocolResolverTests.cs (1)

69Assert.Null(resolver.GetProtocol("notARealProtocol", HubProtocolHelpers.AllProtocolNames));

MapSignalRTests.cs (2)

330Assert.Null(endpoint.Metadata.GetMetadata<NegotiateMetadata>()); 361Assert.Null(endpoint.Metadata.GetMetadata<NegotiateMetadata>());

StaticFileMiddlewareTests.cs (1)

290Assert.Null(exception);

DirectoryBrowserMiddlewareTests.cs (1)

372Assert.Null(response.Content.Headers.ContentLength);

RangeHeaderTests.cs (15)

RangeHelperTests.cs (4)

21Assert.Null(normalizedRange); 31Assert.Null(normalizedRange); 72Assert.Null(parsedRangeResult); 89Assert.Null(parsedRangeResult);

StaticFileMiddlewareTests.cs (4)

41Assert.Null(response.Headers.ETag); 75Assert.Null(response.Headers.ETag); 115Assert.Null(response.Headers.ETag); 539Assert.Null(response.Content.Headers.LastModified);

ClientHandlerTests.cs (6)

36Assert.Null(features.Get<IHttpResponseFeature>().ReasonPhrase); 61Assert.Null(context.Features.Get<IHttpResponseFeature>().ReasonPhrase); 87Assert.Null(features.Get<IHttpResponseFeature>().ReasonPhrase); 150Assert.Null(context.Request.ContentLength); 166Assert.Null(context.Request.ContentLength); 183Assert.Null(context.Request.ContentLength);

HttpContextBuilderTests.cs (2)

38Assert.Null(context.Request.CanHaveBody()); 44Assert.Null(context.Features.Get<IHttpResponseFeature>().ReasonPhrase);

ResponseResetTests.cs (1)

24Assert.Null(feature);

TestServerTests.cs (3)

541Assert.Null(context.RequestServices); 746Assert.Null(listener.UnhandledException); 771Assert.Null(listener.EndRequest?.HttpContext);

WebApplicationTests.cs (5)

1722Assert.Null(c.GetEndpoint()); 1741Assert.Null(chosenEndpoint); 2172Assert.Null(response.Content.Headers.ContentType); 2493Assert.Null(authFeature); 2494Assert.Null(context.User.Identity.Name);

FileBufferingWriteStreamTests.cs (4)

37Assert.Null(bufferingStream.FileStream); 57Assert.Null(fileStream); 150Assert.Null(bufferingStream.FileStream); 168Assert.Null(fileStream);

FormReaderTests.cs (2)

173Assert.Null(await ReadPair(reader)); 185Assert.Null(await ReadPair(reader));

HttpRequestStreamReaderTest.cs (3)

208Assert.Null(eof); 232Assert.Null(eof); 245Assert.Null(eof);

MultipartReaderTests.cs (8)

121Assert.Null(await reader.ReadNextSectionAsync()); 164Assert.Null(await reader.ReadNextSectionAsync()); 181Assert.Null(await reader.ReadNextSectionAsync()); 207Assert.Null(await reader.ReadNextSectionAsync()); 233Assert.Null(await reader.ReadNextSectionAsync()); 268Assert.Null(await reader.ReadNextSectionAsync()); 344Assert.Null(await reader.ReadNextSectionAsync()); 379Assert.Null(await reader.ReadNextSectionAsync());

EditorConfig_Tests.cs (9)

187Assert.Null(matcher); 337Assert.Null(matcher); 344Assert.Null(matcher); 480Assert.Null(matcherOpt); 498Assert.Null(matcherOpt); 584Assert.Null(matcher); 591Assert.Null(matcher); 598Assert.Null(matcher); 707Assert.Null(actual);

CommandLineSwitches_Tests.cs (8)

267Assert.Null(missingParametersErrorMessage); 273Assert.Null(duplicateSwitchErrorMessage); 275Assert.Null(missingParametersErrorMessage); 763Assert.Null(switches.GetParameterlessSwitchCommandLineArg(CommandLineSwitches.ParameterlessSwitch.Version)); 806Assert.Null(switches.GetParameterizedSwitchCommandLineArg(CommandLineSwitches.ParameterizedSwitch.Target)); 849Assert.Null(switches.GetParameterizedSwitchCommandLineArg(CommandLineSwitches.ParameterizedSwitch.Logger)); 901Assert.Null(parameters.Last()); 1270Assert.Null(MSBuildApp.ProcessWarnAsErrorSwitch(commandLineSwitches));

Construction\ConstructionEditing_Tests.cs (4)

45Assert.Null(project.Parent); 1388Assert.Null(target1.Parent); 1389Assert.Null(target2.Parent); 2362Assert.Null(metadatum);

Construction\ProjectChooseElement_Tests.cs (2)

180Assert.Null(Helpers.GetFirst(choose.Children)); 201Assert.Null(choose.OtherwiseElement);

Construction\ProjectTargetElement_Tests.cs (1)

336Assert.Null(target.Returns);

Construction\SolutionFile_Tests.cs (12)

Definition\DefinitionEditing_Tests.cs (1)

1830Assert.Null(project.GetProperty("p1"));

Definition\ProjectItem_Tests.cs (1)

214Assert.Null(item.GetMetadata("m0"));

Definition\ProjectItemDefinition_Tests.cs (1)

90Assert.Null(itemDefinition.GetMetadata("m"));

Definition\ProtectImports_Tests.cs (1)

636Assert.Null(item.Xml.ContainingProject.FullPath); // "Item was not found in the project." // null because XML is in-memory

Instance\ProjectInstance_Tests.cs (5)

71Assert.Null(items[0].GetMetadata("m")); 435Assert.Null(projAInstanceItem.GetMetadata(CapturedMetadataName)); 439Assert.Null(projAInstanceItem.GetMetadata("Identity")); 477Assert.Null(projAInstanceItem.GetMetadata(CapturedMetadataName)); 481Assert.Null(projAInstanceItem.GetMetadata("Identity"));

Instance\ProjectItemInstance_Tests.cs (1)

156Assert.Null(item.GetMetadata("X"));

ObjectModelRemoting\Helpers\TestCollectionGroup.cs (1)

204Assert.Null(this.ImmutableProjects);

ObjectModelRemoting\Helpers\ViewValidation.construction.cs (3)

463Assert.Null(viewChild); 658Assert.Null(viewParams); 676Assert.Null(viewParamsLoc);

ObjectModelRemoting\LinkedConstructionModify_Tests.cs (4)

389Assert.Null(choose.View.OtherwiseElement); 402Assert.Null(choose.View.OtherwiseElement); 499Assert.Null(usingTaskFile.View.TaskBody); 504Assert.Null(usingTaskFile.View.ParameterGroup);

ObjectModelRemoting\LinkedEvaluationModify_Tests.cs (15)

BackEnd\BatchingEngine_Tests.cs (1)

421Assert.Null(log.Warnings[1].Code);

BackEnd\BuildEventArgTransportSink_Tests.cs (2)

28Assert.Null(sink.Name); 143Assert.Null(weakTransportDelegateReference.Target); // " Expected delegate to be dead"

BackEnd\BuildManager_Tests.cs (8)

788Assert.Null(projectStartedEvent.Properties); 825Assert.Null(properties); 922Assert.Null(properties); 1894Assert.Null(instance.GetProperty("Foo")); 2046Assert.Null(ProjectRootElement.TryOpen(rootProjectPath, projectCollection)); // "The built project shouldn't be in the cache anymore." 2047Assert.Null(ProjectRootElement.TryOpen(importedProjectPath, projectCollection)); // "The built project's import shouldn't be in the cache anymore." 2073Assert.Null(ProjectRootElement.TryOpen(rootProjectPath, projectCollection)); // "The unloaded project shouldn't be in the cache anymore." 2074Assert.Null(ProjectRootElement.TryOpen(importedProjectPath, projectCollection)); // "The unloaded project's import shouldn't be in the cache anymore."

BackEnd\BuildRequestConfiguration_Tests.cs (4)

184Assert.Null(config1.Project); 393Assert.Null(instance.GlobalPropertiesDictionary); 394Assert.Null(instance.ItemsToBuildWith); 395Assert.Null(instance.PropertiesToBuildWith);

BackEnd\BuildRequestEngine_Tests.cs (1)

83Assert.Null(_builderThread); // "Received BuildRequest while one was in progress"

BackEnd\BuildRequestEntry_Tests.cs (7)

49Assert.Null(entry.Result); 54Assert.Null(entry.Result); 55Assert.Null(results); 62Assert.Null(entry.Result); 70Assert.Null(entry.Result); 75Assert.Null(entry.Result); 160Assert.Null(entry.GetRequestsToIssueIfReady()); // "Entry should not be ready to issue because there are unresolved configurations"

BackEnd\BuildResult_Tests.cs (1)

84Assert.Null(result.Exception);

BackEnd\CacheSerialization_Tests.cs (2)

99Assert.Null(CacheSerialization.SerializeCaches( 131Assert.Null(CacheSerialization.SerializeCaches(

BackEnd\CentralForwardingLogger_Tests.cs (2)

42Assert.Null(centralLogger.BuildEventRedirector); // "Expected BuildEventRedirector to be null" 86Assert.Null(centralLogger.BuildEventRedirector);

BackEnd\EventSourceSink_Tests.cs (5)

28Assert.Null(sink.Name); 159Assert.Null(handlerHelper.RaisedEvent); 160Assert.Null(handlerHelper.RaisedAnyEvent); 161Assert.Null(handlerHelper.RaisedStatusEvent); 320Assert.Null(testHandlers.RaisedStatusEvent);

BackEnd\LoggingServicesLogMethod_Tests.cs (9)

85Assert.Null(loggingService.ProcessedBuildEvent); // "Expected ProcessedBuildEvent to be null" 194Assert.Null(service.ProcessedBuildEvent); 717Assert.Null(service.ProcessedBuildEvent); 776Assert.Null(service.ProcessedBuildEvent); 1460Assert.Null(service.ProcessedBuildEvent); 1480Assert.Null(service.ProcessedBuildEvent); 1503Assert.Null(service.ProcessedBuildEvent); 1532Assert.Null(service.ProcessedBuildEvent); 1559Assert.Null(service.ProcessedBuildEvent);

BackEnd\Lookup_Tests.cs (2)

1231Assert.Null(lookup.GetProperty("p1")); 1235Assert.Null(lookup.GetProperty("p1"));

BackEnd\ResultsCache_Tests.cs (2)

99Assert.Null(retrievedResult); 355Assert.Null(cache.GetResultForRequest(request));

BackEnd\Scheduler_Tests.cs (5)

139Assert.Null(response[1].Unblocker.Result); 163Assert.Null(response[1].Unblocker.Result); 193Assert.Null(response[1].Unblocker.Result); 263Assert.Null(response[2].Unblocker.Result); 613Assert.Null(((ResultsCacheWithOverride)_host.GetComponent(BuildComponentType.ResultsCache)).CurrentCache.GetResultsForConfiguration(1));

BackEnd\TargetEntry_Tests.cs (5)

718Assert.Null(targetOutputsA); 723Assert.Null(targetOutputsC); 815Assert.Null(targetOutputsA); 816Assert.Null(targetOutputsB); 817Assert.Null(targetOutputsC);

BackEnd\TargetResult_Tests.cs (2)

30Assert.Null(result.Exception); 81Assert.Null(result.Exception);

BackEnd\TaskExecutionHost_Tests.cs (1)

970Assert.Null((_host as TaskExecutionHost)._UNITTESTONLY_TaskFactoryWrapper);

BackEnd\TaskHost_Tests.cs (3)

207Assert.Null(_customLogger.LastWarning); // "Expected no Warning Event at this point" 457Assert.Null(_customLogger.LastError); // "Expected no error Event" 514Assert.Null(_customLogger.LastCustom as MyCustomBuildEventArgsNotSerializable); // "Expected no custom Event"

BackEnd\TaskHostConfiguration_Tests.cs (1)

375Assert.Null(deserializedConfig.TaskParameters);

BackEnd\TaskRegistry_Tests.cs (5)

1231Assert.Null(registeredTaskRecords[0].ParameterGroupAndTaskBody.InlineTaskXmlBody); 1284Assert.Null(inlineTaskRecord.InlineTaskXmlBody); 1321Assert.Null(inlineTaskRecord.InlineTaskXmlBody); 1694Assert.Null(inlineTaskRecord.InlineTaskXmlBody); 2029Assert.Null(record); // "Should not have been a match."

Collections\OMcollections_tests.cs (3)

52Assert.Null(properties["p1"]); 172Assert.Null(enumerator.Current); 176Assert.Null(enumerator.Current);

Construction\SolutionProjectGenerator_Tests.cs (2)

1498Assert.Null(buildTarget.Tasks.Where( 1803Assert.Null(SolutionProjectGenerator.PredictActiveSolutionConfigurationName(solution, globalProperties));

CopyOnWriteDictionary_Tests.cs (1)

84Assert.Null(v);

Definition\Toolset_Tests.cs (3)

209Assert.Null(t.DefaultSubToolsetVersion); 245Assert.Null(subToolsetVersion); 478Assert.Null(t.GetProperty("d", "v11.0")); // property in a different sub-toolset

Definition\ToolsetConfigurationReader_Tests.cs (4)

49Assert.Null(msbuildToolsetSection.MSBuildOverrideTasksPath); 51Assert.Null(msbuildToolsetSection.Default); 78Assert.Null(msbuildToolsetSection.MSBuildOverrideTasksPath); 140Assert.Null(msbuildToolsetSection.MSBuildOverrideTasksPath);

Evaluation\Evaluator_Tests.cs (16)

Evaluation\Expander_Tests.cs (2)

1599Assert.Null(string.IsInterned(xmlattribute.Value)); 1600Assert.Null(string.IsInterned(expandedString));

Evaluation\ExpressionShredder_Tests.cs (58)

Evaluation\ProjectRootElementCache_Tests.cs (1)

99Assert.Null(ProjectCollection.GlobalProjectCollection.ProjectRootElementCache.TryGet(projectPath));

Evaluation\ProjectStringCache_Tests.cs (1)

233Assert.Null(itemGroupContent);

Evaluation\UsedUninitializedProperties_Tests.cs (2)

21Assert.Null(elementLocation); 40Assert.Null(elementLocation);

FileUtilities_Tests.cs (5)

211Assert.Null(info); 452Assert.Null(FileUtilities.NormalizePath(null, null)); 461Assert.Null(FileUtilities.NormalizePath(String.Empty)); 470Assert.Null(FileUtilities.NormalizePath(@"\\")); 479Assert.Null(FileUtilities.NormalizePath(@"\\XXX\"));

Instance\HostServices_Tests.cs (1)

105Assert.Null(hostServices.GetHostObject("project", "target", "task"));

ResourceUtilities_Tests.cs (8)

36Assert.Null(code); 41Assert.Null(code); 46Assert.Null(code); 51Assert.Null(code); 56Assert.Null(code); 61Assert.Null(code); 66Assert.Null(code); 71Assert.Null(code);

Scanner_Tests.cs (8)

147Assert.Null(lexer.UnexpectedlyFound); 152Assert.Null(lexer.UnexpectedlyFound); 157Assert.Null(lexer.UnexpectedlyFound); 162Assert.Null(lexer.UnexpectedlyFound); 167Assert.Null(lexer.UnexpectedlyFound); 172Assert.Null(lexer.UnexpectedlyFound); 185Assert.Null(lexer.UnexpectedlyFound); 190Assert.Null(lexer.UnexpectedlyFound);

TaskParameter_Tests.cs (2)

33Assert.Null(t.WrappedParameter); 39Assert.Null(t2.WrappedParameter);

Copy_Tests.cs (1)

2151Assert.Null(t.CopiedFiles);

Culture_Tests.cs (2)

35Assert.Null(info.culture); 51Assert.Null(info.culture);

FindAppConfigFile_Tests.cs (1)

64Assert.Null(f.AppConfigFile);

FindInList_Tests.cs (3)

49Assert.Null(f.ItemFound); 97Assert.Null(f.ItemFound); 108Assert.Null(f.ItemFound);

Hash_Tests.cs (2)

46Assert.Null(nullItemsHash); 49Assert.Null(zeroLengthItemsHash);

Move_Tests.cs (1)

767Assert.Null(t.MovedFiles);

PropertyParser_Tests.cs (1)

20Assert.Null(propertiesTable);

ResolveCodeAnalysisRuleSet_Tests.cs (8)

67Assert.Null(resolvedRuleSet); 110Assert.Null(resolvedRuleSet); 161Assert.Null(resolvedRuleSet); 211Assert.Null(resolvedRuleSet); 235Assert.Null(resolvedRuleSet); 288Assert.Null(resolvedRuleSet); 307Assert.Null(resolvedRuleSet); 326Assert.Null(resolvedRuleSet);

ResolveNonMSBuildProjectOutput_Tests.cs (2)

71Assert.Null(missingAttr); 123Assert.Null(resolvedPath);

ResolveSDKReference_Tests.cs (1)

566Assert.Null(t.ParseSDKReference(referenceInclude));

ResourceUtilities_Tests.cs (8)

36Assert.Null(code); 41Assert.Null(code); 46Assert.Null(code); 51Assert.Null(code); 56Assert.Null(code); 61Assert.Null(code); 66Assert.Null(code); 71Assert.Null(code);

WriteCodeFragment_Tests.cs (2)

215Assert.Null(task.OutputFile); 242Assert.Null(task.OutputFile);

ObjectModelHelpers.cs (1)

487Assert.Null(actual); // "Expected a null array"

ResourceUtilities_Tests.cs (8)

36Assert.Null(code); 41Assert.Null(code); 46Assert.Null(code); 51Assert.Null(code); 56Assert.Null(code); 61Assert.Null(code); 66Assert.Null(code); 71Assert.Null(code);

AsyncCollectionAssertsTests.cs (2)

151 Assert.Null(collEx.InnerException); 222 Assert.Null(collEx.InnerException);

CollectionAssertsTests.cs (2)

149 Assert.Null(collEx.InnerException); 222 Assert.Null(collEx.InnerException);

EventAssertsTests.cs (6)

62 Assert.Null(evt.Sender); 212 Assert.Null(evt.Sender); 229 Assert.Null(evt.Sender); 386 Assert.Null(evt.Sender); 403 Assert.Null(evt.Sender); 577 Assert.Null(evt.Sender);

ExceptionAssertsTests.cs (11)

35 Assert.Null(ex.InnerException); 118 Assert.Null(ex.InnerException); 191 Assert.Null(ex.InnerException); 271 Assert.Null(ex.InnerException); 343 Assert.Null(ex.InnerException); 429 Assert.Null(ex.InnerException); 518 Assert.Null(ex.InnerException); 588 Assert.Null(ex.InnerException); 648 Assert.Null(ex.InnerException); 707 Assert.Null(ex.InnerException); 776 Assert.Null(ex.InnerException);

NullAssertsTests.cs (2)

52 Assert.Null(null); 66 var ex = Record.Exception(() => Assert.Null(new object()));

BufferReleaseTests.cs (3)

58Assert.Null(third); 143Assert.Null(third); 201Assert.Null(third);

DistributedCacheTests.cs (6)

65Assert.Null(cache.Get(key)); 85Assert.Null(actual); 111Assert.Null(cache.Get(key)); 131Assert.Null(actual); 177Assert.Null(cache.Get(key)); 237Assert.Null(await cache.GetAsync(key));

ServiceConstructionTests.cs (4)

47Assert.Null(defaults.LocalCacheExpiration); // wasn't specified 60Assert.Null(options.DefaultEntryOptions); 76Assert.Null(defaults.Expiration); // wasn't specified 161Assert.Null(cache.BackendCache);

SqlServerCacheWithDatabaseTest.cs (13)

67Assert.Null(value); 116Assert.Null(cacheItemInfo); 156Assert.Null(cacheItemInfo); 197Assert.Null(cacheItemInfo); 218Assert.Null(cacheItem); 245Assert.Null(value); 305Assert.Null(value); 328Assert.Null(value); 352Assert.Null(value); 506Assert.Null(cacheItemInfo.AbsoluteExpiration); 623Assert.Null(cacheItemInfo.AbsoluteExpiration); 643Assert.Null(value); 684Assert.Null(cacheItemInfo);

RedisCacheSetAndRemoveTests.cs (7)

26Assert.Null(result); 56Assert.Null(result); 89Assert.Null(result); 108Assert.Null(cache.Get(key)); // expect null 122Assert.Null(await cache.GetAsync(key)); // expect null 139Assert.Null(cache.Get(key)); // expect null 162Assert.Null(await cache.GetAsync(key)); // expect null

TimeExpirationAsyncTests.cs (8)

73Assert.Null(result); 86Assert.Null(result); 138Assert.Null(result); 151Assert.Null(result); 198Assert.Null(result); 211Assert.Null(result); 236Assert.Null(result); 269Assert.Null(result);

TimeExpirationTests.cs (8)

56Assert.Null(result); 69Assert.Null(result); 122Assert.Null(result); 135Assert.Null(result); 183Assert.Null(result); 196Assert.Null(result); 221Assert.Null(result); 254Assert.Null(result);

ConfigurationProviderTestBase.cs (12)

214Assert.Null(section1.Value); 222Assert.Null(section2.Value); 230Assert.Null(section2.Value); 237Assert.Null(section3a.Value); 241Assert.Null(section3.Value); 246Assert.Null(section4.Value); 251Assert.Null(section4.Value); 263Assert.Null(sections[1].Value); 267Assert.Null(sections[2].Value); 279Assert.Null(sections[1].Value); 291Assert.Null(sections[1].Value); 315Assert.Null(sections[0].Value);

KeyPerFileTests.cs (6)

120Assert.Null(config["ignore.Secret0"]); 121Assert.Null(config["ignore.Secret1"]); 181Assert.Null(config["meSecret0"]); 182Assert.Null(config["meSecret1"]); 264Assert.Null(config["NewSecret2"]); 342Assert.Null(config["NewSecret2"]);

DefaultHealthCheckServiceTest.cs (5)

90Assert.Null(actual.Value.Exception); 99Assert.Null(actual.Value.Exception); 192Assert.Null(actual.Value.Exception); 310Assert.Null(actual.Value.Description); 312Assert.Null(actual.Value.Exception);

DependencyInjection\ServiceCollectionExtensionsTest.cs (10)

32Assert.Null(actual.ImplementationInstance); 33Assert.Null(actual.ImplementationFactory); 40Assert.Null(actual.ImplementationInstance); 41Assert.Null(actual.ImplementationFactory); 62Assert.Null(actual.ImplementationInstance); 63Assert.Null(actual.ImplementationFactory); 70Assert.Null(actual.ImplementationInstance); 71Assert.Null(actual.ImplementationFactory); 78Assert.Null(actual.ImplementationInstance); 79Assert.Null(actual.ImplementationFactory);

FeatureCollectionTests.cs (3)

46Assert.Null(thing2); 64Assert.Null(interfaces.Get<Thing>()); 84Assert.Null(interfaces.Get<int?>());

EmbeddedFileProviderTests.cs (4)

54Assert.Null(fileInfo.PhysicalPath); 120Assert.Null(fileInfo.PhysicalPath); 158Assert.Null(fileInfo.PhysicalPath); 196Assert.Null(fileInfo.PhysicalPath);

Manifest\EmbeddedFilesManifestTests.cs (1)

30Assert.Null(entry);

ManifestEmbeddedFileProviderTests.cs (9)

32Assert.Null(jqueryValidate.PhysicalPath); 39Assert.Null(jqueryMin.PhysicalPath); 46Assert.Null(siteCss.PhysicalPath); 69Assert.Null(jqueryValidate.PhysicalPath); 76Assert.Null(jqueryMin.PhysicalPath); 83Assert.Null(siteCss.PhysicalPath); 168Assert.Null(jqueryValidate.PhysicalPath); 191Assert.Null(jqueryValidate.PhysicalPath); 442Assert.Null(jqueryValidate.PhysicalPath);

HttpRequestMessageExtensionsTest.cs (3)

41Assert.Null(actual); 59Assert.Null(actual); 105Assert.Null(actual);

PolicyHttpMessageHandlerTest.cs (3)

295Assert.Null(request.GetPolicyExecutionContext()); // We clean up the context if it was generated by the handler rather than caller supplied. 348Assert.Null(request.GetPolicyExecutionContext()); // We do clean up a context we generated, when the policy selector throws. 375Assert.Null(request.GetPolicyExecutionContext()); // We do clean up a context we generated, when the execution throws.

InitCommandTest.cs (1)

97Assert.Null(projectDocument.Declaration);

DnsSrvServiceEndpointResolverTests.cs (2)

126Assert.Null(hostNameFeature); 231Assert.Null(hostNameFeature);

ConfigurationServiceEndpointResolverTests.cs (3)

49Assert.Null(hostNameFeature); 377Assert.Null(hostNameFeature); 426Assert.Null(hostNameFeature);

Infrastructure\DotNetDispatcherTest.cs (6)

81Assert.Null(resultJson); 187Assert.Null(resultJson); 204Assert.Null(resultJson); 434Assert.Null(task.Result); 796Assert.Null(value.StringVal); 812v => Assert.Null(v));

JSInProcessRuntimeTest.cs (1)

50Assert.Null(syncResult);

CacheControlHeaderValueTest.cs (1)

587Assert.Null(result);

ContentDispositionHeaderValueTest.cs (25)

ContentRangeHeaderValueTest.cs (10)

22Assert.Null(range.From); 23Assert.Null(range.To); 45Assert.Null(range.Length); 160Assert.Null(result.From); 161Assert.Null(result.To); 162Assert.Null(result.Length); 191Assert.Null(result.From); 192Assert.Null(result.To); 193Assert.Null(result.Length); 204Assert.Null(result);

CookieHeaderValueTest.cs (1)

317Assert.Null(results);

EntityTagHeaderValueTest.cs (1)

513Assert.Null(result);

MediaTypeHeaderValueTest.cs (6)

107Assert.Null(mediaType.Charset.Value); 240Assert.Null(mediaType.Charset.Value); 262Assert.Null(mediaType.Charset.Value); 276Assert.Null(mediaType.Quality); 298Assert.Null(mediaType.Quality); 940Assert.Null(result);

NameValueHeaderValueTest.cs (7)

64Assert.Null(pair0.Value.Value); 65Assert.Null(pair1.Value.Value); 70Assert.Null(pair1.Value.Value); 80Assert.Null(pair0.Value.Value); 81Assert.Null(pair1.Value.Value); 88Assert.Null(pair1.Value.Value); 670Assert.Null(result);

RangeConditionHeaderValueTest.cs (4)

13Assert.Null(rangeCondition.LastModified); 24Assert.Null(rangeCondition.LastModified); 34Assert.Null(rangeCondition.EntityTag); 150Assert.Null(result);

RangeHeaderValueTest.cs (1)

172Assert.Null(result);

SetCookieHeaderValueTest.cs (1)

486Assert.Null(results);

StringWithQualityHeaderValueTest.cs (2)

13Assert.Null(value.Quality); 482Assert.Null(result);

ActualApiResponseMetadataFactoryTest.cs (2)

87Assert.Null(metadata); 270Assert.Null(metadata.Value.ReturnType);

ResponseTests.cs (10)

139Assert.Null(response.Headers.TransferEncodingChunked); 140Assert.Null(response.Headers.ConnectionClose); 161Assert.Null(GetContentLength(response)); 185Assert.Null(response.Headers.TransferEncodingChunked); 186Assert.Null(GetContentLength(response)); 210Assert.Null(response.Headers.ConnectionClose); 211Assert.Null(GetContentLength(response)); 235Assert.Null(response.Headers.ConnectionClose); 236Assert.Null(GetContentLength(response)); 256Assert.Null(GetContentLength(response));

ServiceModel\FaultExceptionTest.cs (12)

35Assert.Null(exception2.Detail); 75Assert.Null(faultException.Action); 79Assert.Null(faultException.Code.SubCode); 123Assert.Null(exception.Detail); 124Assert.Null(exception.Action); 144Assert.Null(exception.Detail); 145Assert.Null(exception.Action); 148Assert.Null(exception.Action); 173Assert.Null(exception.Detail); 174Assert.Null(exception.Action); 205Assert.Null(exception.Detail); 206Assert.Null(exception.Action);

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

17Assert.Null(extension.Type);

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

16Assert.Null(attribute.Name);

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

17Assert.Null(attribute.ReturnType); 18Assert.Null(attribute.ExpressionType); 28Assert.Null(attribute.ExpressionType);

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

19Assert.Null(attribute.Type);

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

15Assert.Null(extension.ProvideValue(null));

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

16Assert.Null(definition.Name); 17Assert.Null(definition.Type); 18Assert.Null(definition.Modifier);

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

18Assert.Null(reference.Name);

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

19Assert.Null(extension.Member); 20Assert.Null(extension.MemberType); 30Assert.Null(extension.MemberType);

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

20Assert.Null(extension.Type); 21Assert.Null(extension.TypeName); 30Assert.Null(extension.Type); 46Assert.Null(extension.TypeName); 135Assert.Null(extension.Type); 152Assert.Null(extension.TypeName);

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

150Assert.Null(ValueSerializer.GetSerializerFor(typeof(ValueSerializer))); 151Assert.Null(ValueSerializer.GetSerializerFor(typeof(ValueSerializer), null)); 200Assert.Null(ValueSerializer.GetSerializerFor(type)); 201Assert.Null(ValueSerializer.GetSerializerFor(type, null)); 287Assert.Null(ValueSerializer.GetSerializerFor(descriptor)); 288Assert.Null(ValueSerializer.GetSerializerFor(descriptor, null));

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

42Assert.Null(attribute.LoaderType); 44Assert.Null(attribute.ContentType);

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

17Assert.Null(data.Text); 56Assert.Null(data.Text); 68Assert.Null(data.Text);

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

19Assert.Null(attribute.AssemblyName);