Empty

Options\SymbolNamesWithValueOptionTests.cs (19)

Http2TrailersResetTests.cs (2)

53Assert.Empty(response.TrailingHeaders); 64Assert.Empty(response.TrailingHeaders);

src\Servers\IIS\IIS\test\Common.FunctionalTests\Http2Tests.cs (1)

324Assert.Empty(response.TrailingHeaders);

src\Servers\IIS\IIS\test\IIS.Shared.FunctionalTests\ApplicationInitializationTests.cs (1)

73Assert.Empty(matchedEntries);

src\Servers\IIS\IIS\test\Common.FunctionalTests\Http2Tests.cs (1)

324Assert.Empty(response.TrailingHeaders);

BadHttpRequestTests.cs (1)

271Assert.Empty(await client.Stream.ReadUntilEndAsync().DefaultTimeout());

CertificateLoaderTests.cs (1)

22Assert.Empty(cert.Extensions.OfType<X509EnhancedKeyUsageExtension>());

Http2\Http2StreamTests.cs (9)

2678Assert.Empty(_decodedHeaders); 2717Assert.Empty(_decodedHeaders); 2754Assert.Empty(_decodedHeaders); 2771Assert.Empty(_decodedHeaders); 2825Assert.Empty(_decodedHeaders); 2871Assert.Empty(_decodedHeaders); 2896Assert.Empty(_decodedHeaders); 2929Assert.Empty(_decodedHeaders); 2954Assert.Empty(_decodedHeaders);

HttpsConnectionMiddlewareTests.cs (1)

1312Assert.Empty(cert.Extensions.OfType<X509EnhancedKeyUsageExtension>());

KestrelMetricsTests.cs (6)

78Assert.Empty(connectionDuration.GetMeasurementSnapshot()); 153Assert.Empty(connectionDuration.GetMeasurementSnapshot()); 154Assert.Empty(activeConnections.GetMeasurementSnapshot()); 155Assert.Empty(queuedConnections.GetMeasurementSnapshot()); 366Assert.Empty(connectionDuration.GetMeasurementSnapshot()); 471Assert.Empty(connectionDuration.GetMeasurementSnapshot());

RequestTests.cs (1)

1131Assert.Empty(ms2.ToArray());

CoalesceAnalyzerTests.cs (1)

42Assert.Empty(d);

UsingToStringInLoggersTests.cs (2)

63Assert.Empty(generated.diagnostics); 118Assert.Empty(d);

ApiLifecycle\AnalysisModelTest.cs (9)

50Assert.Empty(analysis.MissingProperties); 51Assert.Empty(analysis.MissingBaseTypes); 52Assert.Empty(analysis.FoundInBaseline); 53Assert.Empty(analysis.NotFoundInBaseline); 54Assert.Empty(analysis.MissingTypes); 55Assert.Empty(analysis.MissingConstraints); 56Assert.Empty(analysis.MissingFields); 57Assert.Empty(analysis.MissingMethods); 58Assert.Empty(analysis.MissingProperties);

CallAnalysis\UseThrowsTests.cs (1)

47Assert.Empty(d);

InternalReferencedInPublicDocAnalyzerTests.cs (1)

481Assert.Empty(detected);

Components\DisallowNonLiteralSequenceNumbersTest.cs (1)

27Assert.Empty(diagnostics);

Http\HeaderDictionaryIndexerAnalyzerTests.cs (1)

197Assert.Empty(propertyMapping);

RouteEmbeddedLanguage\FrameworkParametersCompletionProviderTests.cs (14)

RouteEmbeddedLanguage\RoutePatternAnalyzerTests.cs (10)

260Assert.Empty(diagnostics); 370Assert.Empty(diagnostics); 410Assert.Empty(diagnostics); 447Assert.Empty(diagnostics); 524Assert.Empty(diagnostics); 553Assert.Empty(diagnostics1); 563Assert.Empty(diagnostics2); 592Assert.Empty(diagnostics); 618Assert.Empty(diagnostics); 645Assert.Empty(diagnostics);

RouteEmbeddedLanguage\RoutePatternCompletionProviderTests.cs (5)

234Assert.Empty(result.Completions.ItemsList); 469Assert.Empty(result.Completions.ItemsList); 491Assert.Empty(result.Completions.ItemsList); 547Assert.Empty(result.Completions.ItemsList); 574Assert.Empty(result.Completions.ItemsList);

RouteEmbeddedLanguage\RoutePatternParserTests_ConformanceTests.cs (1)

785Assert.Empty(tree.Diagnostics);

RouteHandlers\DetectMisplacedLambdaAttributeTest.cs (4)

28Assert.Empty(diagnostics); 153Assert.Empty(diagnostics); 189Assert.Empty(diagnostics); 239Assert.Empty(diagnostics);

RouteHandlers\DisallowMvcBindArgumentsOnParametersTest.cs (2)

26Assert.Empty(diagnostics); 43Assert.Empty(diagnostics);

RouteHandlers\DisallowNonParsableComplexTypesOnParametersTest.cs (9)

41Assert.Empty(diagnostics); 58Assert.Empty(diagnostics); 75Assert.Empty(diagnostics); 93Assert.Empty(diagnostics); 111Assert.Empty(diagnostics); 129Assert.Empty(diagnostics); 146Assert.Empty(diagnostics); 163Assert.Empty(diagnostics); 180Assert.Empty(diagnostics);

RouteHandlers\DisallowReturningActionResultsFromMapMethodsTest.cs (4)

29Assert.Empty(diagnostics); 54Assert.Empty(diagnostics); 82Assert.Empty(diagnostics); 109Assert.Empty(diagnostics);

WebApplicationBuilder\DisallowConfigureHostBuilderConfigureWebHostTest.cs (3)

27Assert.Empty(diagnostics); 109Assert.Empty(diagnostics); 238Assert.Empty(diagnostics);

WebApplicationBuilder\DisallowConfigureWebHostBuilderConfigureTest.cs (3)

28Assert.Empty(diagnostics); 142Assert.Empty(diagnostics); 160Assert.Empty(diagnostics);

WebApplicationBuilder\DisallowConfigureWebHostBuilderUseStartupTest.cs (3)

27Assert.Empty(diagnostics); 186Assert.Empty(diagnostics); 207Assert.Empty(diagnostics);

WebApplicationBuilder\UseTopLevelRouteRegistrationInsteadOfUseEndpointsTest.cs (4)

34Assert.Empty(diagnostics); 58Assert.Empty(diagnostics); 76Assert.Empty(diagnostics); 100Assert.Empty(diagnostics);

SharedFxTests.cs (9)

54Assert.Empty(missing); 55Assert.Empty(unexpected); 81Assert.Empty(missing); 82Assert.Empty(unexpected); 117Assert.Empty(depsFile["compilationOptions"]); 296Assert.Empty(missing); 297Assert.Empty(unexpected); 351Assert.Empty(missing); 352Assert.Empty(unexpected);

TargetingPackTests.cs (8)

56Assert.Empty(missing); 57Assert.Empty(unexpected); 273Assert.Empty(missing); 274Assert.Empty(unexpected); 341Assert.Empty(missing); 342Assert.Empty(unexpected); 394Assert.Empty(missing); 395Assert.Empty(unexpected);

AuthenticationPropertiesTests.cs (9)

42Assert.Empty(props.Items); 43Assert.Empty(props.Parameters); 55Assert.Empty(props.Parameters); 80Assert.Empty(props.Items); 115Assert.Empty(props.Parameters); 133Assert.Empty(props.Parameters); 151Assert.Empty(props.Parameters); 344Assert.Empty(deserialized.Parameters); 358Assert.Empty(deserialized.Parameters);

CookieTests.cs (1)

248Assert.Empty(sessionStore.Store.Keys);

JwtBearerTests.cs (1)

785Assert.Empty(response.Response.Headers.WwwAuthenticate);

JwtBearerTests_Handler.cs (1)

733Assert.Empty(response.Response.Headers.WwwAuthenticate);

OpenIdConnect\OpenIdConnectChallengeTests.cs (2)

814Assert.Empty(mockBackchannel.PushedParameters); 852Assert.Empty(mockBackchannel.PushedParameters);

TicketSerializerTests.cs (1)

26Assert.Empty(readTicket.Principal.Identities);

AuthorizationPolicyFacts.cs (1)

66Assert.Empty(combined.Requirements.OfType<DenyAnonymousAuthorizationRequirement>());

AuthorizeViewTest.cs (3)

38Assert.Empty(diff.Edits); 101Assert.Empty(diff.Edits); 269Assert.Empty(diff1.Edits);

Binding\FormDataMapperTests.cs (4)

112Assert.Empty(errors); 600Assert.Empty(errors); 1097Assert.Empty(errors); 1867Assert.Empty(errors);

EndpointHtmlRendererTest.cs (1)

91Assert.Empty(httpContext.Items);

HotReloadServiceTests.cs (3)

96Assert.Empty(pageEndpoints); 147Assert.Empty(pageEndpoints); 148Assert.Empty(compositePageEndpoints);

EditContextDataAnnotationsExtensionsTest.cs (1)

180Assert.Empty(editContext.GetValidationMessages());

EditContextTest.cs (1)

148Assert.Empty(editContext.GetValidationMessages(fieldWithNoState));

ValidationMessageStoreTest.cs (4)

38Assert.Empty(messages[field3]); 71Assert.Empty(messages[field1]); 89Assert.Empty(messages[field1]); 90Assert.Empty(messages[field2]);

Circuits\CircuitHostTest.cs (1)

273Assert.Empty(reportedErrors);

Circuits\CircuitRegistryTest.cs (1)

149Assert.Empty(registry.ConnectedCircuits);

Circuits\RemoteRendererTest.cs (3)

253Assert.Empty(exceptions); 316Assert.Empty(exceptions); 372Assert.Empty(exceptions);

Circuits\RevalidatingServerAuthenticationStateProviderTest.cs (2)

118Assert.Empty(provider.RevalidationCallLog.Skip(1)); 141Assert.Empty(provider.RevalidationCallLog);

Circuits\ServerComponentDeserializerTest.cs (9)

164Assert.Empty(descriptors); 178Assert.Empty(descriptors); 190Assert.Empty(descriptors); 206Assert.Empty(descriptors); 221Assert.Empty(descriptors); 236Assert.Empty(descriptors); 271Assert.Empty(descriptors); 288Assert.Empty(descriptors); 303Assert.Empty(descriptors);

CascadingParameterStateTest.cs (10)

22Assert.Empty(result); 35Assert.Empty(result); 48Assert.Empty(result); 65Assert.Empty(result); 193Assert.Empty(result); 227Assert.Empty(result); 242Assert.Empty(result); 257Assert.Empty(result); 272Assert.Empty(result); 287Assert.Empty(result);

LayoutViewTest.cs (5)

33Assert.Empty(frames); 181Assert.Empty(batch.DisposedComponentIDs); 183diff => Assert.Empty(diff.Edits), // LayoutView rerendered, but with no changes 184diff => Assert.Empty(diff.Edits), // RootLayout rerendered, but with no changes 225diff => Assert.Empty(diff.Edits), // LayoutView rerendered, but with no changes

NavigationManagerTest.cs (1)

700Assert.Empty(navigationManager.ExceptionsThrownFromLocationChangingHandlers);

ParameterViewTest.cs (4)

22Assert.Empty(ToEnumerable(parameters)); 36Assert.Empty(ToEnumerable(parameters)); 248Assert.Empty(collection.ToDictionary()); 356Assert.Empty(ToEnumerable(cloned));

PersistentState\ComponentStatePersistenceManagerTest.cs (3)

36Assert.Empty(persistenceManager.RegisteredCallbacks); 58Assert.Empty(state); 243Assert.Empty(sequence);

RendererTest.cs (15)

Rendering\ArrayBuilderTest.cs (1)

244Assert.Empty(ArrayPool.ReturnedBuffers);

Rendering\RenderTreeBuilderTest.cs (2)

22Assert.Empty(frames.AsEnumerable()); 901Assert.Empty(builder.GetFrames().AsEnumerable());

RenderTreeDiffBuilderTest.cs (11)

45Assert.Empty(result.Edits); 1640Assert.Empty(result.Edits); 1665Assert.Empty(result.Edits); 1670Assert.Empty(batchBuilder.DisposedEventHandlerIDs.AsEnumerable()); 1697Assert.Empty(batchBuilder.DisposedEventHandlerIDs.AsEnumerable()); 1832Assert.Empty(batchBuilder.ComponentDisposalQueue); 1900Assert.Empty(diff.Edits); 1901Assert.Empty(referenceFrames); 1964Assert.Empty(diff.Edits); 1965Assert.Empty(referenceFrames); 2321Assert.Empty(result.Edits);

Routing\RouterTest.cs (1)

86Assert.Empty(_renderer.HandledExceptions);

SupplyParameterFromPersistentComponentStateValueProviderTests.cs (5)

91Assert.Empty(provider.Subscriptions); 316Assert.Empty(store.State); 357Assert.Empty(store.State); 390Assert.Empty(store.State); 430Assert.Empty(store.State);

Forms\InputBaseTest.cs (8)

146Assert.Empty(valueChangedCallLog); 169Assert.Empty(valueChangedCallLog); 175Assert.Empty(valueChangedCallLog); 301Assert.Empty(rootComponent.EditContext.GetValidationMessages(fieldIdentifier)); 324Assert.Empty(valueChangedArgs); 336Assert.Empty(rootComponent.EditContext.GetValidationMessages(fieldIdentifier)); 361Assert.Empty(rootComponent.EditContext.GetValidationMessages(fieldIdentifier)); 423Assert.Empty(renderer.Batches.Skip(1));

Forms\InputFileChangeEventArgsTest.cs (1)

46Assert.Empty(instance.GetMultipleFiles());

WebViewManagerTests.cs (3)

20Assert.Empty(webViewManager.SentIpcMessages); 38Assert.Empty(webViewManager.SentIpcMessages); 63Assert.Empty(webViewManager.SentIpcMessages);

ConcurrencyLimiterEventSourceTests.cs (1)

42Assert.Empty(eventData.Payload);

CorsMiddlewareTests.cs (3)

328Assert.Empty(response.Headers); 370Assert.Empty(response.Headers); 428Assert.Empty(httpContext.Response.Headers);

CorsPolicyBuilderTests.cs (10)

63Assert.Empty(corsPolicy.Headers); 64Assert.Empty(corsPolicy.Methods); 65Assert.Empty(corsPolicy.ExposedHeaders); 80Assert.Empty(corsPolicy.ExposedHeaders); 81Assert.Empty(corsPolicy.Headers); 82Assert.Empty(corsPolicy.Methods); 83Assert.Empty(corsPolicy.Origins); 104Assert.Empty(corsPolicy.ExposedHeaders); 105Assert.Empty(corsPolicy.Headers); 106Assert.Empty(corsPolicy.Methods);

CorsPolicyTests.cs (4)

19Assert.Empty(corsPolicy.ExposedHeaders); 20Assert.Empty(corsPolicy.Headers); 21Assert.Empty(corsPolicy.Methods); 22Assert.Empty(corsPolicy.Origins);

CorsResultTests.cs (3)

15Assert.Empty(result.AllowedHeaders); 16Assert.Empty(result.AllowedExposedHeaders); 17Assert.Empty(result.AllowedMethods);

CorsServiceTests.cs (4)

254Assert.Empty(result.AllowedExposedHeaders); 488Assert.Empty(result.AllowedHeaders); 557Assert.Empty(result.AllowedHeaders); 573Assert.Empty(httpContext.Response.Headers);

DataProtectionProviderTests.cs (8)

31Assert.Empty(directory.GetFiles()); 97Assert.Empty(directory.GetFiles()); 141Assert.Empty(directory.GetFiles()); 225Assert.Empty(directory.GetFiles()); 254Assert.Empty(directory.GetFiles()); 262Assert.Empty(directory.GetFiles()); 280Assert.Empty(store.Certificates.Find(X509FindType.FindByThumbprint, certificate.Thumbprint, false)); 294Assert.Empty(directory.GetFiles());

Internal\KeyManagementOptionsSetupTest.cs (1)

31Assert.Empty(options.KeyEscrowSinks);

KeyManagement\KeyRingBasedDataProtectorTests.cs (1)

346Assert.Empty(result);

KeyManagement\XmlKeyManagerTests.cs (1)

331Assert.Empty(keys);

RegistryPolicyResolverTests.cs (1)

29Assert.Empty(context.KeyEscrowSinks);

Repositories\EphemeralXmlRepositoryTests.cs (2)

18Assert.Empty(repository.GetAllElements()); 108Assert.Empty(repository.GetAllElements());

Repositories\FileSystemXmlRepositoryTests.cs (1)

58Assert.Empty(allElements);

Repositories\RegistryXmlRepositoryTests.cs (1)

45Assert.Empty(allElements);

CertificateManagerTests.cs (3)

321Assert.Empty(_manager.ListCertificates(StoreName.My, StoreLocation.CurrentUser, isValid: false)); 394Assert.Empty(httpsCertificateList); 414Assert.Empty(httpsCertificateList);

Logging\HeaderReaderTests.cs (2)

24Assert.Empty(listToFill); 33Assert.Empty(listToFill);

Logging\IncomingHttpRouteUtilityTests.cs (1)

268Assert.Empty(sensitiveParameters);

Logging\RequestHeadersEnricherTests.cs (3)

73Assert.Empty(enrichedState); 215Assert.Empty(enrichedState); 248Assert.Empty(enrichedState);

ExceptionHandlerMiddlewareTest.cs (2)

91Assert.Empty(context.Request.RouteValues); 226Assert.Empty(diagnosticsRequestExceptionCollector.GetMeasurementSnapshot());

StatusCodeMiddlewareTest.cs (1)

148Assert.Empty(context.Request.RouteValues);

HttpRoutePatternParserTests.cs (8)

76Assert.Empty(pattern.Variables); 86Assert.Empty(pattern.Variables); 96Assert.Empty(pattern.Variables); 103Assert.Empty(pattern.Segments); 104Assert.Empty(pattern.Variables); 115Assert.Empty(pattern.Variables); 126Assert.Empty(pattern.Variables); 138Assert.Empty(pattern.Variables);

JsonTranscodingRouteAdapterTests.cs (9)

26Assert.Empty(adapter.RewriteVariableActions); 57Assert.Empty(adapter.RewriteVariableActions); 67Assert.Empty(adapter.RewriteVariableActions); 77Assert.Empty(adapter.RewriteVariableActions); 87Assert.Empty(adapter.RewriteVariableActions); 97Assert.Empty(adapter.RewriteVariableActions); 107Assert.Empty(adapter.RewriteVariableActions); 117Assert.Empty(adapter.RewriteVariableActions); 127Assert.Empty(adapter.RewriteVariableActions);

UnaryServerCallHandlerTests.cs (2)

258Assert.Empty(request!.Sub.Subfields); 1300Assert.Empty(requestData!);

SchemaGeneratorIntegrationTests.cs (1)

146Assert.Empty(resolvedSchema.Properties);

HeaderPropagationMessageHandlerTest.cs (2)

135Assert.Empty(Handler.Headers); 148Assert.Empty(Handler.Headers);

HeaderPropagationMiddlewareTest.cs (2)

60Assert.Empty(CapturedHeaders); 73Assert.Empty(CapturedHeaders);

HostingApplicationDiagnosticsTests.cs (2)

407Assert.Empty(requestDurationCollector.GetMeasurementSnapshot()); 462Assert.Empty(requestDurationCollector.GetMeasurementSnapshot());

HostingMetricsTests.cs (2)

149Assert.Empty(currentRequestsCollector.GetMeasurementSnapshot()); 150Assert.Empty(requestDurationCollector.GetMeasurementSnapshot());

Internal\HostingEventSourceTests.cs (4)

46Assert.Empty(eventData.Payload); 69Assert.Empty(eventData.Payload); 153Assert.Empty(eventData.Payload); 175Assert.Empty(eventData.Payload);

StaticWebAssets\ManifestStaticWebAssetsFileProviderTests.cs (1)

588Assert.Empty(directory);

WebHostTests.cs (1)

114Assert.Empty(serverAddressesFeature.Addresses);

HtmlContentBuilderTest.cs (1)

108Assert.Empty(content.Entries);

HttpConnectionDispatcherTests.cs (3)

1161Assert.Empty(currentConnections.GetMeasurementSnapshot()); 1162Assert.Empty(connectionDuration.GetMeasurementSnapshot()); 2279Assert.Empty(availableTransports);

MapConnectionHandlerTests.cs (1)

421Assert.Empty(endpoint.Metadata.GetOrderedMetadata<DisableRequestTimeoutAttribute>());

HeaderDictionaryTypeExtensionsTest.cs (4)

187Assert.Empty(result); 198Assert.Empty(result); 267Assert.Empty(results); 276Assert.Empty(results);

RequestDelegateFactoryTests.cs (3)

771Assert.Empty(TestSink.Writes); 2527Assert.Empty(result.EndpointMetadata); 2586Assert.Empty(result.EndpointMetadata);

RequestDelegateGenerator\CompileTimeCreationTests.AsParameters.cs (3)

34Assert.Empty(result.GeneratedSources); 92Assert.Empty(result.GeneratedSources); 110Assert.Empty(result.GeneratedSources);

RequestDelegateGenerator\CompileTimeCreationTests.cs (10)

28Assert.Empty(GetStaticEndpoints(results, GeneratorSteps.EndpointModelStep)); 71Assert.Empty(diagnostics.Where(d => d.Severity >= DiagnosticSeverity.Warning)); 97Assert.Empty(diagnostics.Where(d => d.Severity >= DiagnosticSeverity.Warning)); 179Assert.Empty(diagnostics.Where(d => d.Severity >= DiagnosticSeverity.Warning)); 203Assert.Empty(result.GeneratedSources); 248Assert.Empty(result.GeneratedSources); 302Assert.Empty(result.GeneratedSources); 685Assert.Empty(GetStaticEndpoints(result, GeneratorSteps.EndpointModelStep)); 740Assert.Empty(diagnostics.Where(d => d.Severity >= DiagnosticSeverity.Warning)); 755Assert.Empty(result.GeneratedSources);

RequestDelegateGenerator\RequestDelegateCreationTestBase.cs (2)

75Assert.Empty(diagnostics.Where(d => d.Severity >= DiagnosticSeverity.Warning)); 151Assert.Empty(result.Diagnostics.Where(d => d.Severity > DiagnosticSeverity.Warning));

RequestDelegateGenerator\RequestDelegateCreationTests.Forms.cs (1)

1014Assert.Empty(TestSink.Writes);

RequestDelegateGenerator\RequestDelegateCreationTests.Logging.cs (6)

162Assert.Empty(TestSink.Writes); 199Assert.Empty(TestSink.Writes); 279Assert.Empty(TestSink.Writes); 358Assert.Empty(TestSink.Writes); 572Assert.Empty(TestSink.Writes); 651Assert.Empty(TestSink.Writes);

RequestDelegateGenerator\RequestDelegateCreationTests.Metadata.cs (1)

66Assert.Empty(metadata);

ValidationsGenerator\ValidationsGeneratorTestBase.cs (1)

146Assert.Empty(result.Diagnostics.Where(d => d.Severity > DiagnosticSeverity.Warning));

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

75Assert.Empty(diagnostics.Where(d => d.Severity >= DiagnosticSeverity.Warning)); 151Assert.Empty(result.Diagnostics.Where(d => d.Severity > DiagnosticSeverity.Warning));

ResultsTests.cs (2)

1338Assert.Empty(result.ProblemDetails.Extensions); 1354Assert.Empty(result.ProblemDetails.Extensions);

TypedResultsTests.cs (2)

1130Assert.Empty(result.ProblemDetails.Extensions); 1146Assert.Empty(result.ProblemDetails.Extensions);

ApplicationBuilderTests.cs (1)

47Assert.Empty(builder.ServerFeatures);

DefaultHttpContextTests.cs (2)

76Assert.Empty(context.Session.Keys); 98Assert.Empty(context.User.Identities);

Features\FormFeatureTests.cs (3)

225Assert.Empty(formCollection.Files); 262Assert.Empty(formCollection.Files); 347Assert.Empty(formCollection.Files);

Features\QueryFeatureTests.cs (1)

148Assert.Empty(queryCollection);

Internal\DefaultHttpRequestTests.cs (4)

170Assert.Empty(cookies0); 207Assert.Empty(request.RouteValues); 227Assert.Empty(request.RouteValues); 239Assert.Empty(request.RouteValues);

Timeouts\RequestTimeoutsMiddlewareTests.cs (3)

198Assert.Empty(context.Response.Headers); 214Assert.Empty(context.Response.Headers); 234Assert.Empty(context.Response.Headers);

FileLoggerProcessorTests.cs (2)

236Assert.Empty(testSink.Writes); 251Assert.Empty(testSink2.Writes);

HttpLoggingMiddlewareTests.cs (3)

112Assert.Empty(TestSink.Writes); 726Assert.Empty(TestSink.Writes); 1059Assert.Empty(TestSink.Writes);

HttpLoggingOptionsTests.cs (1)

51Assert.Empty(options.MediaTypeOptions.MediaTypeStates);

W3CLoggingMiddlewareTests.cs (1)

63Assert.Empty(logger.Processor.Lines);

HstsMiddlewareTests.cs (3)

208Assert.Empty(response.Headers); 318Assert.Empty(response.Headers); 365Assert.Empty(response.Headers);

SqlStoreTestBase.cs (2)

176Assert.Empty(roles); 199Assert.Empty(roles);

UserStoreWithGenericsTest.cs (2)

121Assert.Empty(userClaims); 148Assert.Empty(userClaims);

MapIdentityApiTests.cs (2)

878Assert.Empty(recoveryCodes.Intersect(resetRecoveryCodes)); 1244Assert.Empty(emailSender.Emails);

Pages\RegisterConfirmation.cs (1)

23Assert.Empty(Document.QuerySelectorAll("#confirm-link"));

IdentitySpecificationTestBase.cs (3)

262Assert.Empty(roleClaims); 333Assert.Empty(manager.Roles.Where(func)); 595Assert.Empty((await manager.GetUsersInRoleAsync("123456")));

UserManagerSpecificationTests.cs (6)

564Assert.Empty(logins); 655Assert.Empty(logins); 725Assert.Empty(userClaims); 756Assert.Empty(userClaims); 942Assert.Empty(mgr.Users.Where(UserNameEqualsPredicate("bogus"))); 1933Assert.Empty((await manager.GetUsersForClaimAsync(new Claim("123", "456"))));

IdentityResultTest.cs (2)

13Assert.Empty(result.Errors); 21Assert.Empty(result.Errors);

Internal\DictionaryAdapterTest.cs (4)

210Assert.Empty(dictionary); 228Assert.Empty(dictionary); 271Assert.Empty(dictionary); 290Assert.Empty(dictionary);

Internal\DictionaryAdapterTest.cs (4)

213Assert.Empty(dictionary); 231Assert.Empty(dictionary); 273Assert.Empty(dictionary); 292Assert.Empty(dictionary);

ModelBinding\ModelStateDictionaryTest.cs (30)

ModelBinding\ValueProviderResultTest.cs (3)

22Assert.Empty((string[])result); 37Assert.Empty((string[])result); 53Assert.Empty((string[])result);

ApiResponseTypeProviderTest.cs (14)

DefaultApiDescriptionProviderTest.cs (11)

76Assert.Empty(descriptions); 89Assert.Empty(descriptions); 297Assert.Empty(description.ParameterDescriptions); 469Assert.Empty(id1.RouteInfo.Constraints); 663Assert.Empty(description.SupportedResponseTypes); 745Assert.Empty(responseType.ApiResponseFormats); 848Assert.Empty(responseType.ApiResponseFormats); 918Assert.Empty(GetSortedMediaTypes(responseType)); 988Assert.Empty(GetSortedMediaTypes(responseType)); 1249Assert.Empty(description.SupportedRequestFormats); 1521Assert.Empty(description.ParameterDescriptions);

EndpointMetadataApiDescriptionProviderTest.cs (17)

ApplicationModels\ApiBehaviorApplicationModelProviderTest.cs (2)

80Assert.Empty(actionModel.Selectors[0].EndpointMetadata); 123Assert.Empty(actionModel.Selectors[0].EndpointMetadata);

ApplicationModels\AuthorizationApplicationModelProviderTest.cs (6)

33Assert.Empty(controller.Filters); 51Assert.Empty(controller.Filters); 94Assert.Empty(attributeRoutes); 188Assert.Empty(controller.Filters); 190Assert.Empty(action.Filters); 200Assert.Empty(controller.Filters);

ApplicationModels\DefaultApplicationModelProviderTest.cs (11)

93Assert.Empty(property.Attributes); 145Assert.Empty(property.Attributes); 198Assert.Empty(parameter.Attributes); 428Assert.Empty(model.Filters); 761Assert.Empty(GetAttributeRoutes(action.Selectors)); 784Assert.Empty(GetAttributeRoutes(action.Selectors)); 808Assert.Empty(GetAttributeRoutes(action.Selectors)); 833Assert.Empty(GetAttributeRoutes(action.Selectors)); 856Assert.Empty(GetAttributeRoutes(action.Selectors)); 1016Assert.Empty(GetAttributeRoutes(action.Selectors)); 1298Assert.Empty(model.Actions);

ApplicationParts\ApplicationPartManagerTest.cs (1)

73Assert.Empty(feature.Values.ToArray());

ApplicationParts\RelatedAssemblyPartTest.cs (1)

25Assert.Empty(result);

BadRequestObjectResultTests.cs (1)

32Assert.Empty(errors);

Builder\MvcApplicationBuilderExtensionsTest.cs (1)

56Assert.Empty(endpointDataSource.Endpoints);

Builder\MvcAreaRouteBuilderExtensionsTest.cs (4)

35Assert.Empty(route.DataTokens); 70Assert.Empty(route.DataTokens); 116Assert.Empty(route.DataTokens); 259Assert.Empty(route.DataTokens);

ConflictObjectResultTest.cs (1)

32Assert.Empty(errors);

ControllerBaseTest.cs (3)

2062Assert.Empty(errors); 2108Assert.Empty(errors); 2155Assert.Empty(errors);

Controllers\ControllerBinderDelegateProviderTest.cs (4)

73Assert.Empty(arguments); 128Assert.Empty(arguments); 178Assert.Empty(arguments); 220Assert.Empty(arguments);

Controllers\ControllerFeatureProviderTest.cs (10)

73Assert.Empty(feature.Controllers); 88Assert.Empty(feature.Controllers); 103Assert.Empty(feature.Controllers); 118Assert.Empty(feature.Controllers); 133Assert.Empty(feature.Controllers); 148Assert.Empty(feature.Controllers); 179Assert.Empty(feature.Controllers); 194Assert.Empty(feature.Controllers); 290Assert.Empty(feature.Controllers); 380Assert.Empty(feature.Controllers);

DependencyInjection\MvcCoreServiceCollectionExtensionsTest.cs (2)

160Assert.Empty(builder.PartManager.ApplicationParts); 184Assert.Empty(builder.PartManager.ApplicationParts);

Filters\FilterFactoryTest.cs (3)

23Assert.Empty(filterResult.CacheableFilters); 24Assert.Empty(filterResult.Filters); 49Assert.Empty(filterResult.Filters);

Formatters\FormatFilterTest.cs (1)

387Assert.Empty(result.ContentTypes);

Infrastructure\ActionSelectorTest.cs (3)

181Assert.Empty(candidates); 214Assert.Empty(candidates); 514Assert.Empty(sink.Scopes);

Infrastructure\JsonResultExecutorTestBase.cs (1)

229Assert.Empty(written);

ModelBinding\Binders\ArrayModelBinderTest.cs (2)

81Assert.Empty(Assert.IsType<string[]>(bindingContext.Result.Model)); 115Assert.Empty(Assert.IsType<string[]>(bindingContext.Result.Model));

ModelBinding\Binders\ByteArrayModelBinderTests.cs (1)

100Assert.Empty(bindingContext.ModelState); // No submitted data for "foo".

ModelBinding\Binders\CollectionModelBinderTest.cs (4)

191Assert.Empty(model); 267Assert.Empty(Assert.IsType<List<string>>(bindingContext.Result.Model)); 301Assert.Empty(Assert.IsType<List<string>>(bindingContext.Result.Model)); 376Assert.Empty(list);

ModelBinding\Binders\ComplexObjectModelBinderTest.cs (2)

992Assert.Empty(modelState); 1015Assert.Empty(model.ReadOnlyList);

ModelBinding\Binders\ComplexTypeModelBinderTest.cs (2)

1154Assert.Empty(modelState); 1177Assert.Empty(model.ReadOnlyList);

ModelBinding\Binders\DateTimeModelBinderTest.cs (2)

88Assert.Empty(bindingContext.ModelState); 103Assert.Empty(bindingContext.ModelState);

ModelBinding\Binders\DictionaryModelBinderTest.cs (3)

225Assert.Empty(resultDictionary); 452Assert.Empty(Assert.IsType<Dictionary<string, string>>(bindingContext.Result.Model)); 487Assert.Empty(Assert.IsType<Dictionary<string, string>>(bindingContext.Result.Model));

ModelBinding\Binders\FloatingPointTypeModelBinderTestOfT.cs (1)

184Assert.Empty(bindingContext.ModelState);

ModelBinding\Binders\FormCollectionModelBinderTest.cs (2)

32Assert.Empty(bindingContext.ValidationState); 54Assert.Empty(form);

ModelBinding\Binders\KeyValuePairModelBinderTest.cs (1)

139Assert.Empty(bindingContext.ModelState);

ModelBinding\Binders\SimpleTypeModelBinderTest.cs (1)

192Assert.Empty(bindingContext.ModelState);

ModelBinding\Binders\TryParseTypeModelBinderTest.cs (1)

141Assert.Empty(bindingContext.ModelState);

ModelBinding\CompositeValueProviderTest.cs (1)

102Assert.Empty(values);

ModelBinding\EnumerableValueProviderTest.cs (1)

113Assert.Empty(result);

ModelBinding\FormFileValueProviderFactoryTest.cs (2)

25Assert.Empty(context.ValueProviders); 39Assert.Empty(context.ValueProviders);

ModelBinding\FormValueProviderFactoryTest.cs (1)

26Assert.Empty(context.ValueProviders);

ModelBinding\JQueryFormValueProviderFactoryTest.cs (1)

50Assert.Empty(context.ValueProviders);

ModelBinding\JQueryQueryStringValueProviderFactoryTest.cs (1)

94Assert.Empty(context.ValueProviders);

ModelBinding\Metadata\DefaultModelMetadataTest.cs (1)

31Assert.Empty(metadata.AdditionalValues);

ModelBinding\Metadata\ModelAttributesTest.cs (1)

190Assert.Empty(attributes.ParameterAttributes);

ModelBinding\ModelBindingHelperTest.cs (13)

ModelBinding\PrefixContainerTest.cs (2)

196Assert.Empty(result); 239Assert.Empty(result);

ModelBinding\QueryStringValueProviderFactoryTest.cs (1)

26Assert.Empty(factoryContext.ValueProviders);

ModelBinding\Validation\DefaultObjectValidatorTests.cs (29)

MvcCoreLoggerExtensionsTest.cs (1)

163Assert.Empty(testSink.Writes);

ObjectResultTests.cs (2)

28Assert.Empty(result.ContentTypes); 29Assert.Empty(result.Formatters);

ProducesAttributeTests.cs (2)

84Assert.Empty(objectResult.ContentTypes); 151Assert.Empty(producesAttribute.ContentTypes);

Routing\ActionEndpointFactoryTest.cs (7)

68Assert.Empty(endpoints); 86Assert.Empty(endpoints); 116Assert.Empty(endpoints); 131Assert.Empty(endpoints); 171Assert.Empty(endpoints); 202Assert.Empty(endpoints); 323Assert.Empty(endpoints);

Routing\AttributeRouteTest.cs (15)

108Assert.Empty(context.RouteData.Values); 146Assert.Empty(e.Constraints); 147Assert.Empty(e.Defaults); 191Assert.Empty(e.Defaults); 234Assert.Empty(e.Constraints); 295Assert.Empty(e.Constraints); 296Assert.Empty(e.Defaults); 305Assert.Empty(e.Constraints); 306Assert.Empty(e.Defaults); 349Assert.Empty(e.Constraints); 354Assert.Empty(e.Defaults); 397Assert.Empty(e.Defaults); 435Assert.Empty(e.Constraints); 497Assert.Empty(e.Constraints); 502Assert.Empty(e.Defaults);

Routing\ControllerActionEndpointDataSourceTest.cs (1)

45Assert.Empty(endpoints);

Routing\MvcRouteHandlerTests.cs (1)

44Assert.Empty(sink.Scopes);

SerializableErrorTests.cs (1)

78Assert.Empty(serializableError);

UnprocessableEntityObjectResultTests.cs (1)

32Assert.Empty(errors);

ValidationProblemDetailsTest.cs (1)

18Assert.Empty(problemDescription.Errors);

CorsAuthorizationFilterTest.cs (2)

70Assert.Empty(authorizationContext.HttpContext.Response.Headers); 113Assert.Empty(authorizationContext.HttpContext.Response.Headers);

DataAnnotationsClientModelValidatorProviderTest.cs (1)

88Assert.Empty(providerContext.Results);

DataAnnotationsModelValidatorTest.cs (4)

119Assert.Empty(results); 149Assert.Empty(result); 210Assert.Empty(result); 258Assert.Empty(result);

DataTypeClientModelValidatorProviderTest.cs (1)

80Assert.Empty(providerContext.Results);

ValidatableObjectAdapterTest.cs (1)

132Assert.Empty(results);

DelegatingEnumerableTest.cs (2)

27Assert.Empty(delegatingEnumerable); 65Assert.Empty(delegatingEnumerable);

EnumerableWrapperProviderTest.cs (1)

51Assert.Empty(delegatingEnumerable);

SerializableErrorWrapperTests.cs (1)

21Assert.Empty(wrapper.SerializableError);

ValidationProblemDetailsWrapperTest.cs (2)

110Assert.Empty(problemDetails.Errors); 133Assert.Empty(problemDetails.Errors);

XmlDataContractSerializerOutputFormatterTest.cs (1)

741Assert.Empty(body.ToArray());

XmlSerializerOutputFormatterTest.cs (1)

523Assert.Empty(body.ToArray());

ApiExplorerTest.cs (15)

BasicTests.cs (2)

199Assert.Empty(responseBytes); 215Assert.Empty(responseBytes);

CorsTestsBase.cs (8)

73Assert.Empty(response.Headers); 91Assert.Empty(response.Headers); 233Assert.Empty(response.Headers); 259Assert.Empty(response.Headers); 286Assert.Empty(response.Headers); 381Assert.Empty(response.Headers); 404Assert.Empty(response.Headers); 424Assert.Empty(response.Headers);

RoutingTestsBase.cs (1)

210Assert.Empty(result);

VersioningTestsBase.cs (2)

208Assert.Empty(body); 259Assert.Empty(body);

XmlDataContractSerializerInputFormatterTest.cs (1)

75Assert.Empty(modelBindingInfo.ModelStateErrorMessages);

ActionParametersIntegrationTest.cs (10)

71Assert.Empty(modelState[key].Errors); 109Assert.Empty(boundModel.Address); 165Assert.Empty(modelState[key].Errors); 203Assert.Empty(boundModel.Address); 207Assert.Empty(modelState.Keys); 251Assert.Empty(modelState[key].Errors); 288Assert.Empty(boundModel.Address); 342Assert.Empty(modelState[key].Errors); 379Assert.Empty(boundModel.Address); 383Assert.Empty(modelState.Keys);

ArrayModelBinderIntegrationTest.cs (4)

160Assert.Empty(Assert.IsType<int[]>(modelBindingResult.Model)); 162Assert.Empty(modelState); 322Assert.Empty(Assert.IsType<Person[]>(modelBindingResult.Model)); 324Assert.Empty(modelState);

BinderTypeBasedModelBinderIntegrationTest.cs (2)

45Assert.Empty(modelState); 76Assert.Empty(modelState);

BodyValidationIntegrationTests.cs (5)

430Assert.Empty(modelState); 544Assert.Empty(modelState); 789Assert.Empty(modelState); 845Assert.Empty(modelState); 890Assert.Empty(modelState);

ByteArrayModelBinderIntegrationTest.cs (3)

63Assert.Empty(entry.Value.Errors); 99Assert.Empty(modelState.Keys); 144Assert.Empty(entry.Value.Errors);

CancellationTokenModelBinderIntegrationTest.cs (3)

53Assert.Empty(modelState.Keys); 88Assert.Empty(modelState); 126Assert.Empty(modelState);

CollectionModelBinderIntegrationTest.cs (6)

158Assert.Empty(Assert.IsType<List<int>>(modelBindingResult.Model)); 160Assert.Empty(modelState); 271Assert.Empty(Assert.IsType<List<Person>>(modelBindingResult.Model)); 273Assert.Empty(modelState); 565Assert.Empty(Assert.IsType<List<Person2>>(modelBindingResult.Model)); 567Assert.Empty(modelState);

ComplexRecordIntegrationTest.cs (18)

324Assert.Empty(modelState); 954Assert.Empty(modelState); 1157Assert.Empty(modelState); 1360Assert.Empty(modelState); 1944Assert.Empty(modelState); 2678Assert.Empty(entry.Errors); 2726Assert.Empty(entry.Errors); 2786Assert.Empty(entry.Errors); 2839Assert.Empty(entry.Errors); 3015Assert.Empty(state.Value.Errors); 3088Assert.Empty(kvp.Value.Errors); 3096Assert.Empty(kvp.Value.Errors); 3151Assert.Empty(state.Value.Errors); 3213Assert.Empty(kvp.Value.Errors); 3220Assert.Empty(kvp.Value.Errors); 3476Assert.Empty(modelState); 4018Assert.Empty(modelState); 4196Assert.Empty(entry.Value.Errors);

ComplexTypeIntegrationTestBase.cs (15)

307Assert.Empty(modelState); 962Assert.Empty(modelState); 1170Assert.Empty(modelState); 1378Assert.Empty(modelState); 2091Assert.Empty(modelState); 2857Assert.Empty(entry.Errors); 2905Assert.Empty(entry.Errors); 2977Assert.Empty(entry.Errors); 3030Assert.Empty(entry.Errors); 3223Assert.Empty(state.Value.Errors); 3303Assert.Empty(kvp.Value.Errors); 3311Assert.Empty(kvp.Value.Errors); 3373Assert.Empty(state.Value.Errors); 3435Assert.Empty(kvp.Value.Errors); 3442Assert.Empty(kvp.Value.Errors);

DictionaryModelBinderIntegrationTest.cs (6)

422Assert.Empty(model); 424Assert.Empty(modelState); 458Assert.Empty(modelState); 844Assert.Empty(model); 846Assert.Empty(modelState); 880Assert.Empty(modelState);

FormCollectionModelBindingIntegrationTest.cs (6)

69Assert.Empty(entry.Value.Errors); 115Assert.Empty(modelState); 148Assert.Empty(modelState); 151Assert.Empty(collection); 152Assert.Empty(collection.Files); 153Assert.Empty(collection.Keys);

FormFileModelBindingIntegrationTest.cs (17)

GenericModelBinderIntegrationTest.cs (11)

51Assert.Empty(modelState); 89Assert.Empty(modelState); 123Assert.Empty(model); 217Assert.Empty(modelState); 251Assert.Empty(modelState); 374Assert.Empty(model); 376Assert.Empty(modelState); 497Assert.Empty(model); 499Assert.Empty(modelState); 629Assert.Empty(model); 631Assert.Empty(modelState);

HeaderModelBinderIntegrationTest.cs (13)

103Assert.Empty(entry.Value.Errors); 145Assert.Empty(entry.Value.Errors); 192Assert.Empty(modelStateEntry.Errors); 239Assert.Empty(modelStateEntry.Errors); 299Assert.Empty(entry.Value.Errors); 365Assert.Empty(entry.Errors); 374Assert.Empty(entry.Errors); 383Assert.Empty(entry.Errors); 392Assert.Empty(entry.Errors); 401Assert.Empty(entry.Errors); 410Assert.Empty(entry.Errors); 419Assert.Empty(entry.Errors); 428Assert.Empty(entry.Errors);

KeyValuePairModelBinderIntegrationTest.cs (4)

85Assert.Empty(entry.Errors); 135Assert.Empty(entry.Errors); 167Assert.Empty(entry.Errors); 217Assert.Empty(entry.Errors);

ModelPrefixSelectionIntegrationTest.cs (5)

55Assert.Empty(modelState); 104Assert.Empty(modelState); 143Assert.Empty(modelState); 192Assert.Empty(modelState); 238Assert.Empty(modelState);

ServicesModelBinderIntegrationTest.cs (11)

48Assert.Empty(modelState.Keys); 84Assert.Empty(modelState); 120Assert.Empty(modelState); 152Assert.Empty(actionResultArray); 156Assert.Empty(modelState); 225Assert.Empty(modelState.Keys); 261Assert.Empty(modelState); 294Assert.Empty(modelState.Keys); 330Assert.Empty(modelState); 373Assert.Empty(modelState); 410Assert.Empty(modelState);

SimpleTypeModelBinderIntegrationTest.cs (12)

TryUpdateModelIntegrationTest.cs (26)

TryValidateModelIntegrationTest.cs (1)

72Assert.Empty(modelStateErrors);

ValidationIntegrationTests.cs (15)

ValidationWithRecordIntegrationTests.cs (15)

NewtonsoftJsonOutputFormatterTest.cs (2)

462Assert.Empty(body.ToArray()); 541Assert.Empty(body.ToArray());

src\Mvc\Mvc.Core\test\Infrastructure\JsonResultExecutorTestBase.cs (1)

229Assert.Empty(written);

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

21Assert.Empty(tempDataDictionary);

AssemblyPartExtensionTest.cs (1)

58Assert.Empty(references);

FileProviderRazorProjectFileSystemTest.cs (1)

28Assert.Empty(razorFiles);

DependencyInjection\MvcRazorMvcCoreBuilderExtensionsTest.cs (2)

26Assert.Empty(builder.PartManager.ApplicationParts); 49Assert.Empty(builder.PartManager.ApplicationParts);

RazorHotReloadTest.cs (1)

68Assert.Empty(pageActivator.ActivationInfo);

RazorPageTest.cs (5)

277Assert.Empty(bufferScope.CreatedBuffers); 286Assert.Empty(bufferScope.ReturnedBuffers); 289Assert.Empty(bufferScope.ReturnedBuffers); 301Assert.Empty(bufferScope.ReturnedBuffers); 1127Assert.Empty(output.Attributes);

RazorViewEngineTest.cs (2)

160Assert.Empty(view.ViewStartPages); 192Assert.Empty(view1.ViewStartPages);

ApplicationModels\DefaultPageApplicationModelProviderTest.cs (4)

456Assert.Empty(pageModel.HandlerMethods); 477Assert.Empty(pageModel.HandlerMethods); 732Assert.Empty(handlerMethods); 759Assert.Empty(handlerMethods);

ApplicationModels\TempDataFilterPageApplicationModelProviderTest.cs (1)

26Assert.Empty(context.PageApplicationModel.Filters);

ApplicationModels\ViewDataAttributePageApplicationModelProviderTest.cs (1)

24Assert.Empty(context.PageApplicationModel.Filters);

Builder\PageActionEndpointConventionBuilderResourceCollectionExtensionsTest.cs (3)

36Assert.Empty(list); 57Assert.Empty(list); 198Assert.Empty(list);

DependencyInjection\PageConventionCollectionExtensionsTest.cs (56)

Infrastructure\PageActionDescriptorProviderTest.cs (1)

29Assert.Empty(context.Results);

Infrastructure\PageActionEndpointDataSourceTest.cs (1)

46Assert.Empty(endpoints);

Infrastructure\PageActionInvokerProviderTest.cs (2)

144Assert.Empty(pageContext.ValueProviderFactories); 146Assert.Empty(pageContext.ViewStartFactories);

Infrastructure\PageBinderFactoryTest.cs (1)

652Assert.Empty(arguments);

Infrastructure\PageViewLocationExpanderTest.cs (1)

23Assert.Empty(context.Values);

RouteDataTest.cs (6)

17Assert.Empty(routeData.DataTokens); 18Assert.Empty(routeData.Routers); 19Assert.Empty(routeData.Values); 115Assert.Empty(routeData.DataTokens); 117Assert.Empty(routeData.Routers); 119Assert.Empty(routeData.Values);

VirtualPathDataTests.cs (2)

24Assert.Empty(pathData.DataTokens); 61Assert.Empty(pathData.DataTokens);

AnchorTagHelperTest.cs (5)

133Assert.Empty(output.Attributes); 185Assert.Empty(output.Attributes); 243Assert.Empty(output.Attributes); 302Assert.Empty(output.Attributes); 360Assert.Empty(output.Attributes);

FormTagHelperTest.cs (5)

549Assert.Empty(output.Attributes); 673Assert.Empty(output.Attributes); 730Assert.Empty(output.Attributes); 788Assert.Empty(output.Attributes); 842Assert.Empty(output.Attributes);

LinkTagHelperTest.cs (2)

542Assert.Empty(output.Attributes); 561Assert.Empty(output.Attributes);

ScriptTagHelperTest.cs (2)

470Assert.Empty(output.Attributes); 490Assert.Empty(output.Attributes);

ValidationMessageTagHelperTest.cs (2)

284Assert.Empty(output.Attributes); 449Assert.Empty(output.Attributes);

ValidationSummaryTagHelperTest.cs (5)

131Assert.Empty(output.Attributes); 199Assert.Empty(output.Attributes); 386Assert.Empty(output.Attributes); 501Assert.Empty(output.Attributes); 557Assert.Empty(output.Attributes);

AttributeDictionaryTest.cs (2)

76Assert.Empty(attributes); 77Assert.Empty(attributes);

Buffers\ViewBufferTest.cs (1)

287Assert.Empty(nestedItems);

Builder\ControllerActionEndpointConventionBuilderResourceCollectionExtensionsTest.cs (3)

44Assert.Empty(list); 74Assert.Empty(list); 270Assert.Empty(list);

CookieTempDataProviderTest.cs (2)

64Assert.Empty(tempDataDictionary); 88Assert.Empty(tempDataDictionary);

DefaultValidationHtmlAttributeProviderTest.cs (4)

112Assert.Empty(attributes); 145Assert.Empty(attributes); 220Assert.Empty(attributes); 248Assert.Empty(attributes);

Filters\AntiforgeryApplicationModelProviderTest.cs (5)

41Assert.Empty(model.Filters); 68Assert.Empty(controller.Filters); 95Assert.Empty(controller.Filters); 116Assert.Empty(model.Filters); 121Assert.Empty(model.Filters);

Filters\TempDataApplicationModelProviderTest.cs (1)

28Assert.Empty(controller.Filters);

Filters\ViewDataAttributeApplicationModelProviderTest.cs (1)

26Assert.Empty(controller.Filters);

Infrastructure\TempDataSerializerTestBase.cs (1)

21Assert.Empty(tempDataDictionary);

ModelStateDictionaryExtensionsTest.cs (4)

242Assert.Empty(dictionary); 256Assert.Empty(dictionary); 270Assert.Empty(dictionary); 285Assert.Empty(dictionary);

RemoteAttributeTest.cs (2)

81Assert.Empty(attribute.RouteData); 170Assert.Empty(routeDictionary);

SessionStateTempDataProviderTest.cs (1)

55Assert.Empty(tempDataDictionary);

TempDataDictionaryTest.cs (1)

20Assert.Empty(tempData);

ViewComponents\DefaultViewComponentHelperTest.cs (1)

25Assert.Empty(argumentDictionary);

ViewComponentTests.cs (3)

230Assert.Empty(viewComponent.ViewContext.ViewData); 232Assert.Empty(viewComponent.ViewData); 253Assert.Empty(viewComponent.ViewContext.TempData);

ViewDataDictionaryOfTModelTest.cs (1)

26Assert.Empty(viewData);

ViewDataDictionaryTest.cs (2)

26Assert.Empty(viewData); 44Assert.Empty(viewData);

ViewDataOfTTest.cs (4)

56Assert.Empty(viewData); 57Assert.Empty(viewData); 61Assert.Empty(viewData.Keys); 73Assert.Empty(viewData.Values);

AddOpenApiTests.cs (1)

52Assert.Empty(compilation.GetDiagnostics().Where(d => d.Severity > DiagnosticSeverity.Warning));

SnapshotTestHelper.cs (1)

139Assert.Empty(result.Diagnostics.Where(d => d.Severity > DiagnosticSeverity.Warning));

Extensions\OpenApiEndpointRouteBuilderExtensionsTests.cs (1)

240Assert.Empty(result.Diagnostic.Errors);

Extensions\OpenApiRouteHandlerBuilderExtensionTests.cs (1)

59Assert.Empty(operation.Responses);

Services\OpenApiDocumentProviderTests.cs (1)

107Assert.Empty(result.Diagnostic.Errors);

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

123Assert.Empty(servers); 147Assert.Empty(servers);

Services\OpenApiGeneratorTests.cs (28)

Transformers\OpenApiOptionsTests.cs (18)

CachedResponseBodyTests.cs (1)

40Assert.Empty(receivedSegments);

OutputCacheMiddlewareTests.cs (12)

166Assert.Empty(sink.Writes); 286Assert.Empty(sink.Writes); 300Assert.Empty(sink.Writes); 347Assert.Empty(sink.Writes); 415Assert.Empty(sink.Writes); 438Assert.Empty(sink.Writes); 466Assert.Empty(sink.Writes); 492Assert.Empty(sink.Writes); 530Assert.Empty(sink.Writes); 548Assert.Empty(sink.Writes); 570Assert.Empty(sink.Writes); 585Assert.Empty(sink.Writes);

OutputCachePolicyProviderTests.cs (13)

58Assert.Empty(sink.Writes); 107Assert.Empty(sink.Writes); 123Assert.Empty(sink.Writes); 137Assert.Empty(sink.Writes); 155Assert.Empty(sink.Writes); 173Assert.Empty(sink.Writes); 191Assert.Empty(sink.Writes); 219Assert.Empty(sink.Writes); 237Assert.Empty(sink.Writes); 253Assert.Empty(sink.Writes); 347Assert.Empty(sink.Writes); 370Assert.Empty(sink.Writes); 393Assert.Empty(sink.Writes);

OwinEnvironmentTests.cs (1)

203Assert.Empty(owinEnvironment1);

RateLimitingMetricsTests.cs (12)

Runtime\TagHelpers\TagHelperScopeManagerTest.cs (2)

102Assert.Empty(parentExecutionContext.Items); 118Assert.Empty(executionContext.Items);

TagHelpers\TagHelperAttributeListTest.cs (1)

593Assert.Empty(attributes);

TagHelpers\TagHelperContextTest.cs (1)

40Assert.Empty(context.AllAttributes);

TagHelpers\TagHelperOutputTest.cs (2)

48Assert.Empty(output.Attributes); 1085Assert.Empty(output.Attributes);

CachedResponseBodyTests.cs (1)

48Assert.Empty(receivedSegments);

ResponseCachingMiddlewareTests.cs (14)

184Assert.Empty(sink.Writes); 285Assert.Empty(sink.Writes); 297Assert.Empty(sink.Writes); 340Assert.Empty(sink.Writes); 413Assert.Empty(sink.Writes); 428Assert.Empty(sink.Writes); 441Assert.Empty(sink.Writes); 464Assert.Empty(sink.Writes); 489Assert.Empty(sink.Writes); 514Assert.Empty(sink.Writes); 614Assert.Empty(sink.Writes); 632Assert.Empty(sink.Writes); 651Assert.Empty(sink.Writes); 666Assert.Empty(sink.Writes);

ResponseCachingPolicyProviderTests.cs (13)

33Assert.Empty(sink.Writes); 93Assert.Empty(sink.Writes); 137Assert.Empty(sink.Writes); 152Assert.Empty(sink.Writes); 178Assert.Empty(sink.Writes); 279Assert.Empty(sink.Writes); 376Assert.Empty(sink.Writes); 418Assert.Empty(sink.Writes); 460Assert.Empty(sink.Writes); 496Assert.Empty(sink.Writes); 514Assert.Empty(sink.Writes); 555Assert.Empty(sink.Writes); 598Assert.Empty(sink.Writes);

ResponseCompressionMiddlewareTest.cs (2)

1007Assert.Empty(response.Content.Headers.ContentEncoding); 1326Assert.Empty(response.Content.Headers.ContentEncoding);

Builder\OpenApiRouteHandlerBuilderExtensionsTest.cs (1)

68Assert.Empty(metadata.ContentTypes);

ConstraintMatcherTest.cs (5)

40Assert.Empty(sink.Scopes); 43Assert.Empty(sink.Writes); 60Assert.Empty(sink.Scopes); 77Assert.Empty(sink.Scopes); 78Assert.Empty(sink.Writes);

DecisionTreeBuilderTest.cs (7)

18Assert.Empty(tree.Criteria); 19Assert.Empty(tree.Matches); 35Assert.Empty(tree.Criteria); 55Assert.Empty(tree.Matches); 100Assert.Empty(tree.Matches); 152Assert.Empty(tree.Matches); 185Assert.Empty(tree.Matches);

EndpointNameAddressSchemeTest.cs (4)

48Assert.Empty(endpoints); 65Assert.Empty(endpoints); 117Assert.Empty(addressScheme.Entries); 147Assert.Empty(addressScheme.Entries);

EndpointRoutingMiddlewareTest.cs (1)

86Assert.Empty(sink.Scopes);

InlineRouteParameterParserTests.cs (4)

24Assert.Empty(templatePart.InlineConstraints); 36Assert.Empty(templatePart.InlineConstraints); 74Assert.Empty(templatePart.InlineConstraints); 940Assert.Empty(templatePart.InlineConstraints);

Matching\DataSourceDependentMatcherTest.cs (4)

24Assert.Empty(inner.Endpoints); 76Assert.Empty(inner.Endpoints); 93Assert.Empty(inner.Endpoints); 115Assert.Empty(inner.Endpoints);

Matching\DfaMatcherBuilderTest.cs (20)

Matching\DfaMatcherTest.cs (6)

403Assert.Empty(set.candidates); 508Assert.Empty(set.candidates); 702Assert.Empty(cs[0].Values); 707Assert.Empty(cs[1].Values); 749Assert.Empty(cs[0].Values); 754Assert.Empty(cs[1].Values);

Patterns\InlineRouteParameterParserTest.cs (6)

19Assert.Empty(templatePart.ParameterPolicies); 31Assert.Empty(templatePart.ParameterPolicies); 43Assert.Empty(templatePart.ParameterPolicies); 55Assert.Empty(templatePart.ParameterPolicies); 67Assert.Empty(templatePart.ParameterPolicies); 933Assert.Empty(templatePart.ParameterPolicies);

Patterns\RoutePatternMatcherTest.cs (5)

251Assert.Empty(values); 282Assert.Empty(values); 298Assert.Empty(values); 948Assert.Empty(values); 966Assert.Empty(values);

RouteCollectionTest.cs (8)

54Assert.Empty(pathData.DataTokens); 82Assert.Empty(pathData.DataTokens); 120Assert.Empty(pathData.DataTokens); 233Assert.Empty(context.RouteData.Routers); 254Assert.Empty(pathData.DataTokens); 288Assert.Empty(pathData.DataTokens); 395Assert.Empty(pathData.DataTokens); 450Assert.Empty(pathData.DataTokens);

RouterMiddlewareTest.cs (3)

91Assert.Empty(sink.Scopes); 122Assert.Empty(sink.Scopes); 123Assert.Empty(sink.Writes);

RouteTest.cs (35)

RouteValuesAddressSchemeTest.cs (2)

174Assert.Empty(foundEndpoints); 396Assert.Empty(allMatches);

Template\TemplateMatcherTests.cs (5)

250Assert.Empty(values); 281Assert.Empty(values); 297Assert.Empty(values); 947Assert.Empty(values); 965Assert.Empty(values);

Tree\LinkGenerationDecisionTreeTest.cs (2)

159Assert.Empty(matches); 181Assert.Empty(matches);

Tree\TreeRouteBuilderTest.cs (7)

94Assert.Empty(secondSegment.Matches); 126Assert.Empty(secondSegment.Matches); 130Assert.Empty(thirdSegment.Value.Matches); 134Assert.Empty(fourthSegment.Matches); 170Assert.Empty(secondSegment.Matches); 202Assert.Empty(secondSegment.Matches); 234Assert.Empty(secondSegment.Matches);

Tree\TreeRouterTest.cs (33)

AuthenticationTests.cs (3)

40Assert.Empty(response.Headers.WwwAuthenticate); 215Assert.Empty(response.Headers.WwwAuthenticate); 345Assert.Empty(response.Headers.WwwAuthenticate);

Listener\AuthenticationOnExistingQueueTests.cs (1)

70Assert.Empty(response.Headers.WwwAuthenticate);

Listener\ResponseHeaderTests.cs (4)

90Assert.Empty(response.Content.Headers); 119Assert.Empty(response.Content.Headers); 177Assert.Empty(response.Content.Headers); 200Assert.Empty(response.Content.Headers);

ResponseSendFileTests.cs (2)

210Assert.Empty((await response.Content.ReadAsByteArrayAsync())); 273Assert.Empty((await response.Content.ReadAsByteArrayAsync()));

ResponseTrailersTests.cs (5)

35Assert.Empty(response.TrailingHeaders); 53Assert.Empty(response.TrailingHeaders); 74Assert.Empty(response.TrailingHeaders); 142Assert.Empty(response.TrailingHeaders); 219Assert.Empty(response.TrailingHeaders);

Http2\Http2HPackEncoderTests.cs (2)

372Assert.Empty(GetHeaderEntries(hpackEncoder)); 389Assert.Empty(GetHeaderEntries(hpackEncoder));

HttpRequestHeadersTests.cs (3)

25Assert.Empty(headers); 323Assert.Empty(headers); 361Assert.Empty(headers);

HttpResponseHeadersTests.cs (1)

49Assert.Empty(headers);

KestrelServerTests.cs (4)

164Assert.Empty(warnings); 165Assert.Empty(infos); 173Assert.Empty(warnings); 183Assert.Empty(infos);

SniOptionsSelectorTests.cs (1)

910Assert.Empty(propertyNames);

src\Shared\test\Shared.Tests\runtime\Http2\HPackDecoderTest.cs (13)

src\Shared\test\Shared.Tests\runtime\Http3\QPackDecoderTest.cs (1)

297Assert.Empty(_handler.DecodedHeaders);

KestrelConfigurationLoaderTests.cs (8)

85Assert.Empty(serverOptions.GetListenOptions()); 102Assert.Empty(serverOptions.GetListenOptions()); 130Assert.Empty(serverOptions.GetListenOptions()); 1764Assert.Empty(serverOptions.ConfigurationBackedListenOptions); 1777Assert.Empty(serverOptions.ConfigurationBackedListenOptions); 1796Assert.Empty(serverOptions.ConfigurationBackedListenOptions); 1803Assert.Empty(serverOptions.ConfigurationBackedListenOptions); 1882Assert.Empty(serverOptions.GetListenOptions());

SessionTests.cs (1)

827Assert.Empty(sink.Writes);

AdaptiveCapacityDictionaryTests.cs (14)

24Assert.Empty(dict); 25Assert.Empty(dict._arrayStorage); 37Assert.Empty(dict); 38Assert.Empty(dict._arrayStorage); 296Assert.Empty(keys); 327Assert.Empty(values); 467Assert.Empty(dict); 483Assert.Empty(dict); 683Assert.Empty(dict); 703Assert.Empty(dict); 806Assert.Empty(dict); 824Assert.Empty(dict); 891Assert.Empty(dict); 911Assert.Empty(dict);

CommandLineApplicationTests.cs (4)

732Assert.Empty(app.RemainingArguments); 734Assert.Empty(subCmd.RemainingArguments); 753Assert.Empty(app.RemainingArguments); 754Assert.Empty(testCmd.RemainingArguments);

PropertyHelperTest.cs (3)

192Assert.Empty(properties); 639Assert.Empty(dictValues); 653Assert.Empty(dictValues);

QueryStringEnumerableTest.cs (1)

74Assert.Empty(Parse(queryString));

runtime\Http2\HPackDecoderTest.cs (13)

runtime\Http3\QPackDecoderTest.cs (1)

297Assert.Empty(_handler.DecodedHeaders);

SegmentWriteStreamTests.cs (1)

37Assert.Empty(stream.GetSegments());

HubConnectionTests.cs (2)

809Assert.Empty(results); 856Assert.Empty(results);

HubConnectionTests.Tracing.cs (4)

149Assert.Empty(a.Baggage); 182Assert.Empty(a.Baggage); 321Assert.Empty(a.Baggage); 344Assert.Empty(a.Baggage);

HttpConnectionFactoryTests.cs (1)

123Assert.Empty(testValues);

HubConnectionTests.Protocol.cs (1)

262Assert.Empty(await channel.ReadAndCollectAllAsync().DefaultTimeout());

Internal\Protocol\MemoryBufferWriterTests.cs (1)

45Assert.Empty(data);

AddSignalRTests.cs (1)

87Assert.Empty(serviceProvider.GetRequiredService<IOptions<HubOptions<CustomHub>>>().Value.SupportedProtocols);

HubReflectionHelperTests.cs (1)

17Assert.Empty(hubMethods);

Internal\TypedClientBuilderTests.cs (3)

122Assert.Empty(send2.Arguments); 241Assert.Empty(clientProxy.Sends); 270Assert.Empty(send2.Arguments);

StaticFileMiddlewareTests.cs (1)

207Assert.Empty((await response.Content.ReadAsByteArrayAsync()));

DefaultFilesMiddlewareTests.cs (1)

269Assert.Empty((await response.Content.ReadAsByteArrayAsync()));

DirectoryBrowserMiddlewareTests.cs (2)

273Assert.Empty((await response.Content.ReadAsByteArrayAsync())); 373Assert.Empty((await response.Content.ReadAsByteArrayAsync()));

StaticFileMiddlewareTests.cs (1)

484Assert.Empty((await response.Content.ReadAsByteArrayAsync()));

ClientHandlerTests.cs (3)

223Assert.Empty(response.TrailingHeaders); 230Assert.Empty(response.TrailingHeaders); 239Assert.Empty(response.TrailingHeaders);

PagedByteBufferTest.cs (1)

163Assert.Empty(buffer.Pages);

QueryHelpersTests.cs (1)

101Assert.Empty(collection);

CommandLineSwitches_Tests.cs (5)

810Assert.Empty(parameters); 824Assert.Empty(parameters); 853Assert.Empty(parameters); 1316Assert.Empty(actualWarningsAsErrors); 1357Assert.Empty(actualWarningsAsErrors);

Construction\ProjectImportElement_Tests.cs (1)

31Assert.Empty(project.Imports);

Construction\ProjectImportGroupElement_Tests.cs (2)

149Assert.Empty(project.Imports); 169Assert.Empty(project.Imports);

Construction\ProjectItemDefinitionGroupElement_Tests.cs (1)

27Assert.Empty(project.ItemDefinitionGroups);

Construction\ProjectItemElement_Tests.cs (2)

964Assert.Empty(Helpers.MakeList(project.Items)); 996Assert.Empty(Helpers.MakeList(project.Items));

Construction\ProjectItemGroupElement_tests.cs (1)

24Assert.Empty(project.ItemGroups);

Construction\ProjectMetadataElement_Tests.cs (4)

1063Assert.Empty(items[0].Metadata); 1103Assert.Empty(itemDefinitions[0].Metadata); 1174Assert.Empty(items[0].Metadata); 1221Assert.Empty(itemDefinitions[0].Metadata);

Construction\ProjectPropertyGroupElement_Tests.cs (1)

24Assert.Empty(project.PropertyGroups);

Construction\ProjectRootElement_Tests.cs (2)

472Assert.Empty(root2.Items); 1075Assert.Empty(collection.LoadedProjects);

Construction\ProjectTargetElement_Tests.cs (1)

43Assert.Empty(project.Targets);

Construction\ProjectTaskElement_Tests.cs (2)

35Assert.Empty(parameters); 244Assert.Empty(parameters);

Construction\ProjectUsingTaskElement_Tests.cs (1)

28Assert.Empty(project.UsingTasks);

Construction\SolutionFile_Tests.cs (7)

209Assert.Empty(consoleApplication1.Dependencies); 214Assert.Empty(vbClassLibrary.Dependencies); 219Assert.Empty(classLibrary1.Dependencies); 294Assert.Empty(classLibrary1.Dependencies); 300Assert.Empty(myPhysicalFolderClassLibrary1.Dependencies); 305Assert.Empty(classLibrary2.Dependencies); 395Assert.Empty(solution.ProjectsInOrder[2].Dependencies);

Construction\UsingTaskParameterGroup_Tests.cs (1)

68Assert.Empty(parameterGroup.Parameters);

Construction\WhiteSpacePreservation_Tests.cs (1)

515Assert.Empty(Regex.Matches(projectResults, @"\r\n", RegexOptions.Multiline));

Definition\DefinitionEditing_Tests.cs (7)

333Assert.Empty(items); 1193Assert.Empty(Helpers.MakeList(project.GetItems("i"))); 1194Assert.Empty(Helpers.MakeList(project.GetItemsIgnoringCondition("i"))); 1311Assert.Empty(Helpers.MakeList(project.CreateProjectInstance().GetItems("i"))); 1435Assert.Empty(Helpers.MakeList(project.GetItems("i"))); 1445Assert.Empty(itemsIgnoringCondition); 2254Assert.Empty(items);

Definition\ProjectCollection_Tests.cs (7)

53Assert.Empty(ProjectCollection.GlobalProjectCollection.GlobalProperties); 587Assert.Empty(project1.GlobalProperties); 636Assert.Empty(project1.GlobalProperties); 668Assert.Empty(project1.GlobalProperties); 669Assert.Empty(project2.GlobalProperties); 688Assert.Empty(project1.GlobalProperties); 705Assert.Empty(Helpers.MakeList(ProjectCollection.GlobalProjectCollection.LoadedProjects));

Definition\ProjectItem_Tests.cs (1)

2370Assert.Empty(items);

Definition\ProjectItemDefinition_Tests.cs (1)

87Assert.Empty(metadataList);

ObjectModelRemoting\LinkedConstructionModify_Tests.cs (23)

182Assert.Empty(xmlPair.QueryChildrenWithValidation<ProjectTargetElement>((t) => string.Equals(t.Name, NewTargetName))); 186Assert.Empty(xmlPair.QueryChildrenWithValidation<ProjectTargetElement>((t) => string.Equals(t.Name, NewTargetRenamed))); 187Assert.Empty(xmlPair.QueryChildrenWithValidation<ProjectTargetElement>((t) => string.Equals(t.Name, NewTargetName))); 201Assert.Empty(newTarget1.View.Tasks); 207Assert.Empty(newTarget1.View.ItemGroups); 208Assert.Empty(newTarget1.View.PropertyGroups); 383Assert.Empty(choose.View.WhenElements); 417Assert.Empty(when.View.ChooseElements); 421Assert.Empty(when.View.ItemGroups); 425Assert.Empty(when.View.PropertyGroups); 434Assert.Empty(when.View.ChooseElements); 455Assert.Empty(otherwise.View.ChooseElements); 459Assert.Empty(otherwise.View.ItemGroups); 463Assert.Empty(otherwise.View.PropertyGroups); 472Assert.Empty(otherwise.View.ChooseElements); 542Assert.Empty(taskParamGroup.View.Parameters); 600Assert.Empty(importGroup.View.Imports); 614Assert.Empty(itemDef.View.Metadata); 632Assert.Empty(itemDefGrp.View.ItemDefinitions); 670Assert.Empty(item.View.Metadata); 696Assert.Empty(itemGrp.View.Items); 731Assert.Empty(propGrp.View.Properties); 732Assert.Empty(propGrp.View.PropertiesReversed);

ObjectModelRemoting\LinkedSpecialCasesScenarios.cs (1)

173Assert.Empty(newCopyFrom.View.Items);

BackEnd\BuildManager_Tests.cs (6)

1052Assert.Empty(_logger.TargetStartedEvents); 1053Assert.Empty(_logger.TargetFinishedEvents); 1054Assert.Empty(_logger.TaskStartedEvents); 1055Assert.Empty(_logger.TaskFinishedEvents); 3708Assert.Empty(mainInstance.GlobalProperties); 3743Assert.Empty(p2pInstance.GlobalProperties);

BackEnd\BuildRequest_Tests.cs (1)

71Assert.Empty(request.Targets);

BackEnd\IntrinsicTask_Tests.cs (16)

80Assert.Empty(properties); 702Assert.Empty(i1Group); 1630Assert.Empty(lookup.GetItems("i1")); 1648Assert.Empty(lookup.GetItems("i1")); 1711Assert.Empty(lookup.GetItems("i1")); 1730Assert.Empty(lookup.GetItems("i1")); 1749Assert.Empty(lookup.GetItems("i1")); 2303Assert.Empty(p.ItemsToBuildWith["i0"]); 2304Assert.Empty(p.ItemsToBuildWith.ItemTypes); 2336Assert.Empty(p.ItemsToBuildWith["i0"]); 2337Assert.Empty(p.ItemsToBuildWith.ItemTypes); 2410Assert.Empty(p.ItemsToBuildWith["i0"]); 2411Assert.Empty(p.ItemsToBuildWith.ItemTypes); 2454Assert.Empty(p.ItemsToBuildWith["i1"]); 2833Assert.Empty(lookup.GetItems("i1")); 3259Assert.Empty(p.ItemsToBuildWith["i1"]);

BackEnd\LoggingService_Tests.cs (2)

601Assert.Empty(_initializedService.LoggerDescriptions); 650Assert.Empty(loggingService.LoggerDescriptions); // "Expected LoggerDescriptions to be empty"

BackEnd\Lookup_Tests.cs (16)

BackEnd\TargetBuilder_Tests.cs (1)

109Assert.Empty(result["Empty"].Items);

BackEnd\TargetEntry_Tests.cs (6)

173Assert.Empty(deps); 216Assert.Empty(taskBuilder.ExecutedTasks); 363Assert.Empty(results.Items); 380Assert.Empty(results.Items); 400Assert.Empty(results.Items); 473Assert.Empty(results.Items);

BackEnd\TargetResult_Tests.cs (1)

29Assert.Empty(result.Items);

BackEnd\TaskHostTaskComplete_Tests.cs (1)

126Assert.Empty(deserializedComplete.TaskOutputParameters);

BackEnd\TaskRegistry_Tests.cs (2)

1230Assert.Empty(registeredTaskRecords[0].ParameterGroupAndTaskBody.UsingTaskParameters); 1285Assert.Empty(inlineTaskRecord.UsingTaskParameters);

Collections\MultiDictionary_Tests.cs (1)

119Assert.Empty(values);

Collections\OMcollections_tests.cs (6)

57Assert.Empty(properties); 129Assert.Empty(list); 140Assert.Empty(list); 145Assert.Empty(items["j"]); 188Assert.Empty(dictionary); 198Assert.Empty(dictionary);

Construction\SolutionProjectGenerator_Tests.cs (5)

1964Assert.Empty(ProjectCollection.GlobalProjectCollection.LoadedProjects); 1968Assert.Empty(ProjectCollection.GlobalProjectCollection.LoadedProjects); 2025Assert.Empty(ProjectCollection.GlobalProjectCollection.LoadedProjects); 2031Assert.Empty(ProjectCollection.GlobalProjectCollection.LoadedProjects); 2129Assert.Empty(logger.Errors);

Definition\ToolsetConfigurationReader_Tests.cs (3)

52Assert.Empty(msbuildToolsetSection.Toolsets); 87Assert.Empty(msbuildToolsetSection.Toolsets.GetElement(0).AllProjectImportSearchPaths); 187Assert.Empty(msbuildToolsetSection.Toolsets.GetElement(0).AllProjectImportSearchPaths);

Definition\ToolsVersion_Tests.cs (4)

89Assert.Empty(taskoverrideRegistry.TaskRegistrations); 108Assert.Empty(taskoverrideRegistry.TaskRegistrations); 127Assert.Empty(taskoverrideRegistry.TaskRegistrations); 147Assert.Empty(taskoverrideRegistry.TaskRegistrations);

Evaluation\Evaluator_Tests.cs (5)

1764Assert.Empty(project.GetItems("i")); 1845Assert.Empty(project.GetItems("i")); 2239Assert.Empty(project.AllEvaluatedItemDefinitionMetadata); 2262Assert.Empty(project.AllEvaluatedItemDefinitionMetadata); 2263Assert.Empty(project.AllEvaluatedItems);

Evaluation\Expander_Tests.cs (1)

738Assert.Empty(items[5].Metadata);

Evaluation\ExpressionShredder_Tests.cs (3)

518Assert.Empty(messages); 567Assert.Empty(messages); 629Assert.Empty(matches);

Evaluation\ProjectSdkImplicitImport_Tests.cs (1)

335Assert.Empty(project.Imports);

ExpressionTree_Tests.cs (1)

344Assert.Empty(conditionedProperties);

TypeLoader_Tests.cs (1)

206Assert.Empty(Directory.EnumerateFiles(tempDirectoryPath));

AssemblyDependency\ResolveAssemblyReferenceTestFixture.cs (5)

3040Assert.Empty(t.ResolvedDependencyFiles); 3041Assert.Empty(t.SatelliteFiles); 3042Assert.Empty(t.RelatedFiles); 3043Assert.Empty(t.SuggestedRedirects); 3044Assert.Empty(t.FilesWritten);

AssemblyDependency\SuggestedRedirects.cs (5)

208Assert.Empty(t.SuggestedRedirects); 253Assert.Empty(t.SuggestedRedirects); 293Assert.Empty(t.SuggestedRedirects); 416Assert.Empty(t.SuggestedRedirects); 459Assert.Empty(t.SuggestedRedirects);

AssignCulture_Tests.cs (1)

176Assert.Empty(t.AssignedFilesWithCulture);

AssignLinkMetadata_Tests.cs (5)

35Assert.Empty(t.OutputItems); 56Assert.Empty(t.OutputItems); 126Assert.Empty(t.OutputItems); 148Assert.Empty(t.OutputItems); 168Assert.Empty(t.OutputItems);

Copy_Tests.cs (1)

728Assert.Empty(t.CopiedFiles);

CreateItem_Tests.cs (4)

60Assert.Empty(t.Include); 115Assert.Empty(t.Include); 130Assert.Empty(t.Include); 149Assert.Empty(t.Include);

Exec_Tests.cs (4)

127Assert.Empty(tempFiles); 140Assert.Empty(tempFiles); 838Assert.Empty(exec.Outputs); 922Assert.Empty(exec.ConsoleOutput);

Hash_Tests.cs (1)

101Assert.Empty(hashGroups);

MakeDir_Tests.cs (1)

253Assert.Empty(t.DirectoriesCreated);

MockUnmanagedMemoryHelper.cs (1)

110Assert.Empty(_allocatedHandles);

Move_Tests.cs (1)

146Assert.Empty(t.MovedFiles);

ReadLinesFromFile_Tests.cs (1)

162Assert.Empty(r.Lines);

RemoveDuplicates_Tests.cs (1)

150Assert.Empty(t.Filtered);

ResolveNonMSBuildProjectOutput_Tests.cs (6)

258Assert.Empty(resolvedOutputs); // "No resolved refs expected for case 1" 290Assert.Empty(unresolvedOutputs); // "No unresolved refs expected for case 3" 302Assert.Empty(resolvedOutputs); // "No resolved refs expected for case 4" 303Assert.Empty(unresolvedOutputs); // "No unresolved refs expected for case 4" 317Assert.Empty(unresolvedOutputs); // "No unresolved refs expected for case 5" 328Assert.Empty(resolvedOutputs); // "No resolved refs expected for case 6"

ResolveSDKReference_Tests.cs (13)

74Assert.Empty(ResolveSDKReference.ParseDependsOnSDK(null)); 75Assert.Empty(ResolveSDKReference.ParseDependsOnSDK(String.Empty)); 76Assert.Empty(ResolveSDKReference.ParseDependsOnSDK(";;")); 77Assert.Empty(ResolveSDKReference.ParseDependsOnSDK("; ;")); 102Assert.Empty(result); 112Assert.Empty(result); 1314Assert.Empty(t.ResolvedSDKReferences); 1391Assert.Empty(t.ResolvedSDKReferences); 1481Assert.Empty(t.ResolvedSDKReferences); 2429Assert.Empty(t.ResolvedSDKReferences); 3404Assert.Empty(t.ResolvedSDKReferences); 3546Assert.Empty(t.ResolvedSDKReferences); 3682Assert.Empty(t.ResolvedSDKReferences);

ResourceHandling\GenerateResource_Tests.cs (5)

2794Assert.Empty(t.FilesWritten); 2887Assert.Empty(t.FilesWritten); 2924Assert.Empty(t.FilesWritten); 2961Assert.Empty(t.FilesWritten); 3006Assert.Empty(t.FilesWritten);

src\Analyzers\CSharp\Tests\NamingStyles\NamingStylesTests.cs (3)

1441Assert.Empty(previewOperations.OfType<TestSymbolRenamedCodeActionOperationFactoryWorkspaceService.Operation>()); 1466Assert.Empty(previewOperations.OfType<TestSymbolRenamedCodeActionOperationFactoryWorkspaceService.Operation>()); 1496Assert.Empty(previewOperations.OfType<TestSymbolRenamedCodeActionOperationFactoryWorkspaceService.Operation>());

src\Analyzers\CSharp\Tests\UpgradeProject\UpgradeProjectTests.cs (2)

51Assert.Empty(changedDocs); 63Assert.Empty(actions);

CodeGeneration\SyntaxGeneratorTests.cs (2)

51Assert.Empty(diagnostics); 81Assert.Empty(diagnostics);

Completion\ArgumentProviders\ArgumentProviderOrderTests.cs (3)

68Assert.Empty(orderedCSharpArgumentProviders[i].Metadata.BeforeTyped); 69Assert.Empty(orderedCSharpArgumentProviders[i].Metadata.AfterTyped); 74Assert.Empty(orderedCSharpArgumentProviders[i].Metadata.BeforeTyped);

Completion\CompletionProviders\CompletionProviderOrderTests.cs (3)

100Assert.Empty(orderedCSharpCompletionProviders[i].Metadata.BeforeTyped); 101Assert.Empty(orderedCSharpCompletionProviders[i].Metadata.AfterTyped); 106Assert.Empty(orderedCSharpCompletionProviders[i].Metadata.BeforeTyped);

Completion\CompletionProviders\OperatorCompletionProviderTests.cs (1)

299Assert.Empty(items);

Diagnostics\DiagnosticAnalyzerDriver\DiagnosticAnalyzerDriverTests.cs (1)

158Assert.Empty(exceptions);

Intents\IntentTestsBase.cs (1)

35Assert.Empty(results);

Interactive\NavigateTo\InteractiveNavigateToTests.cs (3)

34Assert.Empty(await _aggregator.GetItemsAsync("Hello")); 692Assert.Empty(items); 735Assert.Empty(items);

NavigateTo\NavigateToTests.cs (5)

34Assert.Empty(await _aggregator.GetItemsAsync("Hello")); 375Assert.Empty(await _aggregator.GetItemsAsync("ar")); 410Assert.Empty(await _aggregator.GetItemsAsync("ar")); 1097Assert.Empty(items); 1135Assert.Empty(items);

PdbSourceDocument\AbstractPdbSourceDocumentTests.cs (1)

326Assert.Empty(result.Diagnostics.Where(d => d.Severity == DiagnosticSeverity.Error));

Workspaces\WorkspaceTests_EditorFeatures.cs (6)

361Assert.Empty(workspace.CurrentSolution.Projects); 393Assert.Empty(workspace.CurrentSolution.Projects.Single().Documents); 1194Assert.Empty(workspace.GetOpenDocumentIds()); 1199Assert.Empty(workspace.GetOpenDocumentIds()); 1223Assert.Empty(workspace.GetOpenDocumentIds()); 1228Assert.Empty(workspace.GetOpenDocumentIds());

EmbeddedLanguages\RegularExpressions\CSharpRegexParserTests_RealWorld.cs (2)

26Assert.Empty(tree.Diagnostics); 34Assert.Empty(tree.Diagnostics);

BreakingChanges.cs (1)

221Assert.Empty(tree.GetDiagnostics());

CodeGen\CodeGenAsyncIteratorTests.cs (1)

1173Assert.Empty(GetAttributeNames(method.GetAttributes()));

CodeGen\CodeGenDeconstructTests.cs (16)

CodeGen\CodeGenReadonlyStructTests.cs (1)

912Assert.Empty(s1.GetAttributes());

CodeGen\CodeGenTupleTest.cs (4)

5823Assert.Empty(ElementTypeNames(tupleWithoutNames)); 27980Assert.Empty(retargetingValueTupleType.GetFieldsToEmit()); 27992Assert.Empty(type.GetFieldsToEmit()); 28075Assert.Empty(type.GetFieldsToEmit());

Emit\CompilationEmitTests.cs (1)

4641Assert.Empty(result.Diagnostics);

Emit\EntryPointTests.cs (1)

1598Assert.Empty(model.GetDiagnostics());

Emit\InAttributeModifierTests.cs (1)

51Assert.Empty(m.Parameters[0].GetAttributes());

Emit\NoPiaEmbedTypes.cs (2)

3197Assert.Empty(m1.GetAttributes()); 3261Assert.Empty(m1.GetAttributes());

Emit\EditAndContinue\EditAndContinueTests.cs (1)

12680Assert.Empty(pdbReader.CustomDebugInformation.Select(cdi => pdbReader.GetGuid(pdbReader.GetCustomDebugInformation(cdi).Kind)));

Attributes\AttributeTests.cs (5)

776Assert.Empty(result.Arguments); 786Assert.Empty(result.Arguments); 1927Assert.Empty(GetAttributeStrings(attributes3)); 1989Assert.Empty(GetAttributeStrings(attributes3)); 2274Assert.Empty(GetAttributeStrings(field3.GetAttributes()));

Attributes\AttributeTests_Assembly.cs (16)

Attributes\AttributeTests_Dynamic.cs (3)

525Assert.Empty(synthesizedDynamicAttributes); 533Assert.Empty(dynamicAttribute.AttributeConstructor.Parameters); 534Assert.Empty(dynamicAttribute.CommonConstructorArguments);

Attributes\AttributeTests_IsByRefLike.cs (1)

1043Assert.Empty(peType.GetAttributes());

Attributes\AttributeTests_RefReadOnly.cs (5)

313Assert.Empty(property.GetAttributes()); 342Assert.Empty(property.GetAttributes()); 378Assert.Empty(property.GetAttributes()); 1386Assert.Empty(result.CandidateSymbols); 1428Assert.Empty(result.CandidateSymbols);

Attributes\AttributeTests_Synthesized.cs (6)

66Assert.Empty(attribute.CommonNamedArguments); 76Assert.Empty(attribute.AttributeConstructor.Parameters); 77Assert.Empty(attribute.CommonConstructorArguments); 94Assert.Empty(attribute.CommonNamedArguments); 234Assert.Empty(peModule.GetCustomAttributesForToken(((PEMethodSymbol)q.GetMethod).Handle)); 235Assert.Empty(peModule.GetCustomAttributesForToken(((PEMethodSymbol)q.SetMethod).Handle));

Attributes\AttributeTests_Tuples.cs (1)

622Assert.Empty(synthesizedTupleElementNamesAttr);

Attributes\InternalsVisibleToAndStrongNameTests.cs (9)

184Assert.Empty(comp.GetDiagnostics()); 313Assert.Empty(comp.GetDiagnostics()); 359Assert.Empty(comp.GetDiagnostics()); 839Assert.Empty(c2.GetDiagnostics()); 888Assert.Empty(c2.GetDiagnostics()); 921Assert.Empty(requestor.GetDiagnostics()); 1110Assert.Empty(requestor.GetDiagnostics()); 1275Assert.Empty(requestor.GetDiagnostics()); 1388Assert.Empty(requestor.GetDiagnostics());

Diagnostics\DiagnosticAnalyzerTests.cs (9)

381Assert.Empty(diagIds); 3271Assert.Empty(analysisResult.SyntaxDiagnostics); 3272Assert.Empty(analysisResult.SemanticDiagnostics); 3317Assert.Empty(analysisResult.SyntaxDiagnostics); 3318Assert.Empty(analysisResult.SemanticDiagnostics); 3362Assert.Empty(analyzer2.SymbolsStarted); 3363Assert.Empty(tree1SemanticDiagnostics); 3993Assert.Empty(diagnostics); 4234Assert.Empty(analyzer.CanceledCompilations);

Diagnostics\GetDiagnosticsTests.cs (22)

FlowAnalysis\FlowDiagnosticTests.cs (2)

514Assert.Empty(this.FlowDiagnostics(comp).Where(e => e.Severity >= DiagnosticSeverity.Error)); 552Assert.Empty(this.FlowDiagnostics(comp).Where(e => e.Severity >= DiagnosticSeverity.Error));

FlowAnalysis\IterationJumpYieldStatementTests.cs (2)

1102Assert.Empty(controlFlowAnalysisResults.EntryPoints); 1351Assert.Empty(ctrlFlowAnalysis.ExitPoints);

FlowAnalysis\RegionAnalysisTests.cs (47)

FlowAnalysis\TryLockUsingStatementTests.cs (5)

48Assert.Empty(controlFlowAnalysisResults.EntryPoints); 49Assert.Empty(controlFlowAnalysisResults.ExitPoints); 50Assert.Empty(controlFlowAnalysisResults.ReturnStatements); 1513Assert.Empty(analysisControlFlow.EntryPoints); 1514Assert.Empty(analysisControlFlow.ExitPoints);

RefReadonlyParameterTests.cs (2)

70Assert.Empty(parameter.GetAttributes()); 76Assert.Empty(parameter.RefCustomModifiers);

Semantics\ExtensionTests.cs (45)

Semantics\InlineArrayTests.cs (6)

2529Assert.Empty(symbolInfo.CandidateSymbols); 6220Assert.Empty(symbolInfo.CandidateSymbols); 8128Assert.Empty(symbolInfo.CandidateSymbols); 8856Assert.Empty(symbolInfo.CandidateSymbols); 10568Assert.Empty(symbolInfo.CandidateSymbols); 11312Assert.Empty(symbolInfo.CandidateSymbols);

Semantics\OutVarTests.cs (4)

1011Assert.Empty(symbolInfo.CandidateSymbols); 18450Assert.Empty(group); // https://github.com/dotnet/roslyn/issues/24936 20827Assert.Empty(GetOutVarDeclarations(tree, "x1")); 20957=> Assert.Empty(decl.Ancestors().OfType<VariableDeclaratorSyntax>());

Semantics\ParamsCollectionTests.cs (15)

242Assert.Empty(attributeData1.ConstructorArguments); 358Assert.Empty(attributeData1.ConstructorArguments); 540Assert.Empty(attributeData1.ConstructorArguments); 686Assert.Empty(attributeData1.ConstructorArguments); 1430Assert.Empty(attributeData1.ConstructorArguments); 2554Assert.Empty(attributeData1.ConstructorArguments); 2690Assert.Empty(attributeData1.ConstructorArguments); 2747Assert.Empty(((NamespaceSymbol)m.GlobalNamespace.GetMember("System.Runtime.CompilerServices")).GetMembers("ParamCollectionAttribute")); 2949Assert.Empty(((NamespaceSymbol)m.GlobalNamespace.GetMember("System.Runtime.CompilerServices")).GetMembers("ParamCollectionAttribute")); 9033Assert.Empty(p1.GetAttributes()); 9040Assert.Empty(p1.GetAttributes()); 12836Assert.Empty(((NamespaceSymbol)m.GlobalNamespace.GetMember("System.Runtime.CompilerServices")).GetMembers("ParamCollectionAttribute")); 13168Assert.Empty(((NamespaceSymbol)module.GlobalNamespace.GetMember("System.Runtime.CompilerServices")).GetMembers("ParamCollectionAttribute")); 13228Assert.Empty(((NamespaceSymbol)module.GlobalNamespace.GetMember("System.Runtime.CompilerServices")).GetMembers("ParamCollectionAttribute")); 13291Assert.Empty(((NamespaceSymbol)module.GlobalNamespace.GetMember("System.Runtime.CompilerServices")).GetMembers("ParamCollectionAttribute"));

Semantics\PatternMatchingTestBase.cs (3)

353=> Assert.Empty(decl.Ancestors().OfType<VariableDeclaratorSyntax>()); 427Assert.Empty(tree.GetRoot().DescendantNodes().OfType<GlobalStatementSyntax>()); 448Assert.Empty(info.CandidateSymbols);

Semantics\PatternMatchingTests4.cs (1)

1025Assert.Empty(symbolInfo.CandidateSymbols);

Semantics\PatternMatchingTests5.cs (2)

1246Assert.Empty(xSymbol.CandidateSymbols); 1254Assert.Empty(ySymbol.CandidateSymbols);

Semantics\PrimaryConstructorTests.cs (70)

Semantics\RecordTests.cs (28)

Symbols\UserDefinedCompoundAssignmentOperatorsTests.cs (52)

EditAndContinue\CSharpEditAndContinueAnalyzerTests.cs (2)

678Assert.Empty(result.Single().RudeEdits); 724Assert.Empty(result.Single().RudeEdits);

SemanticSearch\CSharpSemanticSearchServiceTests.cs (6)

81Assert.Empty(compileResult.CompilationErrors); 308Assert.Empty(compileResult.CompilationErrors); 313Assert.Empty(exceptions); 357Assert.Empty(compileResult.CompilationErrors); 426Assert.Empty(compileResult.CompilationErrors); 487Assert.Empty(compileResult.CompilationErrors);

src\Analyzers\CSharp\Tests\NamingStyles\NamingStylesTests.cs (3)

1441Assert.Empty(previewOperations.OfType<TestSymbolRenamedCodeActionOperationFactoryWorkspaceService.Operation>()); 1466Assert.Empty(previewOperations.OfType<TestSymbolRenamedCodeActionOperationFactoryWorkspaceService.Operation>()); 1496Assert.Empty(previewOperations.OfType<TestSymbolRenamedCodeActionOperationFactoryWorkspaceService.Operation>());

src\Analyzers\CSharp\Tests\UpgradeProject\UpgradeProjectTests.cs (2)

51Assert.Empty(changedDocs); 63Assert.Empty(actions);

IOperation\IOperationTests_IVariableDeclaration.cs (1)

676Assert.Empty(operation.ChildOperations);

InteractiveSessionReferencesTests.cs (4)

49Assert.Empty(diagnostics); 105Assert.Empty(diagnostics0); 143Assert.Empty(diagnostics0); 151Assert.Empty(diagnostics1);

InteractiveSessionTests.cs (3)

1185Assert.Empty(scope.Aliases); 1186Assert.Empty(scope.ExternAliases); 1187Assert.Empty(scope.XmlNamespaces);

Semantics\AccessCheckTests.cs (4)

985Assert.Empty(other.GetDiagnostics()); 995Assert.Empty(c.GetDiagnostics()); 1005Assert.Empty(other.GetDiagnostics()); 1038Assert.Empty(c.GetDiagnostics());

Semantics\DeconstructionTests.cs (60)

Semantics\DelegateTypeTests.cs (1)

1467Assert.Empty(model.GetMemberGroup(expr));

Semantics\FunctionPointerTests.cs (1)

3969Assert.Empty(semanticInfo.CandidateSymbols);

Semantics\GlobalUsingDirectiveTests.cs (2)

3172Assert.Empty(comp2.UsageOfUsingsRecordedInTrees); 3281Assert.Empty(comp2.UsageOfUsingsRecordedInTrees);

Semantics\InitOnlyMemberTests.cs (1)

3991Assert.Empty(property0.RefCustomModifiers);

Semantics\LocalFunctionTests.cs (6)

510Assert.Empty(returnAttributes); 562Assert.Empty(returnAttributes); 825Assert.Empty(attributes); 1445Assert.Empty(comp.GetDeclarationDiagnostics()); 1783Assert.Empty(model.LookupNamespacesAndTypes(a.SpanStart, name: "A")); 1858Assert.Empty(model.LookupNamespacesAndTypes(a.SpanStart, name: "A"));

Semantics\LookupTests.cs (5)

247Assert.Empty(actual_lookupSymbols); 1456Assert.Empty(globalNS.GetMembers("Y")); 1457Assert.Empty(globalNS.GetMembers("Z")); 1458Assert.Empty(globalNS.GetMembers("StaticZ")); 1459Assert.Empty(globalNS.GetMembers("B"));

Semantics\NameOfTests.cs (1)

3066Assert.Empty(typeofType.GetMembers("Count"));

Semantics\NativeIntegerTests.cs (2)

304Assert.Empty(nativeIntegerType.GetTypeMembers()); 413Assert.Empty(nativeIntegerType.GetTypeMembers());

Semantics\NullableReferenceTypesTests.cs (110)

Semantics\NullConditionalAssignmentTests.cs (9)

2450Assert.Empty(analysis.AlwaysAssigned); 2452Assert.Empty(analysis.WrittenInside); 2456Assert.Empty(analysis.AlwaysAssigned); 2457Assert.Empty(analysis.ReadInside); 2458Assert.Empty(analysis.WrittenInside); 2484Assert.Empty(analysis.AlwaysAssigned); 2486Assert.Empty(analysis.WrittenInside); 2490Assert.Empty(analysis.AlwaysAssigned); 2492Assert.Empty(analysis.WrittenInside);

Semantics\OverloadResolutionTests.cs (2)

2302Assert.Empty(cCommon.GetDiagnostics()); 2308Assert.Empty(cCS.GetDiagnostics());

Semantics\QueryTests.cs (1)

2399Assert.Empty(symbolInfoForSelect.CandidateSymbols);

Semantics\RecordStructTests.cs (1)

3323Assert.Empty(symbolInfo.CandidateSymbols);

Semantics\ScriptSemanticsTests.cs (1)

510Assert.Empty(model.LookupLabels(source.Length - 1)); // Used to assert.

Semantics\TopLevelStatementsTests.cs (21)

Semantics\VarianceTests.cs (2)

121Assert.Empty(errors); 237Assert.Empty(errors);

SourceGeneration\AdditionalSourcesCollectionTests.cs (1)

215Assert.Empty(sources);

SourceGeneration\GeneratorDriverTests.cs (47)

SourceGeneration\StateTableTests.cs (6)

793Assert.Empty(step.Inputs); 798Assert.Empty(step.Inputs); 803Assert.Empty(step.Inputs); 808Assert.Empty(step.Inputs); 813Assert.Empty(step.Inputs); 818Assert.Empty(step.Inputs);

SourceGeneration\SyntaxAwareGeneratorTests.cs (29)

Compilation\CompilationAPITests.cs (3)

628Assert.Empty(comp.GetDiagnostics()); 696Assert.Empty(comp.GetDiagnostics()); 3408Assert.Empty(types);

Compilation\GetImportScopesTests.cs (60)

Compilation\GetSemanticInfoBrokenCodeTests.cs (1)

200Assert.Empty(tree.GetCompilationUnitRoot().DescendantNodes().OfType<UsingDirectiveSyntax>());

Compilation\LoadDirectiveTests.cs (2)

170Assert.Empty(compilation.SyntaxTrees); 190Assert.Empty(compilation.SyntaxTrees);

Compilation\SemanticModelAPITests.cs (6)

147Assert.Empty(symbolInfo.CandidateSymbols); 157Assert.Empty(symbolInfo.CandidateSymbols); 1372Assert.Empty(method.Parameters); 2088Assert.Empty(method.Parameters); 4542Assert.Empty(symbolInfo.CandidateSymbols); 4620Assert.Empty(symbolInfo.CandidateSymbols);

Compilation\SemanticModelGetSemanticInfoTests.cs (5)

278Assert.Empty(semanticInfo.CandidateSymbols); 8021Assert.Empty(semanticInfo.CandidateSymbols); 8074Assert.Empty(semanticInfo.CandidateSymbols); 9279Assert.Empty(type.Interfaces); 9281Assert.Empty(type.GetMembers());

Compilation\UsedAssembliesTests.cs (6)

38Assert.Empty(comp1.GetUsedAssemblyReferences()); 72Assert.Empty(comp1.GetUsedAssemblyReferences()); 105Assert.Empty(used.Where(r => r.Properties.Kind == MetadataImageKind.Module)); 329Assert.Empty(used.Where(r => r.Properties.Kind == MetadataImageKind.Module)); 399Assert.Empty(comp1.GetUsedAssemblyReferences()); 433Assert.Empty(comp1.GetUsedAssemblyReferences());

DocumentationComments\CrefTests.cs (3)

6641Assert.Empty(model.LookupSymbols(name.SpanStart, typeParameter, "GetAwaiter")); 6766Assert.Empty(cref.Parameters.Parameters); 6809Assert.Empty(cref.Parameters.Parameters);

DocumentationComments\DocumentationCommentCompilerTests.cs (4)

6915Assert.Empty(comp.GetDeclarationDiagnostics()); 6916Assert.Empty(comp.GetMethodBodyDiagnostics()); 6936Assert.Empty(comp.GetParseDiagnostics()); 6937Assert.Empty(comp.GetDeclarationDiagnostics());

Symbols\AccessorOverriddenOrHiddenMembersTests.cs (2)

1036Assert.Empty(methodDispose.Parameters); 1040Assert.Empty(methodDispose.ExplicitInterfaceImplementations);

Symbols\ConversionTests.cs (1)

811Assert.Empty(diagnostics);

Symbols\DefaultInterfaceImplementationTests.cs (5)

18363Assert.Empty(implementingProperty.ExplicitInterfaceImplementations); 44654Assert.Empty(compilation1.GetTypeByMetadataName("I1").GetMembers("I1")); 67154Assert.Empty(i1.GetMembers().OfType<MethodSymbol>().Single().ExplicitInterfaceImplementations); 67337Assert.Empty(m.ExplicitInterfaceImplementations); 67525Assert.Empty(m.ExplicitInterfaceImplementations);

Symbols\ExtensionMethodTests.cs (4)

3918Assert.Empty(model.LookupSymbols(instance.Position, baseClass, "SetMember", includeReducedExtensionMethods: true)); 3919Assert.Empty(model.LookupSymbols(instance.Position, baseClass, includeReducedExtensionMethods: true).Where(s => s.Name == "SetMembers")); 4013Assert.Empty(model.LookupSymbols(instance.Position, baseClass, "SetMember", includeReducedExtensionMethods: true)); 4014Assert.Empty(model.LookupSymbols(instance.Position, baseClass, includeReducedExtensionMethods: true).Where(s => s.Name == "SetMembers"));

Symbols\FunctionPointerTypeSymbolTests.cs (1)

401Assert.Empty(sixthParamParam.Parameters);

Symbols\IndexerTests.cs (2)

2139Assert.Empty(peIndexer.GetAttributes()); 2140Assert.Empty(((PEModuleSymbol)module).GetCustomAttributesForToken(peIndexer.Handle));

Symbols\Metadata\MetadataMemberTests.cs (11)

178Assert.Empty(compilation.GetDeclarationDiagnostics()); 229Assert.Empty(compilation.GetDeclarationDiagnostics()); 291Assert.Empty(compilation.GetDeclarationDiagnostics()); 336Assert.Empty(compilation.GetDeclarationDiagnostics()); 381Assert.Empty(compilation.GetDeclarationDiagnostics()); 737Assert.Empty(c.GetMembers("P2")); 738Assert.Empty(c.GetMembers("P3")); 745Assert.Empty(c.GetMembers("P3")); 759Assert.Empty(c.GetMembers("P3")); 800Assert.Empty(c.GetMembers("P3")); 814Assert.Empty(c.GetMembers("P3"));

Symbols\Metadata\MetadataTypeTests.cs (6)

60Assert.Empty(compilation.GetDeclarationDiagnostics()); 110Assert.Empty(compilation.GetDeclarationDiagnostics()); 160Assert.Empty(compilation.GetDeclarationDiagnostics()); 208Assert.Empty(compilation.GetDeclarationDiagnostics()); 256Assert.Empty(compilation.GetDeclarationDiagnostics()); 341Assert.Empty(compilation2.GetDeclarationDiagnostics());

Symbols\Metadata\PE\LoadingAttributes.cs (1)

1313Assert.Empty(parameter.GetAttributes());

Symbols\OverriddenOrHiddenMembersTests.cs (2)

1136Assert.Empty(comp.GetDiagnostics()); 1154Assert.Empty(comp.GetDiagnostics());

Symbols\PartialPropertiesTests.cs (1)

5176Assert.Empty(symbolInfo.CandidateSymbols);

Symbols\RequiredMembersTests.cs (4)

7187Assert.Empty(field1.GetAttributes()); 7188Assert.Empty(property1.GetAttributes()); 7190Assert.Empty(field2.GetAttributes()); 7191Assert.Empty(property2.GetAttributes());

Symbols\Retargeting\RetargetCustomAttributes.cs (2)

110Assert.Empty(symbol.GetAttributes(oldMsCorLib_debuggerTypeProxyAttributeType)); 116Assert.Empty(symbol.GetAttributes(oldMsCorLib_debuggerTypeProxyAttributeType));

Symbols\Source\BaseClassTests.cs (1)

1498Assert.Empty(diags);

Symbols\Source\ExternAliasTests.cs (1)

443Assert.Empty(firstTarget.GetMembers());

Symbols\Source\FileModifierTests.cs (14)

2603Assert.Empty(symbolInfo.CandidateSymbols); 2642Assert.Empty(symbolInfo.CandidateSymbols); 3673Assert.Empty(symbols); 3717Assert.Empty(info.CandidateSymbols); 3725Assert.Empty(symbols); 3735Assert.Empty(symbols); 3745Assert.Empty(symbols); 3822Assert.Empty(info.CandidateSymbols); 3826Assert.Empty(symbols); 3982Assert.Empty(symbolInfo.CandidateSymbols); 4293Assert.Empty(comp.GetTypesByMetadataName("C")); 4320Assert.Empty(comp.GetTypesByMetadataName("C")); 4335Assert.Empty(comp.GetTypesByMetadataName($"<>F{checksum}__C")); 4338Assert.Empty(comp.GetTypesByMetadataName($"<WrongName>F{checksum}__C"));

Symbols\Source\MethodTests.cs (2)

1430Assert.Empty(comp.GetDeclarationDiagnostics()); 1645Assert.Empty(c1.GetMembers("@float"));

Symbols\Source\NullablePublicAPITests.cs (1)

2667Assert.Empty(symbolInfo.CandidateSymbols);

Symbols\Source\PropertyTests.cs (3)

1656Assert.Empty(diagnostics); 1693Assert.Empty(diagnostics); 1728Assert.Empty(diagnostics);

Symbols\StaticAbstractMembersInInterfacesTests.cs (64)

Symbols\TypeTests.cs (8)

1386Assert.Empty(comp.GetDiagnostics()); 1407Assert.Empty(comp.GetDiagnostics()); 2350Assert.Empty(m1.UnmanagedCallingConventionTypes); 2355Assert.Empty(m2.UnmanagedCallingConventionTypes); 2360Assert.Empty(m3.UnmanagedCallingConventionTypes); 2398Assert.Empty(m1.UnmanagedCallingConventionTypes); 2403Assert.Empty(m2.UnmanagedCallingConventionTypes); 2408Assert.Empty(m3.UnmanagedCallingConventionTypes);

Diagnostics\LocationsTests.cs (1)

242Assert.Empty(InspectLineMapping(syntaxTree));

IncrementalParsing\IncrementalParsingTests.cs (6)

562Assert.Empty(tree.GetDiagnostics()); 576Assert.Empty(tree.GetDiagnostics()); 579Assert.Empty(fullTree.GetDiagnostics()); 615Assert.Empty(initialTree.GetDiagnostics()); 840Assert.Empty(withCloseBraceDeletedTree.GetDiagnostics()); 843Assert.Empty(fullTree.GetDiagnostics());

LexicalAndXml\LexicalTests.cs (7)

457Assert.Empty(token.LeadingTrivia); 458Assert.Empty(token.TrailingTrivia); 475Assert.Empty(token.Errors()); 484Assert.Empty(token.LeadingTrivia); 518Assert.Empty(token.LeadingTrivia); 584Assert.Empty(token.GetTrailingTrivia()); 3822Assert.Empty(diagnostics);

LexicalAndXml\PreprocessorTests.cs (2)

112Assert.Empty(node.GetDiagnostics()); 3891Assert.Empty(comp.GetParseDiagnostics());

LexicalAndXml\RawStringLiteralLexingTests.cs (1)

201Assert.Empty(token.GetDiagnostics());

LexicalAndXml\SyntaxTokenParserTests.cs (18)

Parsing\IgnoredDirectiveParsingTests.cs (2)

127Assert.Empty(structure.EndOfDirectiveToken.GetLeadingTrivia()); 149Assert.Empty(structure.EndOfDirectiveToken.GetLeadingTrivia());

Parsing\LocalFunctionParsingTests.cs (2)

1354Assert.Empty(s1.ParameterList.Parameters); 1364Assert.Empty(s1.ParameterList.Parameters);

Parsing\ParsingErrorRecoveryTests.cs (1)

7576Assert.Empty(syntaxTree.GetDiagnostics());

Parsing\RecordParsing.cs (1)

342Assert.Empty(comp.GetTypeByMetadataName("P").GetMembers());

Parsing\ScriptParsingTests.cs (4)

45Assert.Empty(actualErrors); 9636Assert.Empty(root.ChildNodes()); 9647Assert.Empty(root.ChildNodes()); 9710Assert.Empty(root.ChildNodes());

Syntax\SyntaxAnnotationTests.cs (2)

136Assert.Empty(matchingNodesOrTokens); 146Assert.Empty(matchingTrivia);

Syntax\SyntaxTests.cs (2)

325Assert.Empty(returnedKindsInts); 343Assert.Empty(returnedKindsInts);

FunctionPointerUtilities.cs (18)

47Assert.Empty(symbol.Locations); 48Assert.Empty(symbol.DeclaringSyntaxReferences); 50Assert.Empty(symbol.GetTypeMembers()); 51Assert.Empty(symbol.InterfacesNoUseSiteDiagnostics()); 94Assert.Empty(symbol.TypeParameters); 95Assert.Empty(symbol.ExplicitInterfaceImplementations); 96Assert.Empty(symbol.Locations); 97Assert.Empty(symbol.DeclaringSyntaxReferences); 98Assert.Empty(symbol.TypeArgumentsWithAnnotations); 99Assert.Empty(symbol.GetAppliedConditionalSymbols()); 100Assert.Empty(symbol.ReturnNotNullIfParameterNotNull); 129Assert.Empty(symbol.Locations); 130Assert.Empty(symbol.DeclaringSyntaxReferences); 131Assert.Empty(symbol.NotNullIfParameterNotNull); 184Assert.Empty(semanticInfo.MemberGroup); 218Assert.Empty(semanticInfo.CandidateSymbols); 231Assert.Empty(semanticInfo.CandidateSymbols); 260Assert.Empty(semanticInfo.CandidateSymbols);

CodeGeneration\AddImportsTests.cs (1)

795Assert.Empty(compilerDiagnostics.Where(d => d.Severity == DiagnosticSeverity.Error));

CodeGeneration\SyntaxGeneratorTests.cs (3)

2051Assert.Empty(initialAttributes); 2059Assert.Empty(attrsRemoved); 3747Assert.Empty(baseListN);

Completion\AbstractCompletionProviderTests.cs (1)

220Assert.Empty(items);

Rename\RenamerTests.cs (3)

102Assert.Empty(remainingErrors); 208Assert.Empty(documentRenameResult.ApplicableActions); 239Assert.Empty(documentRenameResult.ApplicableActions);

CodeFixes\CodeFixServiceTests.cs (5)

165Assert.Empty(documentDiagnosticAnalyzer.SupportedDiagnostics); 194Assert.Empty(GeneratorDiagnosticsPlaceholderAnalyzer.Instance.SupportedDiagnostics); 1107Assert.Empty(lowPriorityAnalyzerData.Analyzers); 1108Assert.Empty(lowPriorityAnalyzerData.SupportedDiagnosticIds); 1149Assert.Empty(cachedDiagnostics);

Collections\Immutable\Maps\MapTests.cs (2)

79Assert.Empty(map); 119Assert.Empty(map);

Diagnostics\DiagnosticAnalyzerServiceTests.cs (1)

761Assert.Empty(analyzer.CanceledCompilations);

EditAndContinue\EditAndContinueLanguageServiceTests.cs (4)

137Assert.Empty(sessionState.ApplyChangesDiagnostics); 142Assert.Empty(sessionState.ApplyChangesDiagnostics); 154Assert.Empty(sessionState.ApplyChangesDiagnostics); 231Assert.Empty(sessionState.ApplyChangesDiagnostics);

Extensions\CollectionExtensionsTest.cs (3)

24Assert.Empty(stack); 32Assert.Empty(stack); 44Assert.Empty(stack);

MetadataAsSource\AbstractMetadataAsSourceTests.TestContext.cs (1)

173Assert.Empty(diagnostics);

Tagging\TagSpanIntervalTreeTests.cs (1)

46Assert.Empty(GetIntersectingSpans(tree, buffer.CurrentSnapshot.GetFullSpan()));

UnusedReferences\ProjectAssets\ProjectAssetsReaderTests.cs (2)

32Assert.Empty(realizedReferences); 53Assert.Empty(realizedReferences);

UnusedReferences\UnusedReferencesRemoverTests.cs (7)

34Assert.Empty(unusedReferences); 45Assert.Empty(unusedReferences); 56Assert.Empty(unusedReferences); 79Assert.Empty(unusedReferences); 90Assert.Empty(unusedReferences); 119Assert.Empty(unusedReferences); 133Assert.Empty(appliedUpdates);

Utilities\PatternMatcherTests.cs (2)

466Assert.Empty(spans); 485Assert.Empty(expectedSpans);

ValueTracking\AbstractBaseValueTrackingTests.cs (1)

71Assert.Empty(children);

ValueTracking\CSharpValueTrackingTests.cs (3)

286Assert.Empty(initialItems); 306Assert.Empty(initialItems); 329Assert.Empty(initialItems);

RazorAnalyzerAssemblyResolverTests.cs (1)

82Assert.Empty(currentLoadContext.Assemblies);

EditAndContinue\EditAndContinueWorkspaceServiceTests.cs (8)

1446Assert.Empty(result.ProjectsToRebuild); 1447Assert.Empty(result.ProjectsToRestart); 1772Assert.Empty(documentDifferences.Deleted); 1827Assert.Empty(documentDifferences.Deleted); 2604Assert.Empty(delta.ActiveStatements); 2611Assert.Empty(delta.ExceptionRegions); 2612Assert.Empty(delta.SequencePoints); 4869Assert.Empty(encService.GetTestAccessor().GetActiveDebuggingSessions());

EditAndContinue\EmitSolutionUpdateResultsTests.cs (7)

181Assert.Empty(projectsToRestart); 182Assert.Empty(projectsToRebuild); 259Assert.Empty(projectsToRestart); 322Assert.Empty(projectsToRestart); 323Assert.Empty(projectsToRebuild); 345Assert.Empty(projectsToRestart); 346Assert.Empty(projectsToRebuild);

FindUsages\DefinitionItemFactoryTests.cs (5)

935Assert.Empty(compilation.GetDiagnostics().Where(d => d.Severity == DiagnosticSeverity.Error)); 1340Assert.Empty(compilation.GetDiagnostics().Where(d => d.Severity == DiagnosticSeverity.Error)); 1400Assert.Empty(compilation.GetDiagnostics().Where(d => d.Severity == DiagnosticSeverity.Error)); 1515Assert.Empty(compilation.GetDiagnostics().Where(d => d.Severity == DiagnosticSeverity.Error)); 1586Assert.Empty(compilation.GetDiagnostics());

Diagnostics\PullDiagnosticTests.cs (2)

2141Assert.Empty(resultsTwo); 2166Assert.Empty(resultsTwo);

DocumentChanges\DocumentChangesTests.cs (3)

46Assert.Empty(testLspServer.GetTrackedTexts()); 62Assert.Empty(testLspServer.GetTrackedTexts()); 172Assert.Empty(testLspServer.GetTrackedTexts());

DocumentChanges\DocumentChangesTests.WithFindAllReferences.cs (1)

36Assert.Empty(testLspServer.GetTrackedTexts());

Options\SolutionAnalyzerConfigOptionsUpdaterTests.cs (4)

49Assert.Empty(workspace.CurrentSolution.FallbackAnalyzerOptions); 71Assert.Empty(workspace.CurrentSolution.FallbackAnalyzerOptions); 110Assert.Empty(workspace.CurrentSolution.Projects); 277Assert.Empty(workspace.CurrentSolution.FallbackAnalyzerOptions);

Ordering\RequestOrderingTests.cs (6)

126Assert.Empty(responses.Where(r => r == null)); 127Assert.Empty(responses.Where(r => r!.StartTime == default)); 149Assert.Empty(responses.Where(r => r == null)); 150Assert.Empty(responses.Where(r => r!.StartTime == default)); 290Assert.Empty(responses.Where(r => r == null)); 291Assert.Empty(responses.Where(r => r!.StartTime == default));

Workspaces\LspWorkspaceRegistrationServiceTests.cs (1)

27Assert.Empty(registrationService.GetAllRegistrations());

LspFileChangeWatcherTests.cs (2)

71Assert.Empty(dynamicCapabilitiesRpcTarget.Registrations); 102Assert.Empty(dynamicCapabilitiesRpcTarget.Registrations);

DeterministicKeyBuilderTests.cs (1)

434Assert.Empty(obj.Value<JObject>("features")!.Properties());

RoundTripUtil.cs (1)

108Assert.Empty(result.Diagnostics);

GlobalAssemblyCacheTests.cs (4)

75Assert.Empty(names); 78Assert.Empty(names); 81Assert.Empty(names); 85Assert.Empty(names);

Assert\AssertEx.cs (2)

1063/// The core <see cref="Xunit.Assert.Empty(IEnumerable)"/> is annotated to not accept null but many 1069Assert.Empty(collection);

Compilation\ControlFlowGraphVerifier.cs (15)

137Assert.Empty(block.Operations); 138Assert.Empty(block.Predecessors); 148Assert.Empty(currentRegion.Locals); 149Assert.Empty(currentRegion.LocalFunctions); 150Assert.Empty(currentRegion.CaptureIds); 157Assert.Empty(block.Operations); 1434Assert.Empty(region.Locals); 1435Assert.Empty(region.LocalFunctions); 1475Assert.Empty(region.Locals); 1476Assert.Empty(region.LocalFunctions); 1477Assert.Empty(region.CaptureIds); 1483Assert.Empty(region.Locals); 1573Assert.Empty(branch.FinallyRegions); 1574Assert.Empty(branch.LeavingRegions); 1575Assert.Empty(branch.EnteringRegions);

Compilation\OperationTreeVerifier.cs (2)

1460Assert.Empty(propertyReference.Arguments); 1559Assert.Empty(operation.Locals);

Compilation\TestOperationVisitor.cs (36)

AnalyzerAssemblyLoaderTests.cs (1)

1192Assert.Empty(compilationWithAnalyzers.GetAllDiagnosticsAsync().Result);

Analyzers\AnalyzerConfigTests.cs (13)

Analyzers\AnalyzerFileReferenceTests.cs (4)

448Assert.Empty(errors); 452Assert.Empty(errors); 456Assert.Empty(errors); 503Assert.Empty(builder);

AssemblyUtilitiesTests.cs (2)

50Assert.Empty(results); 63Assert.Empty(results);

CachingLookupTests.cs (1)

116Assert.Empty(look1[k]);

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

666Assert.Empty(collection);

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

986Assert.Empty(collection);

Diagnostics\CompilationWithAnalyzersTests.cs (1)

65Assert.Empty(analysisResult.CompilationDiagnostics);

CommandLineTests.vb (13)

ScriptTests.vb (1)

77Assert.Empty(ScriptOptions.Default.Imports)

FlowAnalysis\IterationJumpYieldStatementTests.vb (33)

FlowAnalysis\TryLockUsingStatementTests.vb (57)

Syntax\SyntaxAnnotationTests.vb (2)

124Assert.Empty(matchingNodesOrTokens) 133Assert.Empty(matchingTrivia)

CodeGeneration\SyntaxGeneratorTests.vb (3)

2288Assert.Empty(initialAttributes) 2296Assert.Empty(attrsRemoved) 3229Assert.Empty(baseListN)

NetCoreTests.cs (10)

96Assert.Empty(diagnostics); 142Assert.Empty(diagnostics); 182Assert.Empty(diagnostics); 242Assert.Empty(diagnostics); 366Assert.Empty(diagnostics); 415Assert.Empty(project.ProjectReferences); 444Assert.Empty(project.ProjectReferences); 445Assert.Empty(workspace.Diagnostics); 530Assert.Empty(document.Folders); 535Assert.Empty(diagnostics.Where(d => d.Severity >= DiagnosticSeverity.Warning));

VisualStudioMSBuildWorkspaceTests.cs (29)

MEF\TestComposition.cs (1)

133Assert.Empty(configurationOverlap);

FindReferencesTests.cs (3)

335Assert.Empty(expectedMatchedLines); 346Assert.Empty(expectedMatchedLines); 357Assert.Empty(expectedMatchedLines);

Options\EditorConfigNamingStyleParserTests.cs (4)

143Assert.Empty(result.NamingStyles); 328Assert.Empty(result.SerializableNamingRules); 329Assert.Empty(result.NamingStyles); 330Assert.Empty(result.SymbolSpecifications);

Options\OptionKeyTests.cs (1)

174Assert.Empty(publicOption.StorageLocations);

SolutionTests\SolutionTestHelpers.cs (1)

53Assert.Empty(getter(instanceWithNoItem));

SolutionTests\SolutionTests.cs (22)

236Assert.Empty(newSolution3.GetDocumentIdsWithFilePath("")); 240Assert.Empty(newSolution4.GetDocumentIdsWithFilePath(null)); 1953Assert.Empty(newSolution1.GetProject(projectId)!.ProjectReferences); 2021Assert.Empty(solution4.GetProject(projectId)!.AllProjectReferences); 2127Assert.Empty(solution3.GetProject(projectId)!.MetadataReferences); 2200Assert.Empty(solution3.GetProject(projectId)!.AnalyzerReferences); 2266Assert.Empty(solution3.AnalyzerReferences); 2722Assert.Empty(finalProject.Documents); 2723Assert.Empty((await finalProject.GetCompilationAsync()).SyntaxTrees); 2745Assert.All(solution.Projects, p => Assert.Empty(p.Documents)); 3010Assert.Empty(solution.Projects.Single().AnalyzerReferences); 3029Assert.Empty(removedAnalyzerReferences); 3035Assert.Empty(actualAnalyzerReferences); 4042Assert.Empty(project.GetCompilationAsync().Result.ExternalReferences); 4301Assert.Empty(frozenDocument.Project.AdditionalDocuments); 4992Assert.Empty(solution.GetDocumentIdsWithFilePath(editorConfigFilePath)); 5642Assert.Empty(frozenProject.Documents); 5645Assert.Empty(frozenCompilation.SyntaxTrees); 5686Assert.Empty(frozenProject2.Documents); 5693Assert.Empty(frozenCompilation2.SyntaxTrees); 5720Assert.Empty(frozenProject2.Documents); 5723Assert.Empty(frozenCompilation2.SyntaxTrees);

SolutionTests\SolutionWithSourceGeneratorTests.cs (3)

579Assert.Empty(await project.GetSourceGeneratedDocumentsAsync()); 646Assert.Empty(await workspace.CurrentSolution.Projects.Single().GetSourceGeneratedDocumentsAsync()); 1375Assert.Empty(changes.GetExplicitlyChangedSourceGeneratedDocuments());

TestCompositionTests.cs (8)

32Assert.Empty(composition2.RemoveAssemblies(assembly1).Assemblies); 49Assert.Empty(composition3.Parts); 50Assert.Empty(composition3.ExcludedPartTypes); 54Assert.Empty(composition3.ExcludedPartTypes); 68Assert.Empty(composition3.Parts); 70Assert.Empty(composition3.ExcludedPartTypes); 71Assert.Empty(composition3.Parts); 75Assert.Empty(composition4.Parts);

UtilityTest\DictionaryExtensionsTests.cs (2)

18Assert.Empty(dictionary); 69Assert.Empty(dictionary);

UtilityTest\IntervalTreeTests.cs (8)

40Assert.Empty(spans); 51Assert.Empty(spans); 62Assert.Empty(spans); 73Assert.Empty(spans); 84Assert.Empty(spans); 171Assert.Empty(GetIntervalsThatOverlapWith(tree, 2, 2)); 172Assert.Empty(GetIntervalsThatOverlapWith(tree, 11, 2)); 173Assert.Empty(GetIntervalsThatOverlapWith(tree, 22, 2));

UtilityTest\WeakEventTests.cs (1)

39Assert.Empty(target);

DataFrameGroupByTests.cs (1)

52Assert.Empty(grouping);

DataFrameJoinExtensionsTests.cs (4)

33Assert.Empty(intersection); 56Assert.Empty(intersection); 79Assert.Empty(intersection); 110Assert.Empty(intersection);

DataFrameTests.cs (2)

159Assert.Empty(dataFrame.Columns); 173Assert.Empty(dataFrame.Columns);

DataFrameTests.Merge.cs (2)

782Assert.Empty(intersection); 798Assert.Empty(intersection);

GenerateResxSourceTests.cs (1)

54Assert.Empty(engine.Warnings);

PublishToSymbolServerTest.cs (2)

161Assert.Empty(buildEngine.BuildErrorEvents); 162Assert.Empty(buildEngine.BuildWarningEvents);

XlfDocumentTests.cs (3)

458Assert.Empty(untranslatedResources); 570Assert.Empty(validationErrors); 580Assert.Empty(validationErrors);

CollectionAssertsTests.cs (4)

656 Assert.Throws<ArgumentNullException>("collection", () => Assert.Empty(default(IEnumerable)!)); 664 Assert.Empty(list); 672 var ex = Record.Exception(() => Assert.Empty(list)); 687 Assert.Empty(enumerator);

ConditionalAttributeTests.cs (1)

44Assert.Empty(res);

AdditionalPropertiesDictionaryTests.cs (1)

16Assert.Empty(d);

AIToolTests.cs (1)

17Assert.Empty(tool.AdditionalProperties);

ChatCompletion\ChatMessageTests.cs (10)

20Assert.Empty(message.Contents); 25Assert.Empty(message.Contents); 43Assert.Empty(message.Contents); 65Assert.Empty(message.Contents); 69Assert.Empty(message.Contents); 73Assert.Empty(message.Contents); 77Assert.Empty(message.Contents); 99Assert.Empty(message.Contents); 175Assert.Empty(message.Contents); 188Assert.Empty(message.Contents);

ChatCompletion\ChatResponseTests.cs (2)

20Assert.Empty(response.Messages); 24Assert.Empty(response.Messages);

ChatCompletion\ChatResponseUpdateTests.cs (3)

20Assert.Empty(update.Contents); 43Assert.Empty(update.Contents); 53Assert.Empty(update.Contents);

Embeddings\GeneratedEmbeddingsTests.cs (2)

37Assert.Empty(instance); 152Assert.Empty(embeddings);

Functions\AIFunctionArgumentsTests.cs (6)

19Assert.Empty(args); 30Assert.Empty(args); 59Assert.Empty(args); 156Assert.Empty(args); 179Assert.Empty(args); 195Assert.Empty(args);

HostedCodeInterpreterToolTests.cs (1)

16Assert.Empty(tool.AdditionalProperties);

HostedWebSearchToolTests.cs (1)

16Assert.Empty(tool.AdditionalProperties);

SpeechToText\SpeechToTextResponseTests.cs (4)

24Assert.Empty(response.Contents); 28Assert.Empty(response.Contents); 46Assert.Empty(response.Contents); 83Assert.Empty(response.Contents);

SpeechToText\SpeechToTextResponseUpdateTests.cs (2)

20Assert.Empty(update.Contents); 47Assert.Empty(update.Contents);

AzureAIInferenceChatClientTests.cs (6)

508Assert.Empty(azureAIOptions.Messages); 516Assert.Empty(azureAIOptions.StopSequences); 517Assert.Empty(azureAIOptions.Tools); 583Assert.Empty(azureAIOptions.Messages); 591Assert.Empty(azureAIOptions.StopSequences); 592Assert.Empty(azureAIOptions.Tools);

ResultStoreTester.cs (1)

172Assert.Empty(results);

OpenAIChatClientTests.cs (4)

499Assert.Empty(openAIOptions.StopSequences); 500Assert.Empty(openAIOptions.Tools); 575Assert.Empty(openAIOptions.StopSequences); 576Assert.Empty(openAIOptions.Tools);

ChatCompletion\DistributedCachingChatClientTest.cs (1)

686Assert.Empty(_storage.Keys);

ChatCompletion\FunctionInvocationContextTests.cs (1)

25Assert.Empty(ctx.Messages);

ChatCompletion\FunctionInvokingChatClientTests.cs (2)

507Assert.Empty(logs); 567Assert.Empty(activities);

ChatCompletion\LoggingChatClientTests.cs (2)

87Assert.Empty(logs); 141Assert.Empty(logs);

Embeddings\DistributedCachingEmbeddingGeneratorTest.cs (1)

333Assert.Empty(_storage.Keys);

Embeddings\LoggingEmbeddingGeneratorTests.cs (1)

84Assert.Empty(logs);

SpeechToText\LoggingSpeechToTextClientTests.cs (2)

90Assert.Empty(logs); 147Assert.Empty(logs);

GetDocumentTests.cs (3)

69Assert.Empty(result.Diagnostic.Errors); 96Assert.Empty(result.Diagnostic.Errors); 129Assert.Empty(result.Diagnostic.Errors);

RedisCacheSetAndRemoveTests.cs (2)

113Assert.Empty(arr); 127Assert.Empty(arr);

KeyPerFileTests.cs (4)

162Assert.Empty(config.AsEnumerable()); 306Assert.Empty(config.AsEnumerable()); 369Assert.Empty(config.AsEnumerable()); 421Assert.Empty(config.AsEnumerable());

DefaultHealthCheckServiceTest.cs (4)

91Assert.Empty(actual.Value.Data); 113Assert.Empty(actual.Value.Data); 145Assert.Empty(actual.Value.Data); 154Assert.Empty(actual.Value.Data);

Linux\OSFileSystemTests.cs (1)

137Assert.Empty(lines);

Logging\FakeLogCollectorOptionsTests.cs (2)

15Assert.Empty(options.FilteredCategories); 16Assert.Empty(options.FilteredLevels);

Logging\FakeLoggerTests.cs (4)

41Assert.Empty(records[0].Scopes); 49Assert.Empty(records[0].Scopes); 58Assert.Empty(logger.LatestRecord.Scopes); 63Assert.Empty(logger.Collector.GetSnapshot());

Metrics\MeasurementExtensionsTests.cs (7)

36Assert.Empty(filtered); 61Assert.Empty(filtered); 86Assert.Empty(filtered); 89Assert.Empty(filtered); 114Assert.Empty(filtered); 117Assert.Empty(filtered); 120Assert.Empty(filtered);

Metrics\MetricCollectorTests.cs (19)

EmbeddedFileProviderTests.cs (2)

234Assert.Empty(files); 251Assert.Empty(files);

FakeConfigurationSourceTests.cs (1)

37Assert.Empty(configSource.InitialData!);

HostTerminatorServiceTests.cs (1)

27Assert.Empty(logger.Collector.GetSnapshot());

Hedging\HedgingTests.cs (1)

325protected void AssertNoResponse() => Assert.Empty(_responses);

Resilience\HttpClientBuilderExtensionsTests.Resilience.cs (1)

316Assert.Empty(handlers);

Logging\LoggerMessageStateTests.cs (1)

147Assert.Empty(list);

Http\HttpParserTests.cs (3)

130Assert.Empty(httpRouteParameters); 137Assert.Empty(httpRouteParameters); 144Assert.Empty(httpRouteParameters);

Latency\Internal\LatencyContextTests.cs (2)

95Assert.Empty(measures.ToArray()); 256Assert.Empty(checkpoints.ToArray());

GeneratorTests.cs (3)

69Assert.Empty(d); 113Assert.Empty(d); 155Assert.Empty(diags);

EmitterTests.cs (1)

146Assert.Empty(d);

ParserTests.cs (2)

30Assert.Empty(result!.Single().OptionsContextProperties); 47Assert.Empty(result!.Single().Diagnostics);

SyntaxContextReceiverTests.cs (1)

88Assert.Empty(typeDeclarations!);

TagProviderTests.cs (1)

130Assert.Empty(latestRecord.StructuredState!);

AttributeParserTests.cs (8)

32Assert.Empty(diagnostics); 48Assert.Empty(diagnostics); 62Assert.Empty(diagnostics); 76Assert.Empty(diagnostics); 90Assert.Empty(diagnostics); 113Assert.Empty(diagnostics); 127Assert.Empty(diagnostics); 156Assert.Empty(diagnostics);

ParserTests.cs (1)

679Assert.Empty(diagnostics);

ParserTests.LogProperties.cs (1)

487Assert.Empty(d);

GeneratorTests.cs (3)

88Assert.Empty(d); 133Assert.Empty(d); 183Assert.Empty(diags);

MetricTests.cs (6)

57Assert.All(measurements, x => Assert.Empty(x.Tags)); 84Assert.All(measurements, x => Assert.Empty(x.Tags)); 112Assert.All(measurements, x => Assert.Empty(x.Tags)); 140Assert.All(measurements, x => Assert.Empty(x.Tags)); 303Assert.Empty(measurement.Tags); 316Assert.Empty(measurement.Tags);

MetricTests.Ext.cs (4)

43Assert.All(measurements, x => Assert.Empty(x.Tags)); 68Assert.All(measurements, x => Assert.Empty(x.Tags)); 95Assert.All(measurements, x => Assert.Empty(x.Tags)); 122Assert.All(measurements, x => Assert.Empty(x.Tags));

EmitterTests.cs (1)

42Assert.Empty(d);

ParserTests.StrongTypes.cs (13)

28Assert.Empty(d); 56Assert.Empty(d); 136Assert.Empty(d); 157Assert.Empty(d); 170Assert.Empty(d); 202Assert.Empty(d); 267Assert.Empty(d); 395Assert.Empty(d); 517Assert.Empty(d); 558Assert.Empty(d); 592Assert.Empty(d); 612Assert.Empty(d); 661Assert.Empty(d);

GeneratorTests.cs (3)

53Assert.Empty(d); 93Assert.Empty(d); 136Assert.Empty(diags);

JSRuntimeTest.cs (1)

100Assert.Empty(runtime.BeginInvokeCalls);

ColumnInferenceTests.cs (1)

130Assert.Empty(result.ColumnInformation.TextColumnNames);

SuggestedPipelineBuilderTests.cs (1)

49Assert.Empty(pipeline.Transforms);

IntrospectiveTraining.cs (4)

62Assert.Empty(tree.GetCategoricalSplitFeaturesAt(0)); 63Assert.Empty(tree.GetCategoricalCategoricalSplitFeatureRangeAt(0)); 106Assert.Empty(tree.GetCategoricalSplitFeaturesAt(0)); 107Assert.Empty(tree.GetCategoricalCategoricalSplitFeatureRangeAt(0));

ModelFiles.cs (4)

180Assert.Empty(Assert.IsType<TransformerChain<ITransformer>>(t)); 181Assert.Empty(Assert.IsType<TransformerChain<ITransformer>>(t1)); 399Assert.Empty(Assert.IsType<TransformerChain<ITransformer>>(loadedWithSchema)); 400Assert.Empty(Assert.IsType<TransformerChain<ITransformer>>(loadedWithLoader));

Transformers\KeyToBinaryVectorEstimatorTest.cs (1)

130Assert.Empty(column.Annotations.Schema);

Transformers\NormalizerTests.cs (14)

147Assert.Empty(floatAffineDataVec.Offset); 155Assert.Empty(doubleAffineDataVec.Offset); 176Assert.Empty(doubleBinDataVec.Offset); 185Assert.Empty(floatCdfMeanDataVec.Offset); 193Assert.Empty(doubleCdfMeanDataVec.Offset); 264Assert.Empty(floatAffineModelVec.Offset); 274Assert.Empty(doubleAffineModelVector.Offset); 307Assert.Empty(doubleBinModelVector.Offset); 317Assert.Empty(floatCdfMeanModelVector.Offset); 327Assert.Empty(doubleCdfMeanModelVector.Offset); 388Assert.Empty(doubleBinModelVector.Offset); 448Assert.Empty(floatAffineModelVec.Offset); 461Assert.Empty(doubleAffineModelVector.Offset); 970Assert.Empty(noCdfParams.Offset);

PreTokenizerTests.cs (1)

73Assert.Empty(PreTokenizer.CreateWordOrNonWord().PreTokenize((string)null!));

TiktokenTests.cs (2)

259Assert.Empty(encoded); 263Assert.Empty(result);

WordPieceTests.cs (2)

63Assert.Empty(tokens); 66Assert.Empty(ids);

ContentDispositionHeaderValueTest.cs (3)

46Assert.Empty(contentDisposition.Parameters); 83Assert.Empty(contentDisposition.Parameters); 345Assert.Empty(contentDisposition.Parameters);

EntityTagHeaderValueTest.cs (3)

248Assert.Empty(result); 252Assert.Empty(result); 256Assert.Empty(result);

MediaTypeHeaderValueTest.cs (6)

106Assert.Empty(mediaType.Parameters); 241Assert.Empty(mediaType.Parameters); 277Assert.Empty(mediaType.Parameters); 521Assert.Empty(results); 525Assert.Empty(results); 529Assert.Empty(results);

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

344Assert.Empty(receivedArgs.Freeze());

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

269Assert.Empty(DirectoryList); 291Assert.Empty(DirectoryList); 315Assert.Empty(DirectoryList); 393Assert.Empty(FileList); 419Assert.Empty(FileList); 445Assert.Empty(FileList);

DocumentOutline\DocumentOutlineTests.cs (1)

149Assert.Empty(searchedSymbols);

EditorConfigSettings\DataProvider\DataProviderTests.cs (6)

223Assert.Empty(dataSnapShot); 234Assert.Empty(dataSnapShot); 245Assert.Empty(dataSnapShot); 256Assert.Empty(dataSnapShot); 267Assert.Empty(dataSnapShot); 278Assert.Empty(dataSnapShot);

PersistentStorage\AbstractPersistentStorageTests.cs (1)

971Assert.Empty(exceptions);

ProjectSystemShim\CPS\SourceFileHandlingTests.cs (12)

ProjectSystemShim\EntryPointFinderTests.cs (1)

33=> Validate(signature, Assert.Empty);

CodeAnalysisExtensionsTest.cs (2)

33Assert.Empty(attributes); 286Assert.Empty(attributes);

ApiActionsDoNotRequireExplicitModelValidationCheckAnalyzerIntegrationTest.cs (1)

59Assert.Empty(result);

ApiConventionAnalyzerIntegrationTest.cs (1)

270Assert.Empty(result);

EditAndContinue\EditAndContinueTest.cs (1)

43Assert.Empty(_generations);

Services\PerformanceTrackerServiceTests.cs (3)

34Assert.Empty(analyzerInfos); 60Assert.Empty(analyzerInfos); 66Assert.Empty(analyzerInfos);

GenerateFilteredReferenceAssembliesTaskTests.cs (5)

33Assert.Empty(errors); 34Assert.Empty(patterns); 46Assert.Empty(patterns); 60Assert.Empty(patterns); 86Assert.Empty(errors);

ResponseCompressionTests.cs (1)

175Assert.Empty(response.Content.Headers.ContentEncoding);

Data.Validation\LengthAttributeTests.cs (16)

35Assert.Empty(results); 47Assert.Empty(results); 68Assert.Empty(results); 91Assert.Empty(results); 103Assert.Empty(results); 125Assert.Empty(results); 162Assert.Empty(results); 179Assert.Empty(results); 197Assert.Empty(results); 219Assert.Empty(results); 230Assert.Empty(results); 242Assert.Empty(results); 269Assert.Empty(results); 286Assert.Empty(results); 304Assert.Empty(results); 376Assert.Empty(result!.MemberNames);

Data.Validation\TimeSpanAttributeTests.cs (14)

33Assert.Empty(results); 52Assert.Empty(results); 57Assert.Empty(results); 70Assert.Empty(results); 75Assert.Empty(results); 98Assert.Empty(results); 117Assert.Empty(results); 138Assert.Empty(results); 161Assert.Empty(results); 180Assert.Empty(results); 185Assert.Empty(results); 198Assert.Empty(results); 203Assert.Empty(results); 253Assert.Empty(result!.MemberNames);

EmptyCollections\EmptyCollectionExtensionsTests.cs (1)

66Assert.Empty(nothing);

EmptyCollections\EmptyReadonlyDictionaryTests.cs (2)

42Assert.Empty(dict.Keys); 43Assert.Empty(dict.Values);

EmptyCollections\EmptyTests.cs (4)

13Assert.Empty(Empty.ReadOnlyCollection<int>()); 14Assert.Empty(Empty.ReadOnlyList<int>()); 15Assert.Empty(Empty.Enumerable<int>()); 16Assert.Empty(Empty.ReadOnlyDictionary<int, int>());

Pools\PoolTests.cs (3)

158Assert.Empty(l2); 173Assert.Empty(d2); 188Assert.Empty(s2);

mono\System.Drawing.Imaging\JpegCodecTests.cs (1)

195Assert.Empty(bmp.Palette.Entries);

mono\System.Drawing.Imaging\PngCodecTests.cs (1)

254Assert.Empty(bmp.Palette.Entries);

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

1179Assert.Empty(b.Palette.Entries); 1266Assert.Empty(bitmap.Palette.Entries); 1277Assert.Empty(image.Palette.Entries); 1292Assert.Empty(bitmap.Palette.Entries); 1304Assert.Empty(image.Palette.Entries); 1313Assert.Empty(image2.Palette.Entries);

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

1849Assert.Empty(regions); 1852Assert.Empty(regions); 1854Assert.Empty(regions); 1858Assert.Empty(regions); 1861Assert.Empty(regions); 1863Assert.Empty(regions); 1873Assert.Empty(regions); 1876Assert.Empty(regions);

System\Drawing\BitmapTests.cs (1)

706Assert.Empty(result.Palette.Entries);

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

232Assert.Empty(points); 233Assert.Empty(types);

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

139Assert.Empty(gp.PathData.Points); 140Assert.Empty(gp.PathData.Types); 749Assert.Empty(gpi.PathData.Points); 752Assert.Empty(gpf.PathData.Points); 2064Assert.Empty(gp.PathData.Points); 2065Assert.Empty(gp.PathData.Types);

System\Drawing\IconTests.cs (2)

526Assert.Empty(bitmap.Palette.Entries); 564Assert.Empty(bitmap.Palette.Entries);

System\Drawing\ImageTests.cs (5)

35Assert.Empty(bitmap.PropertyIdList); 85Assert.Empty(bitmap.PropertyItems); 93Assert.Empty(bitmap.PropertyItems); 151Assert.Empty(bitmap.PropertyIdList); 171Assert.Empty(bitmap.PropertyIdList);

System\Drawing\PenTests.cs (1)

1206Assert.Empty(pen.CompoundArray);

System\Drawing\RegionTests.cs (4)

188Assert.Empty(region.GetRegionScans(matrix)); 239Assert.Empty(region.GetRegionScans(matrix)); 1449Assert.Empty(region.GetRegionScans(matrix)); 1959Assert.Empty(region.GetRegionScans(matrix));

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

14Assert.Empty(fontCollection.Families);

Serialization\PrimitiveCodeDomSerializerTests.cs (2)

37Assert.Empty(result.UserData); 54Assert.Empty(cast.UserData);

SplitContainerDesignerTests.cs (1)

43Assert.Empty(splitContainerDesigner.AssociatedComponents);

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

165Assert.Empty(control.GetBytes());

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

28Assert.Empty(form.Items); 73Assert.Empty(form.Items); 79Assert.Empty(form.Items); 148Assert.Empty(form.Items); 156Assert.Empty(form.Items); 266Assert.Empty(form.Items); 274Assert.Empty(form.Items);

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

21Assert.Empty(designer.ActionLists); 23Assert.Empty(designer.AssociatedComponents); 31Assert.Empty(designer.Verbs); 40Assert.Empty(treeDesigner.Children); 196Assert.Empty(treeDesigner.Children); 2009Assert.Empty(designer.AssociatedComponents); 2134Assert.Empty(designer.AssociatedComponents);

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

24Assert.Empty(item.Properties); 42Assert.Empty(item.Properties);

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

14Assert.Empty(collection); 78Assert.Empty(collection); 159Assert.Empty(collection); 163Assert.Empty(collection);

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

24Assert.Empty(item.Properties);

System\ComponentModel\Design\DesignerActionListCollectionTests.cs (5)

14Assert.Empty(collection); 128Assert.Empty(collection); 134Assert.Empty(collection); 207Assert.Empty(collection); 211Assert.Empty(collection);

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

128Assert.Empty(items);

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

32Assert.Empty(item.Properties); 58Assert.Empty(item.Properties); 84Assert.Empty(item.Properties); 110Assert.Empty(item.Properties); 136Assert.Empty(item.Properties); 162Assert.Empty(item.Properties);

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

25Assert.Empty(item.Properties); 45Assert.Empty(item.Properties); 65Assert.Empty(item.Properties);

System\ComponentModel\Design\DesignerActionServiceTests.cs (43)

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

24Assert.Empty(item.Properties);

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

System\ComponentModel\Design\DesignerVerbCollectionTests.cs (5)

14Assert.Empty(collection); 128Assert.Empty(collection); 134Assert.Empty(collection); 207Assert.Empty(collection); 211Assert.Empty(collection);

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

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

18Assert.Empty(listService.GetExtenderProviders()); 83Assert.Empty(listService.GetExtenderProviders()); 95Assert.Empty(listService.GetExtenderProviders());

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

27Assert.Empty(e.Errors);

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

117Assert.Empty(underTest.Nodes);

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

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

22Assert.Empty(iManager.Properties); 64Assert.Empty(iManager.Properties); 147Assert.Empty(errors); 157Assert.Empty(manager.Errors); 541Assert.Empty(errors1); 551Assert.Empty(errors2); 1722Assert.Empty(errors1); 1732Assert.Empty(errors2); 1901Assert.Empty(manager.Errors);

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

14Assert.Empty(context.StatementCollection);

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

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

99Assert.Empty(editor.GetExtensions());

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

28Assert.Empty(item.Filter); 33Assert.Empty(item.Properties); 695Assert.Empty(item.CreateComponents()); 960Assert.Empty(item.CreateComponentsCore(null));

System\Windows\Forms\Design\WindowsFormsDesignerOptionServiceTests.cs (6)

39Assert.Empty(childCollection); 47Assert.Empty(service.Options); 63Assert.Empty(childCollection); 80Assert.Empty(childCollection); 87Assert.Empty(otherChildCollection); 103Assert.Empty(childCollection);

ToolStripDesignerTests.cs (2)

44Assert.Empty(toolStripDesigner.AssociatedComponents); 65Assert.Empty(toolStripDesigner.Items);

ToolStripDropDownDesignerTest.cs (1)

39Assert.Empty(toolStripDropDownDesigner.AssociatedComponents);

ToolStripDropDownItemDesignerTest.cs (1)

18Assert.Empty(toolStripDropDownItemDesigner.AssociatedComponents);

Interop\Ole32\CADWORDTests.cs (1)

27Assert.Empty(values);

Interop\Ole32\CALPOLESTRTests.cs (1)

27Assert.Empty(values);

CheckedListBoxTests.cs (8)

270Assert.Empty(control.Items); 275Assert.Empty(control.Items); 309Assert.Empty(control.Items); 317Assert.Empty(control.Items); 563Assert.Empty(checkedListBox.SelectedIndices); 564Assert.Empty(checkedListBox.SelectedItems); 625Assert.Empty(checkedListBox.CheckedIndices); 626Assert.Empty(checkedListBox.CheckedItems);

System\Windows\Forms\AccessibleObjects\ComboBox.ComboBoxAccessibleObjectTests.cs (2)

425Assert.Empty(accessibleObject.ItemAccessibleObjects); 441Assert.Empty(accessibleObject.ItemAccessibleObjects);

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

1201Assert.Empty(columnHeaders); 1296Assert.Empty(rowHeaders);

System\Windows\Forms\AccessibleObjects\ListVIew.ListViewAccessibleObjectTests.cs (4)

963Assert.Empty(listSelection); 981Assert.Empty(listSelection); 1076Assert.Empty(listSelection); 1106Assert.Empty(listSelection);

System\Windows\Forms\AccessibleObjects\TabControl.TabControlAccessibleObjectTests.cs (2)

486Assert.Empty(selectedAccessibleObjects); 502Assert.Empty(selectedAccessibleObjects);

System\Windows\Forms\AccessibleObjects\TreeView.TreeViewAccessibleObjectTests.cs (2)

200Assert.Empty(control.AccessibilityObject.GetSelection()); 210Assert.Empty(control.AccessibilityObject.GetSelection());

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

392Assert.Empty(Application.OpenForms); 530Assert.Empty(Application.OpenForms); 616Assert.Empty(Application.OpenForms);

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

14Assert.Empty(collection); 42Assert.Empty(collection); 186Assert.Empty(collection); 203Assert.Empty(collection); 217Assert.Empty(collection); 221Assert.Empty(collection); 231Assert.Empty(collection); 235Assert.Empty(collection); 247Assert.Empty(collection);

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

57Assert.Empty(control.Controls); 151Assert.Empty(control.Controls);

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

15Assert.Empty(manager.Bindings); 75Assert.Empty(collection); 80Assert.Empty(collection); 95Assert.Empty(collection); 153Assert.Empty(collection);

System\Windows\Forms\BindingsCollectionTests.cs (19)

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

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

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

50Assert.Empty(control.Controls);

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

52Assert.Empty(control.Controls);

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

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

1585Assert.Empty(listView.Columns); 1588Assert.Empty(listView.Columns);

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

421Assert.Empty(comboBoxObjectCollection); 422Assert.Empty(comboBoxObjectCollection.InnerList); 444Assert.Empty(comboBoxObjectCollection); 445Assert.Empty(accessibleObject.ItemAccessibleObjects); 873Assert.Empty(comboBoxObjectCollection); 874Assert.Empty(accessibleObject.ItemAccessibleObjects); 1052Assert.Empty(comboBoxObjectCollection); 1053Assert.Empty(accessibleObject.ItemAccessibleObjects);

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

31Assert.Empty(control.AutoCompleteCustomSource); 53Assert.Empty(control.Controls); 95Assert.Empty(control.Items); 1500Assert.Empty(controlWithNoItems.Items); 1606Assert.Empty(controlWithNoItems.Items);

System\Windows\Forms\ComponentModel\Com2Interop\ComNativeDescriptorTests.cs (2)

220Assert.Empty(properties); 223Assert.Empty(events);

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

55Assert.Empty(control.Controls);

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

32Assert.Empty(collection); 313Assert.Empty(collection); 318Assert.Empty(collection); 333Assert.Empty(collection); 391Assert.Empty(collection);

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

44Assert.Empty(result.Palette.Entries); 69Assert.Empty(result.Palette.Entries); 115Assert.Empty(result.Palette.Entries); 147Assert.Empty(result.Palette.Entries); 180Assert.Empty(result.Palette.Entries);

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

22Assert.Empty(collection); 61Assert.Empty(owner.Controls); 74Assert.Empty(owner.Controls); 89Assert.Empty(owner.Controls); 209Assert.Empty(collection1); 1309Assert.Empty(collection); 1322Assert.Empty(collection); 1508Assert.Empty(collection.Find(key, searchAllChildren: true)); 1509Assert.Empty(collection.Find(key, searchAllChildren: false)); 2885Assert.Empty(collection.Cast<Control>());

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

43Assert.Empty(control.Controls); 132Assert.Empty(control.Controls); 228Assert.Empty(control.Controls); 324Assert.Empty(control.Controls); 420Assert.Empty(control.Controls);

System\Windows\Forms\ControlTests.Internals.cs (1)

345Assert.Empty(tabOrderedChildrenWithhandlesOnly);

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

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

3679Assert.Empty(control.Controls); 3699Assert.Empty(control.Controls); 9712Assert.Empty(oldParent.Controls); 9718Assert.Empty(oldParent.Controls);

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

104Assert.Empty(descriptor.Arguments); 164Assert.Empty(Assert.IsType<byte[]>(converter.ConvertTo(null, typeof(byte[]))));

System\Windows\Forms\DataGridView.DataGridViewControlCollectionTests.cs (1)

16Assert.Empty(collection);

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

18Assert.Empty(collection); 19Assert.Empty(collection); 24Assert.Empty(collection.List);

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

19Assert.Empty(row.Cells); 2997Assert.Empty(control.SelectedRows); 3002Assert.Empty(control.SelectedRows); 3036Assert.Empty(control.SelectedRows); 4062Assert.Empty(row.Cells); 4089Assert.Empty(row.Cells); 4154Assert.Empty(row.CreateCellsInstance());

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

17Assert.Empty(collection); 188Assert.Empty(iList);

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

17Assert.Empty(collection); 208Assert.Empty(iList);

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

17Assert.Empty(collection); 183Assert.Empty(iList);

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

852Assert.Empty(oldParent.Controls); 858Assert.Empty(oldParent.Controls); 2820Assert.Empty(control.Columns); 2821Assert.Empty(control.Rows);

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

30Assert.Empty(control.AutoCompleteCustomSource); 54Assert.Empty(control.Controls); 89Assert.Empty(control.Lines);

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

57Assert.Empty(control.Controls);

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

119Assert.Empty(control.MdiChildren); 128Assert.Empty(control.OwnedForms);

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

52Assert.Empty(control.Controls);

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

24Assert.Empty(dialog.CustomPlaces); 32Assert.Empty(dialog.FileNames); 62Assert.Empty(dialog.CustomPlaces); 70Assert.Empty(dialog.FileNames); 618Assert.Empty(dialog.CustomPlaces); 626Assert.Empty(dialog.FileNames);

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

50Assert.Empty(control.Controls);

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

23Assert.Empty(dialog.SelectedPaths); 301Assert.Empty(dialog.SelectedPaths);

System\Windows\Forms\Form.ControlCollectionTests.cs (1)

16Assert.Empty(collection);

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

63Assert.Empty(control.Controls); 121Assert.Empty(control.MdiChildren); 130Assert.Empty(control.OwnedForms); 965Assert.Empty(oldParent.Controls); 972Assert.Empty(oldParent.Controls);

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

19Assert.Empty(collection); 26Assert.Empty(collection);

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

46Assert.Empty(control.Controls);

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

50Assert.Empty(control.Controls);

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

864Assert.Empty(collection); 900Assert.Empty(collection); 1052Assert.Empty(collection); 1778Assert.Empty(document.GetElementsByTagName("NoSuchTagName")); 1780Assert.Empty(document.GetElementsByTagName("")); 1947Assert.Empty(newDocument.All);

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

51Assert.Empty(collection); 152Assert.Empty(collection); 1943Assert.Empty(element.GetElementsByTagName("NoSuchTagName")); 1944Assert.Empty(element.GetElementsByTagName("")); 2002Assert.Empty(element.All); 2008Assert.Empty(element.All); 2015Assert.Empty(element.All);

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

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

46Assert.Empty(control.Controls);

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

22Assert.Empty(settings.ColumnStyles); 28Assert.Empty(settings.RowStyles); 39Assert.Empty(settings.ColumnStyles); 44Assert.Empty(settings.RowStyles); 1854Assert.Empty(result.ColumnStyles); 1855Assert.Empty(result.RowStyles);

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

107Assert.Empty(settings.ColumnStyles); 108Assert.Empty(settings.RowStyles);

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

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

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

15Assert.Empty(collection); 31Assert.Empty(collection); 41Assert.Empty(collection);

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

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

47Assert.Empty(control.Controls);

System\Windows\Forms\ListView.ListViewItemCollectionTests.cs (2)

90Assert.Empty(collection.Find(key, searchAllSubItems: true)); 91Assert.Empty(collection.Find(key, searchAllSubItems: false));

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

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

25Assert.Empty(group.Items); 46Assert.Empty(group.Items); 76Assert.Empty(group.Items); 104Assert.Empty(group.Items); 1327Assert.Empty(groupWithEmptyItems.Items); 1385Assert.Empty(group.Items);

System\Windows\Forms\ListViewItem.IKeyboardToolTipTests.cs (3)

213Assert.Empty(((IKeyboardToolTip)listViewItem).GetNeighboringToolsRectangles()); 224Assert.Empty(((IKeyboardToolTip)listViewItem).GetNeighboringToolsRectangles()); 233Assert.Empty(((IKeyboardToolTip)listViewItem).GetNeighboringToolsRectangles());

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

26Assert.Empty(result);

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

1039Assert.Empty(listView.Items);

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

19Assert.Empty(collection); 33Assert.Empty(collection); 433Assert.Empty(collection); 438Assert.Empty(collection); 449Assert.Empty(collection); 713Assert.Empty(collection); 718Assert.Empty(collection); 731Assert.Empty(collection); 736Assert.Empty(collection); 794Assert.Empty(collection);

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

50Assert.Empty(control.CheckedIndices); 52Assert.Empty(control.CheckedItems); 56Assert.Empty(control.Columns); 61Assert.Empty(control.Controls); 86Assert.Empty(control.Groups); 101Assert.Empty(control.Items); 127Assert.Empty(control.SelectedIndices); 129Assert.Empty(control.SelectedItems); 4487Assert.Empty(control.SelectedItems); 4553Assert.Empty(control.SelectedIndices); 5581Assert.Empty(listView.SelectedItems); 5582Assert.Empty(listView.SelectedIndices); 5641Assert.Empty(listView.CheckedItems); 5642Assert.Empty(listView.CheckedIndices);

System\Windows\Forms\MdiClient.ControlCollectionTests.cs (1)

16Assert.Empty(collection);

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

44Assert.Empty(control.Controls); 65Assert.Empty(control.MdiChildren);

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

50Assert.Empty(control.Controls); 66Assert.Empty(control.DisplayedItems); 101Assert.Empty(control.Items);

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

29Assert.Empty(control.AnnuallyBoldedDates); 36Assert.Empty(control.BoldedDates); 59Assert.Empty(control.Controls); 102Assert.Empty(control.MonthlyBoldedDates);

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

354Assert.Empty(window1.Messages); 369Assert.Empty(window2.Messages); 380Assert.Empty(window3.Messages); 399Assert.Empty(window.Messages);

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

50Assert.Empty(control.Controls);

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

49Assert.Empty(control.Controls); 1150Assert.Empty(oldParent.Controls); 1155Assert.Empty(oldParent.Controls);

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

45Assert.Empty(control.Controls);

System\Windows\Forms\PropertyGridInternal\PropertiesTabTests.cs (3)

75Assert.Empty(tab.GetProperties(null)); 112Assert.Empty(tab.GetProperties(null, null)); 196Assert.Empty(tab.GetProperties(null, null, null));

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

145Assert.Empty(control.SelectedObjects);

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

51Assert.Empty(control.Controls);

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

60Assert.Empty(control.Controls); 96Assert.Empty(control.Lines); 6178Assert.Empty(control.SelectionTabs); 6182Assert.Empty(control.SelectionTabs); 6198Assert.Empty(control.SelectionTabs); 6205Assert.Empty(control.SelectionTabs); 6249Assert.Empty(control.SelectionTabs); 6412Assert.Empty(control.SelectionTabs); 6417Assert.Empty(control.SelectionTabs);

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

49Assert.Empty(control.Controls);

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

44Assert.Empty(control.Controls);

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

54Assert.Empty(control.Controls);

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

45Assert.Empty(control.Controls);

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

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

20Assert.Empty(collection); 705Assert.Empty(container.Components); 963Assert.Empty(collection); 964Assert.Empty(owner.TabPages); 1084Assert.Empty(collection); 1085Assert.Empty(owner.TabPages); 1199Assert.Empty(collection); 1200Assert.Empty(owner.TabPages); 1321Assert.Empty(collection); 1322Assert.Empty(owner.TabPages); 1384Assert.Empty(collection); 1422Assert.Empty(collection);

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

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

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

79Assert.Empty(collection);

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

17Assert.Empty(collection); 71Assert.Empty(collection);

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

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

79Assert.Empty(collection);

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

18Assert.Empty(collection); 195Assert.Empty(collection); 231Assert.Empty(collection); 246Assert.Empty(collection); 249Assert.Empty(collection);

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

54Assert.Empty(control.Controls); 163Assert.Empty(control.Controls); 2510Assert.Empty(oldParent.Controls); 2516Assert.Empty(oldParent.Controls); 3747Assert.Empty(controls); 4950Assert.Empty(actual);

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

15Assert.Empty(collection);

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

52Assert.Empty(control.Controls);

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

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

484Assert.Empty(item.DropDownItems);

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

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

89Assert.Empty(collection.Find(key, searchAllChildren: true)); 90Assert.Empty(collection.Find(key, searchAllChildren: false)); 111Assert.Empty(contextMenuStrip.Items); 119Assert.Empty(toolStripDropDownButton.DropDownItems);

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

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

51Assert.Empty(control.Controls);

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

System\Windows\Forms\TreeNode.IKeyboardToolTipTests.cs (3)

308Assert.Empty(((IKeyboardToolTip)treeNodesList[0]).GetNeighboringToolsRectangles()); 309Assert.Empty(((IKeyboardToolTip)treeNodesList[1]).GetNeighboringToolsRectangles()); 310Assert.Empty(((IKeyboardToolTip)treeNodesList[2]).GetNeighboringToolsRectangles());

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

44Assert.Empty(treeNode.Nodes); 215Assert.Empty(collection.Find(key, searchAllChildren: true)); 216Assert.Empty(collection.Find(key, searchAllChildren: false));

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

39Assert.Empty(node.Nodes); 79Assert.Empty(node.Nodes); 170Assert.Empty(node.Nodes);

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

47Assert.Empty(control.Controls); 94Assert.Empty(control.Nodes); 6977Assert.Empty(treeView.Nodes); 7111Assert.Empty(treeView.Nodes); 7209Assert.Empty(treeNode5.Nodes); 7258Assert.Empty(fifthSubNode1.Nodes); 7262Assert.Empty(firstSubNode.Nodes); 7267Assert.Empty(parent.Nodes);

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

55Assert.Empty(control.Controls);

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

49Assert.Empty(control.Controls);

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

TextBoxBaseTests.cs (1)

1620Assert.Empty(control.Lines);

TextBoxTests.cs (3)

29Assert.Empty(control.AutoCompleteCustomSource); 53Assert.Empty(control.Controls); 83Assert.Empty(control.Lines);

TrackBarTests.cs (1)

46Assert.Empty(control.Controls);

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

19Assert.Empty(extension.Items); 30Assert.Empty(extension.Items);

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

14Assert.Empty(definition.Attributes);

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

94Assert.Empty(serializer.TypeReferences(value, null)); 95Assert.Empty(serializer.TypeReferences(value, new CustomValueSerializerContext()));

System\Xaml\Replacements\TypeListConverterTests.cs (1)

30Assert.Empty(Assert.IsType<Type[]>(converter.ConvertFrom(new CustomTypeDescriptorContext(), null, "value")));

System\Xaml\Schema\XamlTypeNameTests.cs (5)

20Assert.Empty(typeName.TypeArguments); 32Assert.Empty(typeName.TypeArguments); 59Assert.Empty(typeName.TypeArguments); 72Assert.Empty(Assert.Single(typeName.TypeArguments).TypeArguments); 311Assert.Empty(name.TypeArguments);

System\Xaml\XamlMemberTests.cs (1)

632Assert.Empty(directive.DependsOn);

System\Xaml\XamlWriterTests.cs (1)

24Assert.Empty(writer.CalledMethodArgs);

src\Shared\E2ETesting\WaitAssert.cs (2)

51=> WaitAssertCore(driver, () => Assert.Empty(actualValues())); 66Assert.Empty(elements);

src\Shared\E2ETesting\WaitAssert.cs (2)

51=> WaitAssertCore(driver, () => Assert.Empty(actualValues())); 66Assert.Empty(elements);

src\Shared\E2ETesting\WaitAssert.cs (2)

51=> WaitAssertCore(driver, () => Assert.Empty(actualValues())); 66Assert.Empty(elements);

src\Shared\E2ETesting\WaitAssert.cs (2)

51=> WaitAssertCore(driver, () => Assert.Empty(actualValues())); 66Assert.Empty(elements);

AnalyzerConsistencyCheckerTests.cs (1)

73Assert.Empty(emitResult.Diagnostics.Where(x => x.Severity == DiagnosticSeverity.Error));

System\ComponentModel\GroupDescriptionTests.cs (32)

System\ComponentModel\SortDescriptionCollectionTests.cs (16)

System\IO\Packaging\PackageDigitalSignatureManagerTests.cs (5)

30Assert.Empty(manager.Signatures); 282Assert.Empty(manager.Signatures); 289Assert.Empty(manager.Signatures); 304Assert.Empty(manager.Signatures); 310Assert.Empty(manager.Signatures);

System\Security\RightsManagement\UnsignedPublishLicenseTests.cs (2)

13Assert.Empty(license.Grants); 15Assert.Empty(license.LocalizedNameDescriptionDictionary);

System\Windows\Markup\Primitives\MarkupObjectTests.cs (22)

System\Windows\Markup\Primitives\MarkupPropertyTests.cs (20)

System\Windows\WeakEventManagerTests.cs (6)

402Assert.Empty(events); 405Assert.Empty(events); 692Assert.Empty(events); 697Assert.Empty(events); 731Assert.Empty(events); 736Assert.Empty(events);

AsyncCollectionAsserts.cs (1)

209 Empty(AssertHelper.ToEnumerable(collection));