87Assert.Empty(files);

66Assert.Empty(options.GetTestAccessor().Symbols); 67Assert.Empty(options.GetTestAccessor().WildcardNamesBySymbolKind); 100Assert.Empty(options.GetTestAccessor().Names); 101Assert.Empty(options.GetTestAccessor().Symbols); 102Assert.Empty(options.GetTestAccessor().WildcardNamesBySymbolKind); 135Assert.Empty(options.GetTestAccessor().Names); 137Assert.Empty(options.GetTestAccessor().WildcardNamesBySymbolKind); 157Assert.Empty(options.GetTestAccessor().Names); 158Assert.Empty(options.GetTestAccessor().Symbols); 159Assert.Empty(options.GetTestAccessor().WildcardNamesBySymbolKind); 177Assert.Empty(options.GetTestAccessor().Names); 178Assert.Empty(options.GetTestAccessor().Symbols); 179Assert.Empty(options.GetTestAccessor().WildcardNamesBySymbolKind); 199Assert.Empty(options.GetTestAccessor().Names); 200Assert.Empty(options.GetTestAccessor().Symbols); 228Assert.Empty(options.GetTestAccessor().Names); 229Assert.Empty(options.GetTestAccessor().Symbols); 299Assert.Empty(options.GetTestAccessor().WildcardMatchResult); 300Assert.Empty(options.GetTestAccessor().SymbolToDeclarationId);

52Assert.Empty(response.TrailingHeaders); 63Assert.Empty(response.TrailingHeaders);

323Assert.Empty(response.TrailingHeaders);

72Assert.Empty(matchedEntries);

323Assert.Empty(response.TrailingHeaders);

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

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

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);

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

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

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

42Assert.Empty(d);

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

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);

47Assert.Empty(d);

481Assert.Empty(detected);

42Assert.Empty(features);

27Assert.Empty(diagnostics);

197Assert.Empty(propertyMapping);

287Assert.Empty(result.Completions.ItemsList); 309Assert.Empty(result.Completions.ItemsList); 381Assert.Empty(result.Completions.ItemsList); 476Assert.Empty(result.Completions.ItemsList); 498Assert.Empty(result.Completions.ItemsList); 595Assert.Empty(result.Completions.ItemsList); 621Assert.Empty(result.Completions.ItemsList); 696Assert.Empty(result.Completions.ItemsList); 723Assert.Empty(result.Completions.ItemsList); 776Assert.Empty(result.Completions.ItemsList); 823Assert.Empty(result.Completions.ItemsList); 902Assert.Empty(result.Completions.ItemsList); 1027Assert.Empty(result.Completions.ItemsList); 1091Assert.Empty(result.Completions.ItemsList);

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);

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);

785Assert.Empty(tree.Diagnostics);

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

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

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);

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

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

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

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

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

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);

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

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);

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

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

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

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

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

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

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

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

31Assert.Empty(property.PropertyMetadata.Properties); 40Assert.Empty(property.PropertyMetadata.Properties); 75Assert.Empty(property.PropertyMetadata.Properties); 84Assert.Empty(property.PropertyMetadata.Properties); 103Assert.Empty(property.PropertyMetadata.Properties); 112Assert.Empty(property.PropertyMetadata.Properties); 138Assert.Empty(property.PropertyMetadata.Properties); 147Assert.Empty(property.PropertyMetadata.Properties); 172Assert.Empty(parameter.ParameterMetadata.Properties); 181Assert.Empty(parameter.ParameterMetadata.Properties); 206Assert.Empty(property.PropertyMetadata.Properties); 215Assert.Empty(property.PropertyMetadata.Properties); 234Assert.Empty(subProperty.PropertyMetadata.Properties); 243Assert.Empty(subProperty.PropertyMetadata.Properties); 269Assert.Empty(property.PropertyMetadata.Properties); 289Assert.Empty(subProperty.PropertyMetadata.Properties); 307Assert.Empty(subSubProperty.PropertyMetadata.Properties); 316Assert.Empty(subSubProperty.PropertyMetadata.Properties); 344Assert.Empty(property.PropertyMetadata.Properties); 378Assert.Empty(property.PropertyMetadata.Properties); 396Assert.Empty(subProperty.PropertyMetadata.Properties); 431Assert.Empty(property.PropertyMetadata.Properties); 441Assert.Empty(property.PropertyMetadata.Properties); 468Assert.Empty(property.PropertyMetadata.Properties); 478Assert.Empty(property.PropertyMetadata.Properties); 506Assert.Empty(parameter.ParameterMetadata.Properties);

94Assert.Empty(httpContext.Items);

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

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

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

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

274Assert.Empty(reportedErrors);

154Assert.Empty(registry.ConnectedCircuits); 170Assert.Empty(registry.ConnectedCircuits.Values); 322Assert.Empty(registry.ConnectedCircuits.Values); 375Assert.Empty(registry.ConnectedCircuits.Values); 482Assert.Empty(registry.ConnectedCircuits);

253Assert.Empty(exceptions); 316Assert.Empty(exceptions); 372Assert.Empty(exceptions); 373Assert.Empty(renderer._unacknowledgedRenderBatches);

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

152Assert.Empty(secondDescriptor.Parameters.ToDictionary()); 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); 338Assert.Empty(secondDescriptor.Parameters.Parameters.ToDictionary());

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);

106Assert.Empty(activity.Links);

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

700Assert.Empty(navigationManager.ExceptionsThrownFromLocationChangingHandlers);

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

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

245Assert.Empty(callbacks); 285Assert.Empty(callbacks);

99Assert.Empty(provider.Subscriptions);

712Assert.Empty(renderer.HandledExceptions); 1784Assert.Empty(renderer.HandledExceptions); 1822Assert.Empty(renderer.HandledExceptions); 1864Assert.Empty(renderer.HandledExceptions); 2371Assert.Empty(renderer.HandledExceptions); 2411Assert.Empty(renderer.HandledExceptions); 2416Assert.Empty(renderer.HandledExceptions); 2455Assert.Empty(renderer.HandledExceptions); 2533Assert.Empty(renderer.HandledExceptions); 3020Assert.Empty(diff4.Edits); 4067Assert.Empty(renderer.HandledExceptions); 4102Assert.Empty(renderer.HandledExceptions); 4143Assert.Empty(renderer.HandledExceptions); 4179Assert.Empty(renderer.Batches); 4202Assert.Empty(renderer.Batches);

244Assert.Empty(ArrayPool.ReturnedBuffers);

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

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);

89Assert.Empty(_renderer.HandledExceptions);

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));

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

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

42Assert.Empty(eventData.Payload);

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

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);

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

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

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

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());

31Assert.Empty(options.KeyEscrowSinks);

346Assert.Empty(result);

331Assert.Empty(keys);

29Assert.Empty(context.KeyEscrowSinks);

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

58Assert.Empty(allElements);

45Assert.Empty(allElements);

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

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

268Assert.Empty(sensitiveParameters);

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

104Assert.Empty(context.Request.RouteValues); 143Assert.Empty(sink.Writes); 202Assert.Empty(sink.Writes); 240Assert.Empty(sink.Writes); 241Assert.Empty(metricsTagsFeature.Tags); 328Assert.Empty(diagnosticsRequestExceptionCollector.GetMeasurementSnapshot());

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

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);

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);

259Assert.Empty(request!.Sub.Subfields); 1301Assert.Empty(requestData!);

146Assert.Empty(resolvedSchema.Properties);

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

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

289Assert.Empty(context.MetricsTagsFeature.TagsList); 472Assert.Empty(requestDurationCollector.GetMeasurementSnapshot()); 527Assert.Empty(requestDurationCollector.GetMeasurementSnapshot()); 1122Assert.Empty(tags);

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

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

588Assert.Empty(directory);

116Assert.Empty(serverAddressesFeature.Addresses);

108Assert.Empty(content.Entries);

18Assert.Empty(dict); 19Assert.Empty(dict._arrayStorage); 31Assert.Empty(dict); 32Assert.Empty(dict._arrayStorage); 262Assert.Empty(dict); 277Assert.Empty(dict); 337Assert.Empty(dict); 409Assert.Empty(dict); 737Assert.Empty(keys); 782Assert.Empty(values); 961Assert.Empty(dict); 974Assert.Empty(dict); 989Assert.Empty(dict); 991Assert.Empty(dict._arrayStorage); 1007Assert.Empty(dict); 1333Assert.Empty(dict); 1353Assert.Empty(dict); 1435Assert.Empty(dict); 1465Assert.Empty(dict); 1480Assert.Empty(dict); 1516Assert.Empty(dict); 1534Assert.Empty(dict); 1578Assert.Empty(dict); 1611Assert.Empty(dict); 1628Assert.Empty(dict); 1667Assert.Empty(dict); 1687Assert.Empty(dict); 2116Assert.Empty(dictionary);

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

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

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

799Assert.Empty(TestSink.Writes); 2555Assert.Empty(result.EndpointMetadata); 2614Assert.Empty(result.EndpointMetadata);

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

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);

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

1014Assert.Empty(TestSink.Writes);

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

66Assert.Empty(metadata); 93Assert.Empty(endpoint.Metadata.OfType<IProducesResponseTypeMetadata>()); 118Assert.Empty(endpoint.Metadata.OfType<IProducesResponseTypeMetadata>());

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

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

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

47Assert.Empty(builder.ServerFeatures);

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

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

148Assert.Empty(queryCollection);

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

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

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

112Assert.Empty(TestSink.Writes); 766Assert.Empty(TestSink.Writes); 1099Assert.Empty(TestSink.Writes);

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

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

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

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

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

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

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

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

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"))));

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

79Assert.Empty(signInUserPrincipal.GetMeasurementSnapshot()); 422Assert.Empty(signInUserPrincipal.GetMeasurementSnapshot()); 901Assert.Empty(signInUserPrincipal.GetMeasurementSnapshot());

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

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

120Assert.Empty(dictionary); 122Assert.Empty(dictionary); 136Assert.Empty(dictionary); 138Assert.Empty(dictionary); 601Assert.Empty(item.Errors); 638Assert.Empty(modelState.Errors); 1296Assert.Empty(dictionary["Property1"].Errors); 1298Assert.Empty(dictionary["Property2"].Errors); 1302Assert.Empty(dictionary["Property4"].Errors); 1323Assert.Empty(dictionary["Product"].Errors); 1325Assert.Empty(dictionary["Product.Detail1"].Errors); 1327Assert.Empty(dictionary["Product.Detail2[0]"].Errors); 1329Assert.Empty(dictionary["Product.Detail2[1]"].Errors); 1331Assert.Empty(dictionary["Product.Detail2[2]"].Errors); 1333Assert.Empty(dictionary["Product.Detail3"].Errors); 1354Assert.Empty(dictionary["Product.Detail1"].Errors); 1356Assert.Empty(dictionary["Product.Detail1.Name"].Errors); 1377Assert.Empty(dictionary["Property1"].Errors); 1379Assert.Empty(dictionary["Property2"].Errors); 1381Assert.Empty(dictionary["Property3"].Errors); 1383Assert.Empty(dictionary["Property4"].Errors); 1394Assert.Empty(dictionary); 1418Assert.Empty(entry.Value.Errors); 1426Assert.Empty(entry.Value.Errors); 1434Assert.Empty(entry.Value.Errors); 1485Assert.Empty(keys); 1518Assert.Empty(values); 1540Assert.Empty(value.Errors); 1547Assert.Empty(value.Errors); 1554Assert.Empty(value.Errors);

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

55Assert.Empty(responseType.ApiResponseFormats); 62Assert.Empty(responseType.ApiResponseFormats); 133Assert.Empty(responseType.ApiResponseFormats); 178Assert.Empty(responseType.ApiResponseFormats); 185Assert.Empty(responseType.ApiResponseFormats); 236Assert.Empty(responseType.ApiResponseFormats); 244Assert.Empty(responseType.ApiResponseFormats); 332Assert.Empty(responseType.ApiResponseFormats); 380Assert.Empty(responseType.ApiResponseFormats); 567Assert.Empty(responseType.ApiResponseFormats); 573Assert.Empty(responseType.ApiResponseFormats); 605Assert.Empty(responseType.ApiResponseFormats); 621Assert.Empty(responseType.ApiResponseFormats); 809Assert.Empty(GetSortedMediaTypes(responseType));

75Assert.Empty(descriptions); 88Assert.Empty(descriptions); 296Assert.Empty(description.ParameterDescriptions); 468Assert.Empty(id1.RouteInfo.Constraints); 662Assert.Empty(description.SupportedResponseTypes); 744Assert.Empty(responseType.ApiResponseFormats); 847Assert.Empty(responseType.ApiResponseFormats); 917Assert.Empty(GetSortedMediaTypes(responseType)); 987Assert.Empty(GetSortedMediaTypes(responseType)); 1248Assert.Empty(description.SupportedRequestFormats); 1520Assert.Empty(description.ParameterDescriptions); 1534Assert.Empty(description.ParameterDescriptions);

42Assert.Empty(apiDescriptions); 176Assert.Empty(responseType.ApiResponseFormats); 274Assert.Empty(badRequestResponseType.ApiResponseFormats); 300Assert.Empty(badRequestResponseType.ApiResponseFormats); 594Assert.Empty(badRequestResponseType.ApiResponseFormats); 628Assert.Empty(badRequestResponseType.ApiResponseFormats); 822Assert.Empty(GetApiDescription((IInferredServiceInterface foo) => { }).ParameterDescriptions); 823Assert.Empty(GetApiDescription(([FromServices] InferredServiceClass foo) => { }).ParameterDescriptions); 824Assert.Empty(GetApiDescription(([CustomFromServices] InferredServiceClass foo) => { }).ParameterDescriptions); 825Assert.Empty(GetApiDescription(([FromKeyedServices("foo")] InferredServiceClass foo) => { }).ParameterDescriptions); 826Assert.Empty(GetApiDescription(([CustomFromKeyedServices("foo")] InferredServiceClass foo) => { }).ParameterDescriptions); 827Assert.Empty(GetApiDescription((HttpContext context) => { }).ParameterDescriptions); 828Assert.Empty(GetApiDescription((HttpRequest request) => { }).ParameterDescriptions); 829Assert.Empty(GetApiDescription((HttpResponse response) => { }).ParameterDescriptions); 830Assert.Empty(GetApiDescription((ClaimsPrincipal user) => { }).ParameterDescriptions); 831Assert.Empty(GetApiDescription((CancellationToken token) => { }).ParameterDescriptions); 832Assert.Empty(GetApiDescription((BindAsyncRecord context) => { }).ParameterDescriptions); 1142Assert.Empty(context.Results); 1635Assert.Empty(parameter.RouteInfo.Constraints);

80Assert.Empty(actionModel.Selectors[0].EndpointMetadata); 123Assert.Empty(actionModel.Selectors[0].EndpointMetadata); 154Assert.Empty(provider.ActionModelConventions.OfType<ClientErrorResultFilterConvention>()); 164Assert.Empty(provider.ActionModelConventions.OfType<InvalidModelStateFilterConvention>()); 174Assert.Empty(provider.ActionModelConventions.OfType<ConsumesConstraintForFormFileParameterConvention>()); 184Assert.Empty(provider.ActionModelConventions.OfType<InferParameterBindingInfoConvention>());

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

94Assert.Empty(property.Attributes); 146Assert.Empty(property.Attributes); 199Assert.Empty(parameter.Attributes); 429Assert.Empty(model.Filters); 759Assert.Empty(action.Attributes); 761Assert.Empty(action.Selectors[0].ActionConstraints.OfType<HttpMethodActionConstraint>()); 762Assert.Empty(GetAttributeRoutes(action.Selectors)); 785Assert.Empty(GetAttributeRoutes(action.Selectors)); 809Assert.Empty(GetAttributeRoutes(action.Selectors)); 834Assert.Empty(GetAttributeRoutes(action.Selectors)); 857Assert.Empty(GetAttributeRoutes(action.Selectors)); 902Assert.Empty(action.Selectors[0].ActionConstraints); 992Assert.Empty(action.Attributes); 994Assert.Empty(action.Selectors[0].ActionConstraints); 1016Assert.Empty(action.Selectors[0].ActionConstraints); 1017Assert.Empty(GetAttributeRoutes(action.Selectors)); 1018Assert.Empty(action.Attributes); 1300Assert.Empty(model.Actions);

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

25Assert.Empty(result);

32Assert.Empty(errors);

56Assert.Empty(endpointDataSource.Endpoints);

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

32Assert.Empty(errors);

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

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

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);

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

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

387Assert.Empty(result.ContentTypes);

234Assert.Empty(matches); 264Assert.Empty(matches);

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

229Assert.Empty(written);

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

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

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

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

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

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

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

184Assert.Empty(bindingContext.ModelState);

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

139Assert.Empty(bindingContext.ModelState);

192Assert.Empty(bindingContext.ModelState);

141Assert.Empty(bindingContext.ModelState);

102Assert.Empty(values);

113Assert.Empty(result);

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

26Assert.Empty(context.ValueProviders);

50Assert.Empty(context.ValueProviders);

94Assert.Empty(context.ValueProviders);

215Assert.Empty(defaultMetadata.Attributes.ParameterAttributes);

31Assert.Empty(metadata.AdditionalValues);

189Assert.Empty(attributes.ParameterAttributes);

654Assert.Empty(dictionary["Name"].Errors); 656Assert.Empty(dictionary["Id"].Errors); 658Assert.Empty(dictionary["Category"].Errors); 683Assert.Empty(dictionary[string.Empty].Errors); 714Assert.Empty(dictionary["[0].Name"].Errors); 716Assert.Empty(dictionary["[0].Id"].Errors); 718Assert.Empty(dictionary["[0].Category"].Errors); 720Assert.Empty(dictionary["[1].Name"].Errors); 722Assert.Empty(dictionary["[1].Id"].Errors); 724Assert.Empty(dictionary["[1].Category"].Errors); 763Assert.Empty(dictionary[entry].Errors); 1456Assert.Empty(list); 1472Assert.Empty(list);

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

26Assert.Empty(factoryContext.ValueProviders);

44Assert.Empty(entry.Errors); 71Assert.Empty(entry.Errors); 100Assert.Empty(entry.Errors); 127Assert.Empty(entry.Errors); 149Assert.Empty(modelState); 177Assert.Empty(entry.Errors); 181Assert.Empty(entry.Errors); 209Assert.Empty(entry.Errors); 213Assert.Empty(entry.Errors); 282Assert.Empty(entry.Errors); 286Assert.Empty(entry.Errors); 540Assert.Empty(entry.Value.Errors); 637Assert.Empty(entry.Errors); 668Assert.Empty(entry.Errors); 704Assert.Empty(entry.Errors); 774Assert.Empty(entry.Errors); 778Assert.Empty(entry.Errors); 930Assert.Empty(entry.Errors); 934Assert.Empty(entry.Errors); 938Assert.Empty(entry.Errors); 1006Assert.Empty(entry.Errors); 1010Assert.Empty(entry.Errors); 1014Assert.Empty(entry.Errors); 1018Assert.Empty(entry.Errors); 1054Assert.Empty(entry.Errors); 1058Assert.Empty(entry.Errors); 1153Assert.Empty(entry.Errors); 1183Assert.Empty(entry.Errors); 1216Assert.Empty(entry.Value.Errors);

163Assert.Empty(testSink.Writes);

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

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

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

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);

45Assert.Empty(endpoints);

44Assert.Empty(sink.Scopes);

78Assert.Empty(serializableError);

32Assert.Empty(errors);

18Assert.Empty(problemDescription.Errors);

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

88Assert.Empty(providerContext.Results);

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

80Assert.Empty(providerContext.Results);

132Assert.Empty(results);

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

51Assert.Empty(delegatingEnumerable);

21Assert.Empty(wrapper.SerializableError);

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

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

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

63Assert.Empty(result); 76Assert.Empty(result); 193Assert.Empty(parameter.RouteInfo.ConstraintTypes); 477Assert.Empty(responseType.ResponseFormats); 497Assert.Empty(responseType.ResponseFormats); 518Assert.Empty(description.SupportedResponseTypes); 1187Assert.Empty(description.ParameterDescriptions); 1208Assert.Empty(description.ParameterDescriptions); 1221Assert.Empty(description.ParameterDescriptions); 1345Assert.Empty(responseType.ResponseFormats); 1380Assert.Empty(responseType.ResponseFormats); 1415Assert.Empty(responseType.ResponseFormats); 1450Assert.Empty(responseType.ResponseFormats); 1490Assert.Empty(responseType.ResponseFormats); 1527Assert.Empty(responseType.ResponseFormats);

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

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);

210Assert.Empty(result);

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

75Assert.Empty(modelBindingInfo.ModelStateErrorMessages);

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);

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

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

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

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

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

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);

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);

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);

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

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

70Assert.Empty(modelState[key].Errors); 120Assert.Empty(value.Errors); 171Assert.Empty(value.Errors); 234Assert.Empty(value.Errors); 242Assert.Empty(value.Errors); 324Assert.Empty(value.Errors); 390Assert.Empty(value.Errors); 452Assert.Empty(value.Errors); 460Assert.Empty(value.Errors); 511Assert.Empty(modelStateEntry.Errors); 546Assert.Empty(modelState); 600Assert.Empty(modelStateEntry.Errors); 649Assert.Empty(entry.Value.Errors); 685Assert.Empty(modelState.Keys); 913Assert.Empty(house.Garage.Cars); 917Assert.Empty(modelState); 1119Assert.Empty(container.FormFiles);

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);

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);

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

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

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);

62Assert.Empty(modelState[key].Errors); 106Assert.Empty(modelState[key].Errors); 150Assert.Empty(modelState[key].Errors); 184Assert.Empty(modelState.Keys); 227Assert.Empty(modelState[key].Errors); 271Assert.Empty(modelState[key].Errors); 356Assert.Empty(modelState[key].Errors); 603Assert.Empty(modelState[key].Errors); 634Assert.Empty(modelState.Keys); 699Assert.Empty(entry.Errors); 745Assert.Empty(modelState[key].Errors); 789Assert.Empty(modelState[key].Errors);

56Assert.Empty(state.Errors); 90Assert.Empty(state.Errors); 200Assert.Empty(state.Errors); 241Assert.Empty(state.Errors); 282Assert.Empty(state.Errors); 343Assert.Empty(state.Errors); 447Assert.Empty(state.Errors); 495Assert.Empty(state.Errors); 526Assert.Empty(model.Address); 530Assert.Empty(modelState); 663Assert.Empty(state.Errors); 697Assert.Empty(state.Errors); 800Assert.Empty(state.Errors); 836Assert.Empty(state.Errors); 877Assert.Empty(state.Errors); 928Assert.Empty(state.Errors); 964Assert.Empty(state.Errors); 1012Assert.Empty(state.Errors); 1038Assert.Empty(model.Address); 1042Assert.Empty(modelState); 1080Assert.Empty(modelStateEntry.Errors); 1133Assert.Empty(state.Errors); 1204Assert.Empty(state.Errors); 1211Assert.Empty(state.Errors); 1259Assert.Empty(state.Errors); 1268Assert.Empty(state.Errors);

72Assert.Empty(modelStateErrors);

197Assert.Empty(entry.Errors); 286Assert.Empty(entry.Errors); 377Assert.Empty(entry.Errors); 469Assert.Empty(entry.Errors); 555Assert.Empty(entry.Errors); 713Assert.Empty(entry.Errors); 801Assert.Empty(entry.Errors); 871Assert.Empty(modelState); 936Assert.Empty(entry.Errors); 1043Assert.Empty(entry.Errors); 1131Assert.Empty(entry.Errors); 1199Assert.Empty(model); 1201Assert.Empty(modelState); 1492Assert.Empty(modelState); 2003Assert.Empty(modelState);

185Assert.Empty(entry.Errors); 267Assert.Empty(entry.Errors); 349Assert.Empty(entry.Errors); 434Assert.Empty(entry.Errors); 514Assert.Empty(entry.Errors); 596Assert.Empty(entry.Errors); 677Assert.Empty(entry.Errors); 747Assert.Empty(modelState); 805Assert.Empty(entry.Errors); 905Assert.Empty(entry.Errors); 989Assert.Empty(entry.Errors); 1057Assert.Empty(model); 1059Assert.Empty(modelState); 1336Assert.Empty(modelState); 1798Assert.Empty(modelState);

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

229Assert.Empty(written);

21Assert.Empty(tempDataDictionary);

58Assert.Empty(references);

28Assert.Empty(razorFiles);

23Assert.Empty(result1.ExpirationTokens);

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

68Assert.Empty(pageActivator.ActivationInfo);

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

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

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

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

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

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

61model => Assert.Empty(model.EndpointMetadata), 65Assert.Empty(model.Filters); 71Assert.Empty(model.Filters); 96model => Assert.Empty(model.Filters), 127model => Assert.Empty(model.Filters), 131Assert.Empty(model.Filters); 153model => Assert.Empty(model.Filters), 185Assert.Empty(model.Filters); 192Assert.Empty(model.Filters); 270Assert.Empty(model.Filters); 277Assert.Empty(model.Filters); 285Assert.Empty(model.Filters); 352model => Assert.Empty(model.EndpointMetadata), 353model => Assert.Empty(model.EndpointMetadata), 357Assert.Empty(model.Filters); 363Assert.Empty(model.Filters); 366model => Assert.Empty(model.EndpointMetadata)); 389model => Assert.Empty(model.Filters), 390model => Assert.Empty(model.Filters), 401model => Assert.Empty(model.Filters)); 422model => Assert.Empty(model.Filters), 426Assert.Empty(model.Filters); 430model => Assert.Empty(model.Filters)); 451model => Assert.Empty(model.Filters), 459model => Assert.Empty(model.Filters)); 479model => Assert.Empty(model.Filters), 483Assert.Empty(model.Filters); 506model => Assert.Empty(model.Filters), 533model => Assert.Empty(model.Filters), 537Assert.Empty(model.Filters); 560model => Assert.Empty(model.Filters), 588model => Assert.Empty(model.Filters), 592Assert.Empty(model.Filters); 596model => Assert.Empty(model.Filters)); 617model => Assert.Empty(model.Filters), 625model => Assert.Empty(model.Filters)); 648model => Assert.Empty(model.Filters), 652Assert.Empty(model.Filters); 659Assert.Empty(model.Filters); 685model => Assert.Empty(model.Filters), 722model => Assert.Empty(model.Filters), 723model => Assert.Empty(model.Filters), 727Assert.Empty(model.Filters); 734Assert.Empty(model.Filters); 738model => Assert.Empty(model.Filters)); 761model => Assert.Empty(model.Filters), 762model => Assert.Empty(model.Filters), 777model => Assert.Empty(model.Filters)); 800model => Assert.Empty(model.EndpointMetadata), 801model => Assert.Empty(model.EndpointMetadata), 805Assert.Empty(model.Filters); 812Assert.Empty(model.Filters); 816model => Assert.Empty(model.Filters)); 839model => Assert.Empty(model.Filters), 840model => Assert.Empty(model.Filters), 855model => Assert.Empty(model.Filters));

29Assert.Empty(context.Results);

46Assert.Empty(endpoints);

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

652Assert.Empty(arguments);

23Assert.Empty(context.Values);

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

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

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

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

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

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

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

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

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

287Assert.Empty(nestedItems);

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

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

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

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

28Assert.Empty(controller.Filters);

26Assert.Empty(controller.Filters);

21Assert.Empty(tempDataDictionary);

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

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

55Assert.Empty(tempDataDictionary);

20Assert.Empty(tempData);

25Assert.Empty(argumentDictionary);

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

26Assert.Empty(viewData);

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

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

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

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

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

60Assert.Empty(operation.Responses);

63Assert.Empty(actual.Diagnostic.Errors); 68Assert.Empty(errors); 96Assert.Empty(errors);

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

122Assert.Empty(servers); 146Assert.Empty(servers);

86Assert.Empty(operation.Parameters); 105Assert.Empty(operation.Parameters); 121Assert.Empty(operation.Parameters); 143Assert.Empty(operation.Parameters); 188Assert.Empty(response.Value.Content); 243Assert.Empty(badRequestResponseType.Content); 414Assert.Empty(GetOpenApiOperation((IInferredServiceInterface foo) => { }).Parameters); 415Assert.Empty(GetOpenApiOperation(([FromServices] int foo) => { }).Parameters); 416Assert.Empty(GetOpenApiOperation(([CustomFromServices] int foo) => { }).Parameters); 417Assert.Empty(GetOpenApiOperation(([FromKeyedServices("foo")] int foo) => { }).Parameters); 418Assert.Empty(GetOpenApiOperation(([CustomFromKeyedServices("foo")] int foo) => { }).Parameters); 419Assert.Empty(GetOpenApiOperation((HttpContext context) => { }).Parameters); 420Assert.Empty(GetOpenApiOperation((HttpRequest request) => { }).Parameters); 421Assert.Empty(GetOpenApiOperation((HttpResponse response) => { }).Parameters); 422Assert.Empty(GetOpenApiOperation((ClaimsPrincipal user) => { }).Parameters); 423Assert.Empty(GetOpenApiOperation((CancellationToken token) => { }).Parameters); 424Assert.Empty(GetOpenApiOperation((BindAsyncRecord context) => { }).Parameters); 437Assert.Empty(operation.Parameters); 677Assert.Empty(operation.Parameters); 706Assert.Empty(operation.Parameters); 724Assert.Empty(operation.Parameters); 740Assert.Empty(operation.Parameters); 756Assert.Empty(operation.Parameters); 772Assert.Empty(operation.Parameters); 788Assert.Empty(operation.Parameters); 804Assert.Empty(operation.Parameters); 826Assert.Empty(operation.Parameters); 858Assert.Empty(operation.Parameters); 883Assert.Empty(operation.Parameters); 945Assert.Empty(operationWithNoParams.Parameters);

26Assert.Empty(options.OperationTransformers); 27Assert.Empty(options.SchemaTransformers); 44Assert.Empty(options.OperationTransformers); 45Assert.Empty(options.SchemaTransformers); 61Assert.Empty(options.OperationTransformers); 62Assert.Empty(options.SchemaTransformers); 83Assert.Empty(options.DocumentTransformers); 84Assert.Empty(options.SchemaTransformers); 101Assert.Empty(options.DocumentTransformers); 102Assert.Empty(options.SchemaTransformers); 118Assert.Empty(options.DocumentTransformers); 119Assert.Empty(options.SchemaTransformers); 140Assert.Empty(options.DocumentTransformers); 141Assert.Empty(options.OperationTransformers); 158Assert.Empty(options.DocumentTransformers); 159Assert.Empty(options.OperationTransformers); 175Assert.Empty(options.DocumentTransformers); 176Assert.Empty(options.OperationTransformers);

40Assert.Empty(receivedSegments);

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);

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);

203Assert.Empty(owinEnvironment1);

50Assert.Empty(currentLeaseRequestsCollector.GetMeasurementSnapshot()); 51Assert.Empty(leaseRequestDurationCollector.GetMeasurementSnapshot()); 52Assert.Empty(currentRequestsQueuedCollector.GetMeasurementSnapshot()); 53Assert.Empty(queuedRequestDurationCollector.GetMeasurementSnapshot()); 98Assert.Empty(leaseRequestDurationCollector.GetMeasurementSnapshot()); 112Assert.Empty(currentRequestsQueuedCollector.GetMeasurementSnapshot()); 113Assert.Empty(queuedRequestDurationCollector.GetMeasurementSnapshot()); 162Assert.Empty(currentLeaseRequestsCollector.GetMeasurementSnapshot()); 223Assert.Empty(queuedRequestDurationCollector.GetMeasurementSnapshot()); 297Assert.Empty(currentRequestsQueuedCollector.GetMeasurementSnapshot()); 298Assert.Empty(queuedRequestDurationCollector.GetMeasurementSnapshot()); 306Assert.Empty(currentRequestsQueuedCollector.GetMeasurementSnapshot());

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

593Assert.Empty(attributes);

40Assert.Empty(context.AllAttributes);

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

48Assert.Empty(receivedSegments);

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);

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);

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

68Assert.Empty(metadata.ContentTypes);

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

18Assert.Empty(tree.Criteria); 19Assert.Empty(tree.Matches); 35Assert.Empty(tree.Criteria); 55Assert.Empty(tree.Matches); 62Assert.Empty(admin.Value.Matches); 69Assert.Empty(users.Value.Matches); 76Assert.Empty(addUser.Value.Criteria); 100Assert.Empty(tree.Matches); 106Assert.Empty(buy.Matches); 113Assert.Empty(store.Value.Criteria); 117Assert.Empty(checkout.Matches); 124Assert.Empty(store.Value.Criteria); 152Assert.Empty(tree.Matches); 185Assert.Empty(tree.Matches);

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

86Assert.Empty(sink.Scopes);

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

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

2647Assert.Empty(a.Matches); 2654Assert.Empty(a.Matches); 2692Assert.Empty(a.Matches); 2700Assert.Empty(test1_0.Matches); 2712Assert.Empty(test1_1.Matches); 2756Assert.Empty(a.Matches); 2800Assert.Empty(a.Matches); 2844Assert.Empty(a.Matches); 3201Assert.Empty(candidate.Slots); 3202Assert.Empty(candidate.Captures); 3204Assert.Empty(candidate.ComplexSegments); 3205Assert.Empty(candidate.Constraints); 3228Assert.Empty(candidate.ComplexSegments); 3229Assert.Empty(candidate.Constraints); 3258Assert.Empty(candidate.ComplexSegments); 3259Assert.Empty(candidate.Constraints); 3289Assert.Empty(candidate.ComplexSegments); 3290Assert.Empty(candidate.Constraints); 3321Assert.Empty(candidate.ComplexSegments); 3322Assert.Empty(candidate.Constraints); 3353Assert.Empty(candidate.Constraints); 3369Assert.Empty(candidate.Slots); 3370Assert.Empty(candidate.Captures); 3372Assert.Empty(candidate.ComplexSegments); 3458Assert.Empty(candidate.Slots); 3459Assert.Empty(candidate.Captures); 3461Assert.Empty(candidate.ComplexSegments); 3462Assert.Empty(candidate.Constraints);

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);

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

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

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);

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

408Assert.Empty(context.RouteData.Values); 612Assert.Empty(pathData.DataTokens); 644Assert.Empty(pathData.DataTokens); 677Assert.Empty(pathData.DataTokens); 695Assert.Empty(pathData.DataTokens); 713Assert.Empty(pathData.DataTokens); 731Assert.Empty(pathData.DataTokens); 749Assert.Empty(pathData.DataTokens); 848Assert.Empty(pathData.DataTokens); 864Assert.Empty(pathData.DataTokens); 905Assert.Empty(pathData.DataTokens); 946Assert.Empty(pathData.DataTokens); 980Assert.Empty(pathData.DataTokens); 1011Assert.Empty(pathData.DataTokens); 1042Assert.Empty(pathData.DataTokens); 1072Assert.Empty(pathData.DataTokens); 1103Assert.Empty(pathData.DataTokens); 1122Assert.Empty(pathData.DataTokens); 1154Assert.Empty(pathData.DataTokens); 1171Assert.Empty(pathData.DataTokens); 1203Assert.Empty(pathData.DataTokens); 1226Assert.Empty(pathData.DataTokens); 1248Assert.Empty(pathData.DataTokens); 1270Assert.Empty(pathData.DataTokens); 1292Assert.Empty(pathData.DataTokens); 1314Assert.Empty(pathData.DataTokens); 1336Assert.Empty(pathData.DataTokens); 1358Assert.Empty(pathData.DataTokens); 1380Assert.Empty(pathData.DataTokens); 1402Assert.Empty(pathData.DataTokens); 1426Assert.Empty(pathData.DataTokens); 1450Assert.Empty(pathData.DataTokens); 1474Assert.Empty(pathData.DataTokens); 1498Assert.Empty(pathData.DataTokens); 1599Assert.Empty(templateRoute.Constraints);

174Assert.Empty(foundEndpoints); 373Assert.Empty(addressScheme.State.MatchesWithRequiredValues); 396Assert.Empty(allMatches);

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

159Assert.Empty(matches); 181Assert.Empty(matches); 581Assert.Empty(matches); 606Assert.Empty(matches); 685Assert.Empty(matches); 710Assert.Empty(matches);

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);

822Assert.Empty(result.DataTokens); 845Assert.Empty(result.DataTokens); 877Assert.Empty(result.DataTokens); 909Assert.Empty(result.DataTokens); 944Assert.Empty(result.DataTokens); 990Assert.Empty(result.DataTokens); 1027Assert.Empty(result.DataTokens); 1057Assert.Empty(result.DataTokens); 1087Assert.Empty(result.DataTokens); 1145Assert.Empty(result.DataTokens); 1231Assert.Empty(result.DataTokens); 1251Assert.Empty(pathData.DataTokens); 1271Assert.Empty(pathData.DataTokens); 1308Assert.Empty(pathData.DataTokens); 1328Assert.Empty(pathData.DataTokens); 1348Assert.Empty(pathData.DataTokens); 1373Assert.Empty(pathData.DataTokens); 1393Assert.Empty(pathData.DataTokens); 1414Assert.Empty(pathData.DataTokens); 1452Assert.Empty(pathData.DataTokens); 1472Assert.Empty(pathData.DataTokens); 1494Assert.Empty(pathData.DataTokens); 1519Assert.Empty(pathData.DataTokens); 1544Assert.Empty(pathData.DataTokens); 1571Assert.Empty(pathData.DataTokens); 1598Assert.Empty(pathData.DataTokens); 1692Assert.Empty(pathData.DataTokens); 1810Assert.Empty(context.RouteData.Routers); 1852Assert.Empty(context.RouteData.Routers); 1915Assert.Empty(pathData.DataTokens); 1937Assert.Empty(pathData.DataTokens); 1959Assert.Empty(pathData.DataTokens); 1981Assert.Empty(pathData.DataTokens);

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

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

172Assert.Empty(requestHeaders.GetValues("If-None-Match")); 197Assert.Empty(requestHeaders.GetValues("Custom-Header"));

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

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

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

615Assert.Empty(addressesFeature.Addresses); 616Assert.Empty(attachedServer.Listener.Options.UrlPrefixes);

133Assert.Empty(_http1Connection.RequestHeaders); 879Assert.Empty(_http1Connection.RequestHeaders); 911Assert.Empty(_http1Connection.RequestHeaders);

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

25Assert.Empty(headers); 323Assert.Empty(headers); 361Assert.Empty(headers); 770Assert.Empty(headers); 782Assert.Empty(headers); 818Assert.Empty(headers); 829Assert.Empty(headers);

49Assert.Empty(headers);

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

60Assert.Empty(dict);

239Assert.Empty(currentMemoryMetric.GetMeasurementSnapshot()); 280Assert.Empty(totalMemoryMetric.GetMeasurementSnapshot()); 315Assert.Empty(rentMetric.GetMeasurementSnapshot()); 360Assert.Empty(evictMetric.GetMeasurementSnapshot());

922Assert.Empty(propertyNames);

179Assert.Empty(_handler.DecodedHeaders); 255Assert.Empty(_handler.DecodedHeaders); 279Assert.Empty(_handler.DecodedHeaders); 303Assert.Empty(_handler.DecodedHeaders); 327Assert.Empty(_handler.DecodedHeaders); 373Assert.Empty(_handler.DecodedHeaders); 405Assert.Empty(_handler.DecodedHeaders); 500Assert.Empty(_handler.DecodedHeaders); 609Assert.Empty(_handler.DecodedHeaders); 666Assert.Empty(_handler.DecodedHeaders); 678Assert.Empty(_handler.DecodedHeaders); 869Assert.Empty(_handler.DecodedHeaders); 904Assert.Empty(_handler.DecodedHeaders);

297Assert.Empty(_handler.DecodedHeaders);

50Assert.Empty(host.Services.GetRequiredService<IServer>().Features.Get<IServerAddressesFeature>().Addresses);

85Assert.Empty(serverOptions.GetListenOptions()); 102Assert.Empty(serverOptions.GetListenOptions()); 130Assert.Empty(serverOptions.GetListenOptions()); 2011Assert.Empty(serverOptions.ConfigurationBackedListenOptions); 2024Assert.Empty(serverOptions.ConfigurationBackedListenOptions); 2043Assert.Empty(serverOptions.ConfigurationBackedListenOptions); 2050Assert.Empty(serverOptions.ConfigurationBackedListenOptions); 2129Assert.Empty(serverOptions.GetListenOptions());

369Assert.Empty(connectionListener._pendingConnections);

827Assert.Empty(sink.Writes);

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);

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

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

74Assert.Empty(Parse(queryString));

179Assert.Empty(_handler.DecodedHeaders); 255Assert.Empty(_handler.DecodedHeaders); 279Assert.Empty(_handler.DecodedHeaders); 303Assert.Empty(_handler.DecodedHeaders); 327Assert.Empty(_handler.DecodedHeaders); 373Assert.Empty(_handler.DecodedHeaders); 405Assert.Empty(_handler.DecodedHeaders); 500Assert.Empty(_handler.DecodedHeaders); 609Assert.Empty(_handler.DecodedHeaders); 666Assert.Empty(_handler.DecodedHeaders); 678Assert.Empty(_handler.DecodedHeaders); 869Assert.Empty(_handler.DecodedHeaders); 904Assert.Empty(_handler.DecodedHeaders);

297Assert.Empty(_handler.DecodedHeaders);

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

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

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

123Assert.Empty(testValues);

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

33Assert.Empty(data); 45Assert.Empty(data);

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

17Assert.Empty(hubMethods);

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

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

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

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

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

224Assert.Empty(response.TrailingHeaders); 231Assert.Empty(response.TrailingHeaders); 240Assert.Empty(response.TrailingHeaders);

163Assert.Empty(buffer.Pages);

101Assert.Empty(collection);

1323Assert.Empty(previewOperations.OfType<TestSymbolRenamedCodeActionOperationFactoryWorkspaceService.Operation>()); 1348Assert.Empty(previewOperations.OfType<TestSymbolRenamedCodeActionOperationFactoryWorkspaceService.Operation>()); 1378Assert.Empty(previewOperations.OfType<TestSymbolRenamedCodeActionOperationFactoryWorkspaceService.Operation>());

47Assert.Empty(changedDocs); 59Assert.Empty(actions);

2328Assert.Empty(parsedArgs.EmbeddedFiles); 2472Assert.Empty(expectedEmbeddedMap); 2549Assert.Empty(fileMap); 2552Assert.Empty(expectedFilesMap); 2711Assert.Empty(parsedArgs.Errors); 3044Assert.Empty(errors); 3076Assert.Empty(errors); 3109Assert.Empty(errors); 3142Assert.Empty(errors); 3176Assert.Empty(errors); 3210Assert.Empty(errors); 3244Assert.Empty(errors); 3278Assert.Empty(errors); 3313Assert.Empty(errors); 3348Assert.Empty(errors); 3372Assert.Empty(errors); 3405Assert.Empty(errors); 3438Assert.Empty(errors); 3472Assert.Empty(errors); 6495Assert.Empty(diagnostics); 12385Assert.Empty(((CSharpParseOptions)options).InterceptorsNamespaces);

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

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

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

290Assert.Empty(items);

156Assert.Empty(exceptions);

92Assert.Empty(spans3);

35Assert.Empty(results);

33Assert.Empty(await _aggregator.GetItemsAsync("Hello")); 614Assert.Empty(items); 646Assert.Empty(items);

1286Assert.Empty(actions);

33Assert.Empty(await _aggregator.GetItemsAsync("Hello")); 340Assert.Empty(await _aggregator.GetItemsAsync("ar")); 371Assert.Empty(await _aggregator.GetItemsAsync("ar")); 974Assert.Empty(items); 1003Assert.Empty(items);

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

361Assert.Empty(workspace.CurrentSolution.Projects); 393Assert.Empty(workspace.CurrentSolution.Projects.Single().Documents); 1196Assert.Empty(workspace.GetOpenDocumentIds()); 1201Assert.Empty(workspace.GetOpenDocumentIds()); 1225Assert.Empty(workspace.GetOpenDocumentIds()); 1230Assert.Empty(workspace.GetOpenDocumentIds());

214Assert.Empty(tree.Diagnostics);

28Assert.Empty(tree.Diagnostics); 38Assert.Empty(tree.Diagnostics);

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

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

399Assert.Empty(test.GetTypeMembers()); 2046Assert.Empty(stateMachine.GetMembers().Where(m => m.Name.StartsWith("<x>"))); 2105Assert.Empty(stateMachine.GetMembers().Where(m => m.Name.StartsWith("<x>")));

272Assert.Empty(nested[0].Nested); 276Assert.Empty(nested[1].Nested); 282Assert.Empty(defaultInfo.Nested); 316Assert.Empty(deconstructionInfo.Nested); 1122Assert.Empty(nested[0].Nested); 1126Assert.Empty(nested[1].Nested); 1614Assert.Empty(names.Where(name => name.Contains("ValueTuple"))); 2302Assert.Empty(nested[0].Nested); 2315Assert.Empty(nested2[0].Nested); 2319Assert.Empty(nested2[1].Nested); 4053Assert.Empty(nested[0].Nested); 4057Assert.Empty(nested[1].Nested); 6182Assert.Empty(GetDiscardIdentifiers(tree)); 6212Assert.Empty(GetDiscardIdentifiers(tree)); 7311Assert.Empty(symbolInfo.CandidateSymbols); 7318Assert.Empty(symbolInfo.CandidateSymbols); 9014Assert.Empty(info.Nested);

5470Assert.Empty(field.GetAttributes()); 5556Assert.Empty(f.GetAttributes()); 7690Assert.Empty(funcPtrWithTestOnReturn.Signature.GetCallingConventionModifiers()); 7691Assert.Empty(funcPtrWithTestOnRef.Signature.GetCallingConventionModifiers()); 7775Assert.Empty(funcPtrWithTestOnReturn.Signature.GetCallingConventionModifiers()); 7776Assert.Empty(funcPtrWithTestOnRef.Signature.GetCallingConventionModifiers()); 8069Assert.Empty(unmanagedData!.CallingConventionTypes); 8745Assert.Empty(unmanagedData!.CallingConventionTypes); 10340Assert.Empty(m.GetUnmanagedCallersOnlyAttributeData(forceComplete: true)!.CallingConventionTypes); 11678Assert.Empty(attr.NamedArguments); 11741Assert.Empty(attr.NamedArguments); 11804Assert.Empty(attr.NamedArguments); 11863Assert.Empty(attr.NamedArguments); 11897Assert.Empty(attr.NamedArguments); 12138Assert.Empty(attr.NamedArguments); 12281Assert.Empty(attr.NamedArguments); 12320Assert.Empty(attr.NamedArguments); 12368Assert.Empty(attr.NamedArguments);

5290Assert.Empty(attrs[0].ConstructorArguments); 5291Assert.Empty(attrs[1].ConstructorArguments); 5362Assert.Empty(localFn1.GetReturnTypeAttributes()); 5366Assert.Empty(param.GetAttributes()); 5429Assert.Empty(localFn1.GetReturnTypeAttributes()); 5432Assert.Empty(param.GetAttributes()); 5648Assert.Empty(localFn1.GetReturnTypeAttributes()); 5649Assert.Empty(localFn1.TypeParameters.Single().GetAttributes()); 5650Assert.Empty(localFn1.Parameters.Single().GetAttributes());

4151Assert.Empty(paramArrayAttributes);

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

5823Assert.Empty(ElementTypeNames(tupleWithoutNames)); 24479Assert.Empty(derivedSymbol.GetSymbol().AsUnboundGenericType().AllInterfaces()); 27980Assert.Empty(retargetingValueTupleType.GetFieldsToEmit()); 27992Assert.Empty(type.GetFieldsToEmit()); 28075Assert.Empty(type.GetFieldsToEmit()); 28284Assert.Empty(item.DeclaringSyntaxReferences); 28364Assert.Empty(item.DeclaringSyntaxReferences); 28450Assert.Empty(item.DeclaringSyntaxReferences); 28971Assert.Empty(field.GetAttributes());

4641Assert.Empty(result.Diagnostics);

1029Assert.Empty(type.GetMembers(".cctor"));

1307Assert.Empty(attribute.AttributeConstructor.Parameters);

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

51Assert.Empty(m.Parameters[0].GetAttributes()); 1656Assert.Empty(parameter.TypeWithAnnotations.CustomModifiers); 1676Assert.Empty(parameter.TypeWithAnnotations.CustomModifiers); 1697Assert.Empty(method.ReturnTypeWithAnnotations.CustomModifiers); 1717Assert.Empty(method.ReturnTypeWithAnnotations.CustomModifiers); 1738Assert.Empty(method.ReturnTypeWithAnnotations.CustomModifiers); 1759Assert.Empty(method.ReturnTypeWithAnnotations.CustomModifiers); 1780Assert.Empty(property.TypeWithAnnotations.CustomModifiers); 1800Assert.Empty(property.TypeWithAnnotations.CustomModifiers); 1821Assert.Empty(property.TypeWithAnnotations.CustomModifiers); 1842Assert.Empty(property.TypeWithAnnotations.CustomModifiers); 1862Assert.Empty(parameter.TypeWithAnnotations.CustomModifiers); 1882Assert.Empty(parameter.TypeWithAnnotations.CustomModifiers); 1903Assert.Empty(indexer.TypeWithAnnotations.CustomModifiers); 1923Assert.Empty(indexer.TypeWithAnnotations.CustomModifiers); 1945Assert.Empty(indexer.TypeWithAnnotations.CustomModifiers); 1962Assert.Empty(invokeParameter.TypeWithAnnotations.CustomModifiers); 1966Assert.Empty(beginInvokeParameter.TypeWithAnnotations.CustomModifiers); 1970Assert.Empty(endInvokeParameter.TypeWithAnnotations.CustomModifiers); 1987Assert.Empty(invokeMethod.ReturnTypeWithAnnotations.CustomModifiers); 1991Assert.Empty(endInvokeMethod.ReturnTypeWithAnnotations.CustomModifiers); 2011Assert.Empty(parameter.TypeWithAnnotations.CustomModifiers); 2012Assert.Empty(parameter.RefCustomModifiers); 2031Assert.Empty(parameter.TypeWithAnnotations.CustomModifiers); 2032Assert.Empty(parameter.RefCustomModifiers); 2051Assert.Empty(parameter.TypeWithAnnotations.CustomModifiers); 2052Assert.Empty(parameter.RefCustomModifiers); 2071Assert.Empty(parameter.TypeWithAnnotations.CustomModifiers); 2072Assert.Empty(parameter.RefCustomModifiers); 2092Assert.Empty(parameters[0].TypeWithAnnotations.CustomModifiers); 2093Assert.Empty(parameters[0].RefCustomModifiers); 2095Assert.Empty(parameters[1].TypeWithAnnotations.CustomModifiers); 2096Assert.Empty(parameters[1].RefCustomModifiers); 2115Assert.Empty(parameter.TypeWithAnnotations.CustomModifiers); 2116Assert.Empty(parameter.RefCustomModifiers); 2502Assert.Empty(parameter.TypeWithAnnotations.CustomModifiers); 2528Assert.Empty(parameter.TypeWithAnnotations.CustomModifiers); 2550Assert.Empty(parameter.TypeWithAnnotations.CustomModifiers); 2575Assert.Empty(parameter.TypeWithAnnotations.CustomModifiers); 2597Assert.Empty(parameter.TypeWithAnnotations.CustomModifiers); 2623Assert.Empty(implicitParameter.TypeWithAnnotations.CustomModifiers); 2624Assert.Empty(implicitParameter.RefCustomModifiers); 2630Assert.Empty(explicitParameter.TypeWithAnnotations.CustomModifiers); 2652Assert.Empty(parameter.TypeWithAnnotations.CustomModifiers); 2678Assert.Empty(parameter.TypeWithAnnotations.CustomModifiers); 2700Assert.Empty(parameter.TypeWithAnnotations.CustomModifiers); 2725Assert.Empty(parameter.TypeWithAnnotations.CustomModifiers); 2747Assert.Empty(method.ReturnTypeWithAnnotations.CustomModifiers); 2770Assert.Empty(method.ReturnTypeWithAnnotations.CustomModifiers); 2792Assert.Empty(method.ReturnTypeWithAnnotations.CustomModifiers); 2815Assert.Empty(method.ReturnTypeWithAnnotations.CustomModifiers); 2837Assert.Empty(method.ReturnTypeWithAnnotations.CustomModifiers); 2860Assert.Empty(implicitMethod.ReturnTypeWithAnnotations.CustomModifiers); 2882Assert.Empty(implicitMethod.ReturnTypeWithAnnotations.CustomModifiers); 2905Assert.Empty(implicitMethod.ReturnTypeWithAnnotations.CustomModifiers); 2927Assert.Empty(implicitMethod.ReturnTypeWithAnnotations.CustomModifiers); 2950Assert.Empty(implicitMethod.ReturnTypeWithAnnotations.CustomModifiers); 2972Assert.Empty(property.TypeWithAnnotations.CustomModifiers); 2995Assert.Empty(property.TypeWithAnnotations.CustomModifiers); 3017Assert.Empty(property.TypeWithAnnotations.CustomModifiers); 3041Assert.Empty(property.TypeWithAnnotations.CustomModifiers); 3063Assert.Empty(property.TypeWithAnnotations.CustomModifiers); 3087Assert.Empty(implicitproperty.TypeWithAnnotations.CustomModifiers); 3109Assert.Empty(property.TypeWithAnnotations.CustomModifiers); 3133Assert.Empty(property.TypeWithAnnotations.CustomModifiers); 3155Assert.Empty(property.TypeWithAnnotations.CustomModifiers); 3179Assert.Empty(property.TypeWithAnnotations.CustomModifiers); 3201Assert.Empty(parameter.TypeWithAnnotations.CustomModifiers); 3227Assert.Empty(parameter.TypeWithAnnotations.CustomModifiers); 3249Assert.Empty(parameter.TypeWithAnnotations.CustomModifiers); 3275Assert.Empty(parameter.TypeWithAnnotations.CustomModifiers); 3297Assert.Empty(parameter.TypeWithAnnotations.CustomModifiers); 3323Assert.Empty(implicitParameter.TypeWithAnnotations.CustomModifiers); 3324Assert.Empty(implicitParameter.RefCustomModifiers); 3330Assert.Empty(explicitParameter.TypeWithAnnotations.CustomModifiers); 3352Assert.Empty(parameter.TypeWithAnnotations.CustomModifiers); 3378Assert.Empty(parameter.TypeWithAnnotations.CustomModifiers); 3400Assert.Empty(parameter.TypeWithAnnotations.CustomModifiers); 3426Assert.Empty(parameter.TypeWithAnnotations.CustomModifiers); 3448Assert.Empty(indexer.TypeWithAnnotations.CustomModifiers); 3472Assert.Empty(indexer.TypeWithAnnotations.CustomModifiers); 3494Assert.Empty(indexer.TypeWithAnnotations.CustomModifiers); 3518Assert.Empty(indexer.TypeWithAnnotations.CustomModifiers); 3540Assert.Empty(indexer.TypeWithAnnotations.CustomModifiers); 3564Assert.Empty(indexer.TypeWithAnnotations.CustomModifiers); 3586Assert.Empty(indexer.TypeWithAnnotations.CustomModifiers); 3610Assert.Empty(indexer.TypeWithAnnotations.CustomModifiers); 3632Assert.Empty(indexer.TypeWithAnnotations.CustomModifiers); 3656Assert.Empty(indexer.TypeWithAnnotations.CustomModifiers); 3673Assert.Empty(parameter.TypeWithAnnotations.CustomModifiers); 3706Assert.Empty(method.ReturnTypeWithAnnotations.CustomModifiers); 3745Assert.Empty(parameter.TypeWithAnnotations.CustomModifiers); 3787Assert.Empty(method.ReturnTypeWithAnnotations.CustomModifiers); 3835Assert.Empty(interfaceMethod.ReturnTypeWithAnnotations.CustomModifiers); 3840Assert.Empty(classMethod.ReturnTypeWithAnnotations.CustomModifiers); 3841Assert.Empty(classMethod.RefCustomModifiers); 3864Assert.Empty(parentMethod.ReturnTypeWithAnnotations.CustomModifiers); 3869Assert.Empty(classMethod.ReturnTypeWithAnnotations.CustomModifiers); 3870Assert.Empty(classMethod.RefCustomModifiers); 4503Assert.Empty(parentMethod.Parameters.Single().RefCustomModifiers); 4508Assert.Empty(childMethod.Parameters.Single().RefCustomModifiers); 4546Assert.Empty(parentMethod.Parameters.Single().RefCustomModifiers);

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

776Assert.Empty(result.Arguments); 786Assert.Empty(result.Arguments); 1030Assert.Empty(arguments0[2].Values); 1069Assert.Empty(attrs[0].ConstructorArguments); 1070Assert.Empty(attrs[1].ConstructorArguments); 1804Assert.Empty(prop1.GetAttributes()); 1812Assert.Empty(prop2.GetAttributes()); 1858Assert.Empty(field1.GetAttributes()); 1898Assert.Empty(prop1.GetAttributes()); 1913Assert.Empty(prop2.GetAttributes()); 1927Assert.Empty(GetAttributeStrings(attributes3)); 1960Assert.Empty(prop1.GetAttributes()); 1975Assert.Empty(prop2.GetAttributes()); 1989Assert.Empty(GetAttributeStrings(attributes3)); 2199Assert.Empty(prop1.GetAttributes()); 2206Assert.Empty(prop2.GetAttributes()); 2248Assert.Empty(prop1.GetAttributes()); 2262Assert.Empty(prop2.GetAttributes()); 2274Assert.Empty(GetAttributeStrings(field3.GetAttributes())); 2330Assert.Empty(prop1.GetAttributes()); 2340Assert.Empty(prop2.GetAttributes()); 2474Assert.Empty(prop2.GetAttributes()); 4647Assert.Empty(attr.NamedArguments); 4679Assert.Empty(attr.ConstructorArguments); 4712Assert.Empty(attr.NamedArguments); 4744Assert.Empty(attr.ConstructorArguments); 4780Assert.Empty(attr.NamedArguments); 4811Assert.Empty(attr.NamedArguments); 4837Assert.Empty(attr.NamedArguments); 4869Assert.Empty(attr.NamedArguments); 5830Assert.Empty(classTypeParameter.GetAttributes());

32Assert.Empty(other.GetDiagnostics()); 145Assert.Empty(other.GetDiagnostics()); 155Assert.Empty(other.GetDiagnostics()); 165Assert.Empty(other.GetDiagnostics()); 268Assert.Empty(other.GetDiagnostics()); 278Assert.Empty(other.GetDiagnostics()); 288Assert.Empty(other.GetDiagnostics()); 298Assert.Empty(other.GetDiagnostics()); 519Assert.Empty(other.GetDiagnostics()); 525Assert.Empty(other.GetDiagnostics()); 535Assert.Empty(other.GetDiagnostics()); 545Assert.Empty(other.GetDiagnostics()); 555Assert.Empty(other.GetDiagnostics()); 561Assert.Empty(other.GetDiagnostics()); 870Assert.Empty(comp.GetDiagnostics()); 893Assert.Empty(comp.GetDiagnostics());

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

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

41Assert.Empty(type.GetAttributes()); 60Assert.Empty(type.GetAttributes()); 78Assert.Empty(type.GetAttributes()); 96Assert.Empty(type.GetAttributes()); 114Assert.Empty(type.GetAttributes()); 140Assert.Empty(type.GetAttributes()); 436Assert.Empty(type.GetAttributes());

44Assert.Empty(parameter.GetAttributes()); 45Assert.Empty(method.GetReturnTypeAttributes()); 69Assert.Empty(parameter.GetAttributes()); 95Assert.Empty(method.GetReturnTypeAttributes()); 126Assert.Empty(parameter.GetAttributes()); 127Assert.Empty(method.GetReturnTypeAttributes()); 155Assert.Empty(parameter.GetAttributes()); 177Assert.Empty(parameter.GetAttributes()); 207Assert.Empty(parameter.GetAttributes()); 234Assert.Empty(parameter.GetAttributes()); 251Assert.Empty(parameter.GetAttributes()); 278Assert.Empty(parameter.GetAttributes()); 313Assert.Empty(property.GetAttributes()); 342Assert.Empty(property.GetAttributes()); 378Assert.Empty(property.GetAttributes()); 408Assert.Empty(parameter.GetAttributes()); 409Assert.Empty(indexer.GetAttributes()); 428Assert.Empty(parameter.GetAttributes()); 449Assert.Empty(indexer.GetAttributes()); 480Assert.Empty(parameter.GetAttributes()); 481Assert.Empty(indexer.GetAttributes()); 507Assert.Empty(parameter.GetAttributes()); 508Assert.Empty(method.GetReturnTypeAttributes()); 523Assert.Empty(parameter.GetAttributes()); 539Assert.Empty(method.GetReturnTypeAttributes()); 567Assert.Empty(parameter.GetAttributes()); 568Assert.Empty(method.GetReturnTypeAttributes()); 604Assert.Empty(parameter.GetAttributes()); 605Assert.Empty(method.GetReturnTypeAttributes()); 627Assert.Empty(parameter.GetAttributes()); 655Assert.Empty(method.GetReturnTypeAttributes()); 692Assert.Empty(parameter.GetAttributes()); 693Assert.Empty(method.GetReturnTypeAttributes()); 731Assert.Empty(parameter.GetAttributes()); 732Assert.Empty(method.GetReturnTypeAttributes()); 758Assert.Empty(parameter.GetAttributes()); 786Assert.Empty(method.GetReturnTypeAttributes()); 825Assert.Empty(parameter.GetAttributes()); 826Assert.Empty(method.GetReturnTypeAttributes()); 1162Assert.Empty(parameter.GetAttributes()); 1305Assert.Empty(property.GetAttributes()); 1309Assert.Empty(method.GetReturnTypeAttributes()); 1313Assert.Empty(parameter.GetAttributes()); 1342Assert.Empty(property.GetAttributes()); 1346Assert.Empty(method.GetReturnTypeAttributes()); 1350Assert.Empty(parameter.GetAttributes()); 1386Assert.Empty(result.CandidateSymbols); 1428Assert.Empty(result.CandidateSymbols); 1592Assert.Empty(method.GetReturnTypeAttributes()); 1593Assert.Empty(method.Parameters.Single().GetAttributes()); 1596Assert.Empty(@operator.Parameters[0].GetAttributes()); 1597Assert.Empty(@operator.Parameters[1].GetAttributes()); 1600Assert.Empty(property.GetAttributes()); 1603Assert.Empty(indexer.GetAttributes()); 1604Assert.Empty(indexer.Parameters.Single().GetAttributes()); 1634Assert.Empty(method.GetReturnTypeAttributes()); 1635Assert.Empty(method.Parameters.Single().GetAttributes()); 1638Assert.Empty(@operator.Parameters[0].GetAttributes()); 1639Assert.Empty(@operator.Parameters[1].GetAttributes()); 1642Assert.Empty(property.GetAttributes()); 1645Assert.Empty(indexer.GetAttributes()); 1646Assert.Empty(indexer.Parameters.Single().GetAttributes()); 1678Assert.Empty(method.GetReturnTypeAttributes()); 1679Assert.Empty(method.Parameters.Single().GetAttributes()); 1682Assert.Empty(@operator.Parameters[0].GetAttributes()); 1683Assert.Empty(@operator.Parameters[1].GetAttributes()); 1686Assert.Empty(property.GetAttributes()); 1689Assert.Empty(indexer.GetAttributes()); 1690Assert.Empty(indexer.Parameters.Single().GetAttributes()); 1727Assert.Empty(method.GetReturnTypeAttributes()); 1728Assert.Empty(method.Parameters.Single().GetAttributes()); 1731Assert.Empty(property.GetAttributes()); 1734Assert.Empty(indexer.GetAttributes()); 1735Assert.Empty(indexer.Parameters.Single().GetAttributes()); 1774Assert.Empty(method.GetReturnTypeAttributes()); 1775Assert.Empty(method.Parameters.Single().GetAttributes()); 1778Assert.Empty(property.GetAttributes()); 1781Assert.Empty(indexer.GetAttributes()); 1782Assert.Empty(indexer.Parameters.Single().GetAttributes()); 1818Assert.Empty(method.GetReturnTypeAttributes()); 1819Assert.Empty(method.Parameters.Single().GetAttributes()); 1822Assert.Empty(property.GetAttributes()); 1825Assert.Empty(indexer.GetAttributes()); 1826Assert.Empty(indexer.Parameters.Single().GetAttributes()); 1867Assert.Empty(method.GetReturnTypeAttributes()); 1868Assert.Empty(method.Parameters.Single().GetAttributes()); 1871Assert.Empty(property.GetAttributes()); 1874Assert.Empty(indexer.GetAttributes()); 1875Assert.Empty(indexer.Parameters.Single().GetAttributes()); 1907Assert.Empty(method.GetReturnTypeAttributes()); 1908Assert.Empty(method.Parameters.Single().GetAttributes()); 1911Assert.Empty(@operator.Parameters[0].GetAttributes()); 1912Assert.Empty(@operator.Parameters[1].GetAttributes()); 1915Assert.Empty(property.GetAttributes()); 1918Assert.Empty(indexer.GetAttributes()); 1919Assert.Empty(indexer.Parameters.Single().GetAttributes()); 1976Assert.Empty(method.GetReturnTypeAttributes()); 1977Assert.Empty(method.Parameters.Single().GetAttributes()); 1980Assert.Empty(property.GetAttributes()); 1983Assert.Empty(indexer.GetAttributes()); 1984Assert.Empty(indexer.Parameters.Single().GetAttributes()); 2025Assert.Empty(method.GetReturnTypeAttributes()); 2026Assert.Empty(method.Parameters.Single().GetAttributes()); 2029Assert.Empty(property.GetAttributes()); 2032Assert.Empty(indexer.GetAttributes()); 2033Assert.Empty(indexer.Parameters.Single().GetAttributes()); 2065Assert.Empty(method.GetReturnTypeAttributes()); 2066Assert.Empty(method.Parameters.Single().GetAttributes()); 2069Assert.Empty(property.GetAttributes()); 2072Assert.Empty(indexer.GetAttributes()); 2073Assert.Empty(indexer.Parameters.Single().GetAttributes()); 2107Assert.Empty(method.GetReturnTypeAttributes()); 2108Assert.Empty(method.Parameters.Single().GetAttributes()); 2111Assert.Empty(property.GetAttributes()); 2114Assert.Empty(indexer.GetAttributes()); 2115Assert.Empty(indexer.Parameters.Single().GetAttributes());

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)); 583Assert.Empty(baseMethodWrapper.GetReturnTypeAttributes()); 586Assert.Empty(parameter.GetAttributes()); 626Assert.Empty(baseMethodWrapper.GetReturnTypeAttributes()); 629Assert.Empty(parameter.GetAttributes()); 632Assert.Empty(typeParameter.GetAttributes()); 703Assert.Empty(ctor[1].GetAttributes()); // shouldn't have attribute. 709Assert.Empty(myProperty.GetAttributes()); 763Assert.Empty(ctor.GetAttributes()); 766Assert.Empty(myProperty.GetAttributes()); 845Assert.Empty(ctor[0].GetAttributes()); 854Assert.Empty(p1.GetAttributes()); 885Assert.Empty(ctor[0].GetAttributes()); 886Assert.Empty(ctor[1].GetAttributes()); 918Assert.Empty(p1.GetAttributes()); 946Assert.Empty(ctor.GetAttributes()); 949Assert.Empty(toString.GetAttributes()); 952Assert.Empty(op_Equality.GetAttributes()); 955Assert.Empty(op_Inequality.GetAttributes()); 958Assert.Empty(getHashCode.GetAttributes()); 962Assert.Empty(equals[0].GetAttributes()); 963Assert.Empty(equals[1].GetAttributes()); 1616Assert.Empty(unverifiableCode.AttributeConstructor.Parameters); 1617Assert.Empty(unverifiableCode.CommonConstructorArguments); 1618Assert.Empty(unverifiableCode.CommonNamedArguments); 1816Assert.Empty(asyncMethod.GetAttributes()); 1907Assert.Empty(type.GetMember<MethodSymbol>("F").GetAttributes());

501Assert.Empty(field7.Type.TupleElementTypesWithAnnotations); 622Assert.Empty(synthesizedTupleElementNamesAttr);

5079Assert.Empty(noParamsParameter.GetAttributes());

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());

102Assert.Empty(paramArrayAttributes);

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); 3971Assert.Empty(applicableDiagnostics); 3993Assert.Empty(diagnostics); 4234Assert.Empty(analyzer.CanceledCompilations);

1050Assert.Empty(result.SyntaxDiagnostics); 1209Assert.Empty(diagnosticsByAnalyzerMap); 1271Assert.Empty(result.SemanticDiagnostics); 1277Assert.Empty(result.SyntaxDiagnostics); 1650Assert.Empty(syntaxResult.GetAllDiagnostics()); 1655Assert.Empty(analyzer.AnalyzedSymbols); 1656Assert.Empty(analyzer.AnalyzedSymbolStartSymbols); 1657Assert.Empty(analyzer.AnalyzedSymbolEndSymbols); 1658Assert.Empty(analyzer.AnalyzedCodeBlockSymbols); 1659Assert.Empty(analyzer.AnalyzedCodeBlockStartSymbols); 1660Assert.Empty(analyzer.AnalyzedCodeBlockEndSymbols); 1661Assert.Empty(analyzer.AnalyzedOperationBlockSymbols); 1662Assert.Empty(analyzer.AnalyzedOperationBlockStartSymbols); 1663Assert.Empty(analyzer.AnalyzedOperationBlockEndSymbols); 1664Assert.Empty(analyzer.AnalyzedOperations); 1665Assert.Empty(analyzer.AnalyzedOperationsInsideOperationBlock); 1666Assert.Empty(analyzer.AnalyzedSyntaxNodes); 1667Assert.Empty(analyzer.AnalyzedSyntaxNodesInsideCodeBlock); 1668Assert.Empty(analyzer.AnalyzedSemanticModels); 1679Assert.Empty(result.GetAllDiagnostics()); 1682Assert.Empty(analyzer.AnalyzedTrees); 1831Assert.Empty(result.CompilationDiagnostics);

10337Assert.Empty(actualFields.ToTestDisplayStrings()); 10444Assert.Empty(actualFields.ToTestDisplayStrings()); 12788Assert.Empty(tree.GetRoot().DescendantNodes().OfType<FieldExpressionSyntax>());

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

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

1538Assert.Empty(dataFlows.VariablesDeclared); 1552Assert.Empty(dataFlows.VariablesDeclared); 4203Assert.Empty(controlFlowAnalysisResults.EntryPoints); 4272Assert.Empty(controlFlowAnalysisResults.EntryPoints); 4409Assert.Empty(dataFlows.VariablesDeclared); 4936Assert.Empty(analysis.ReturnStatements); 5249Assert.Empty(controlFlowAnalysisResults.ReturnStatements); 5990Assert.Empty(dataFlows.DataFlowsOut); 6051Assert.Empty(dataFlowAnalysisResults.Captured); 6052Assert.Empty(dataFlowAnalysisResults.CapturedInside); 6053Assert.Empty(dataFlowAnalysisResults.CapturedOutside); 6054Assert.Empty(dataFlowAnalysisResults.VariablesDeclared); 6055Assert.Empty(dataFlowAnalysisResults.AlwaysAssigned); 6056Assert.Empty(dataFlowAnalysisResults.DataFlowsIn); 6057Assert.Empty(dataFlowAnalysisResults.DataFlowsOut); 6060Assert.Empty(dataFlowAnalysisResults.ReadInside); 6062Assert.Empty(dataFlowAnalysisResults.WrittenInside); 6088Assert.Empty(dataFlowAnalysisResults.Captured); 6089Assert.Empty(dataFlowAnalysisResults.CapturedInside); 6090Assert.Empty(dataFlowAnalysisResults.CapturedOutside); 6091Assert.Empty(dataFlowAnalysisResults.VariablesDeclared); 6092Assert.Empty(dataFlowAnalysisResults.AlwaysAssigned); 6093Assert.Empty(dataFlowAnalysisResults.DataFlowsIn); 6094Assert.Empty(dataFlowAnalysisResults.DataFlowsOut); 6097Assert.Empty(dataFlowAnalysisResults.ReadInside); 6099Assert.Empty(dataFlowAnalysisResults.WrittenInside); 6127Assert.Empty(dataFlowAnalysisResults.Captured); 6128Assert.Empty(dataFlowAnalysisResults.CapturedInside); 6129Assert.Empty(dataFlowAnalysisResults.CapturedOutside); 6130Assert.Empty(dataFlowAnalysisResults.VariablesDeclared); 6131Assert.Empty(dataFlowAnalysisResults.AlwaysAssigned); 6133Assert.Empty(dataFlowAnalysisResults.DataFlowsOut); 6138Assert.Empty(dataFlowAnalysisResults.WrittenInside); 6166Assert.Empty(dataFlowAnalysisResults.Captured); 6167Assert.Empty(dataFlowAnalysisResults.CapturedInside); 6168Assert.Empty(dataFlowAnalysisResults.CapturedOutside); 6169Assert.Empty(dataFlowAnalysisResults.VariablesDeclared); 6170Assert.Empty(dataFlowAnalysisResults.AlwaysAssigned); 6172Assert.Empty(dataFlowAnalysisResults.DataFlowsOut); 6177Assert.Empty(dataFlowAnalysisResults.WrittenInside); 6219Assert.Empty(flowAnalysis.Captured); 6220Assert.Empty(flowAnalysis.CapturedInside); 6221Assert.Empty(flowAnalysis.CapturedOutside); 6223Assert.Empty(flowAnalysis.DataFlowsOut); 6225Assert.Empty(flowAnalysis.WrittenInside); 6232Assert.Empty(flowAnalysis.DataFlowsOut); 6234Assert.Empty(flowAnalysis.WrittenInside);

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

994Assert.Empty(attrs[0]);

70Assert.Empty(parameter.GetAttributes()); 76Assert.Empty(parameter.RefCustomModifiers); 338Assert.Empty(attribute.ConstructorArguments); 339Assert.Empty(attribute.NamedArguments); 445Assert.Empty(attribute.ConstructorArguments); 446Assert.Empty(attribute.NamedArguments); 976Assert.Empty(p.GetAttributes()); 1073Assert.Empty(p.GetAttributes()); 1125Assert.Empty(p.GetAttributes()); 1177Assert.Empty(p.GetAttributes()); 1227Assert.Empty(p.GetAttributes());

5045Assert.Empty(t.ConstraintTypesNoUseSiteDiagnostics); 7586Assert.Empty(op.Info.GetEnumeratorArguments); 7776Assert.Empty(op.Info.GetEnumeratorArguments); 7996Assert.Empty(op.Info.GetEnumeratorArguments); 8186Assert.Empty(op.Info.GetEnumeratorArguments); 8379Assert.Empty(op.Info.GetEnumeratorArguments); 8658Assert.Empty(op.Info.GetEnumeratorArguments); 9032Assert.Empty(op.Info.MoveNextArguments); 9236Assert.Empty(op.Info.MoveNextArguments); 9600Assert.Empty(op.Info.MoveNextArguments); 9824Assert.Empty(op.Info.MoveNextArguments); 10033Assert.Empty(op.Info.MoveNextArguments); 10260Assert.Empty(op.Info.MoveNextArguments); 10643Assert.Empty(op.Info.MoveNextArguments); 10840Assert.Empty(op.Info.MoveNextArguments); 11081Assert.Empty(op.Info.MoveNextArguments); 11308Assert.Empty(op.Info.MoveNextArguments); 11520Assert.Empty(op.Info.MoveNextArguments); 11620Assert.Empty(op.Info.MoveNextArguments); 11715Assert.Empty(op.Info.MoveNextArguments); 17773Assert.Empty(op.Info.GetEnumeratorArguments); 17970Assert.Empty(op.Info.GetEnumeratorArguments); 18194Assert.Empty(op.Info.GetEnumeratorArguments); 18390Assert.Empty(op.Info.GetEnumeratorArguments); 18591Assert.Empty(op.Info.GetEnumeratorArguments); 18875Assert.Empty(op.Info.GetEnumeratorArguments); 19213Assert.Empty(op.Info.MoveNextArguments); 19384Assert.Empty(op.Info.MoveNextArguments); 19709Assert.Empty(op.Info.MoveNextArguments); 19877Assert.Empty(op.Info.MoveNextArguments);

693Assert.Empty(symbolInfo.CandidateSymbols); 697Assert.Empty(group); 792Assert.Empty(symbolInfo.CandidateSymbols); 796Assert.Empty(group); 840Assert.Empty(symbolInfo.CandidateSymbols); 844Assert.Empty(group); 911Assert.Empty(symbolInfo.CandidateSymbols); 915Assert.Empty(group); 977Assert.Empty(group); 1045Assert.Empty(group); 2183Assert.Empty(symbolInfo.CandidateSymbols); 2187Assert.Empty(group); 4765Assert.Empty(symbolInfo.CandidateSymbols); 4769Assert.Empty(group); 4883Assert.Empty(symbolInfo.CandidateSymbols); 4887Assert.Empty(group); 5055Assert.Empty(symbolInfo.CandidateSymbols); 5059Assert.Empty(group); 5109Assert.Empty(symbolInfo.CandidateSymbols); 5113Assert.Empty(group); 5157Assert.Empty(symbolInfo.CandidateSymbols); 5161Assert.Empty(group); 5205Assert.Empty(symbolInfo.CandidateSymbols); 5209Assert.Empty(group); 5254Assert.Empty(symbolInfo.CandidateSymbols); 5258Assert.Empty(group); 5302Assert.Empty(symbolInfo.CandidateSymbols); 5306Assert.Empty(group); 5351Assert.Empty(symbolInfo.CandidateSymbols); 5355Assert.Empty(group); 5402Assert.Empty(symbolInfo.CandidateSymbols); 5406Assert.Empty(group); 5457Assert.Empty(symbolInfo.CandidateSymbols); 5461Assert.Empty(group); 5571Assert.Empty(symbolInfo.CandidateSymbols); 5575Assert.Empty(group); 5643Assert.Empty(symbolInfo.CandidateSymbols); 5647Assert.Empty(group); 5714Assert.Empty(symbolInfo.CandidateSymbols); 5718Assert.Empty(group); 5785Assert.Empty(symbolInfo.CandidateSymbols); 5789Assert.Empty(group); 5852Assert.Empty(group); 5915Assert.Empty(group); 5980Assert.Empty(group); 6050Assert.Empty(group); 6118Assert.Empty(group); 6192Assert.Empty(group); 8382Assert.Empty(symbolInfo.CandidateSymbols); 8386Assert.Empty(group); 8453Assert.Empty(symbolInfo.CandidateSymbols); 8457Assert.Empty(group); 11554Assert.Empty(symbolInfo.CandidateSymbols); 11558Assert.Empty(group); 11653Assert.Empty(symbolInfo.CandidateSymbols); 11657Assert.Empty(group); 11701Assert.Empty(symbolInfo.CandidateSymbols); 11705Assert.Empty(group); 11772Assert.Empty(symbolInfo.CandidateSymbols); 11776Assert.Empty(group); 11838Assert.Empty(group); 11906Assert.Empty(group); 13796Assert.Empty(symbolInfo.CandidateSymbols); 13800Assert.Empty(group); 14122Assert.Empty(symbolInfo.CandidateSymbols); 14935Assert.Empty(symbolInfo.CandidateSymbols); 14939Assert.Empty(group); 15105Assert.Empty(symbolInfo.CandidateSymbols); 15109Assert.Empty(group); 15177Assert.Empty(group); 15302Assert.Empty(group); 16092Assert.Empty(symbolInfo.CandidateSymbols); 16143Assert.Empty(symbolInfo.CandidateSymbols); 18899Assert.Empty(symbolInfo.CandidateSymbols); 18903Assert.Empty(group); 19026Assert.Empty(symbolInfo.CandidateSymbols); 19030Assert.Empty(group); 19130Assert.Empty(symbolInfo.CandidateSymbols); 19134Assert.Empty(group); 19811Assert.Empty(symbolInfo.CandidateSymbols); 20320Assert.Empty(symbolInfo.CandidateSymbols); 20324Assert.Empty(group); 20447Assert.Empty(symbolInfo.CandidateSymbols); 20451Assert.Empty(group); 20627Assert.Empty(symbolInfo.CandidateSymbols); 20631Assert.Empty(group); 20681Assert.Empty(symbolInfo.CandidateSymbols); 20685Assert.Empty(group); 20729Assert.Empty(symbolInfo.CandidateSymbols); 20733Assert.Empty(group); 20777Assert.Empty(symbolInfo.CandidateSymbols); 20781Assert.Empty(group); 20826Assert.Empty(symbolInfo.CandidateSymbols); 20830Assert.Empty(group); 20874Assert.Empty(symbolInfo.CandidateSymbols); 20878Assert.Empty(group); 20923Assert.Empty(symbolInfo.CandidateSymbols); 20927Assert.Empty(group); 20974Assert.Empty(symbolInfo.CandidateSymbols); 20978Assert.Empty(group); 21029Assert.Empty(symbolInfo.CandidateSymbols); 21033Assert.Empty(group); 21143Assert.Empty(symbolInfo.CandidateSymbols); 21147Assert.Empty(group); 21215Assert.Empty(symbolInfo.CandidateSymbols); 21219Assert.Empty(group); 21286Assert.Empty(symbolInfo.CandidateSymbols); 21290Assert.Empty(group); 21357Assert.Empty(symbolInfo.CandidateSymbols); 21361Assert.Empty(group); 21424Assert.Empty(group); 21487Assert.Empty(group); 21552Assert.Empty(group); 21622Assert.Empty(group); 21690Assert.Empty(group); 21764Assert.Empty(group); 27296Assert.Empty(symbolInfo.CandidateSymbols); 27400Assert.Empty(symbolInfo.CandidateSymbols);

74Assert.Empty(symbol.Interfaces); 75Assert.Empty(symbol.AllInterfaces); 178Assert.Empty(symbol.MemberNames); 179Assert.Empty(symbol.InstanceConstructors); 180Assert.Empty(symbol.StaticConstructors); 181Assert.Empty(symbol.Constructors); 186Assert.Empty(symbol.TypeParameters); 187Assert.Empty(symbol.TypeArguments); 369Assert.Empty(symbol.TypeParameters.Single().ConstraintTypes); 398Assert.Empty(symbol.TypeParameters.ToTestDisplayStrings()); 399Assert.Empty(symbol.TypeArguments.ToTestDisplayStrings()); 2506Assert.Empty(symbol.MemberNames); 2599Assert.Empty(symbol.StaticConstructors); 3947Assert.Empty(comp.GetTypeByMetadataName("Extensions").GetMembers().OfType<MethodSymbol>()); 12508Assert.Empty(model.GetMemberGroup(method)); 12512Assert.Empty(model.GetMemberGroup(property)); 12739Assert.Empty(model.GetMemberGroup(invocation1)); 12743Assert.Empty(model.GetMemberGroup(invocation2)); 12795Assert.Empty(model.GetMemberGroup(invocation1)); 12799Assert.Empty(model.GetMemberGroup(invocation2)); 12845Assert.Empty(model.GetMemberGroup(invocation1)); 12850Assert.Empty(model.GetMemberGroup(invocation2)); 12855Assert.Empty(model.GetMemberGroup(invocation3)); 12883Assert.Empty(model.GetMemberGroup(invocation)); 12914Assert.Empty(model.GetMemberGroup(invocation)); 12946Assert.Empty(model.GetMemberGroup(invocation)); 13129Assert.Empty(model.GetMemberGroup(memberAccess)); 14349Assert.Empty(model.GetMemberGroup(invocation)); 15329Assert.Empty(model.GetMemberGroup(memberAccess)); 15456Assert.Empty(model.GetMemberGroup(memberAccess)); 18343Assert.Empty(model.GetMemberGroup(memberAccess)); // Tracked by https://github.com/dotnet/roslyn/issues/78957 : consider handling BoundBadExpression better 19273Assert.Empty(model.GetMemberGroup(memberAccess)); 19843Assert.Empty(model.GetMemberGroup(property)); // Tracked by https://github.com/dotnet/roslyn/issues/78957 : handle GetMemberGroup on a property access 19875Assert.Empty(model.GetMemberGroup(property)); // Tracked by https://github.com/dotnet/roslyn/issues/78957 : handle GetMemberGroup on a property access 24918Assert.Empty(model.GetMemberGroup(memberAccess)); // Tracked by https://github.com/dotnet/roslyn/issues/78957 : public API, consider handling BoundBadExpression better 24957Assert.Empty(model.GetMemberGroup(memberAccess)); 25028Assert.Empty(model.GetMemberGroup(memberAccess1)); 25033Assert.Empty(model.GetMemberGroup(memberAccess2)); 28745Assert.Empty(model.GetMemberGroup(invocation)); 29095Assert.Empty(model.GetMemberGroup(memberAccess)); // Tracked by https://github.com/dotnet/roslyn/issues/78957 : public API, consider handling BoundBadExpression better 29553Assert.Empty(model.GetMemberGroup(memberAccess)); 34256Assert.Empty(implementations[1].GetAttributes()); 36362Assert.Empty(model.GetMemberGroup(memberAccess)); 37437Assert.Empty(model.LookupNamespacesAndTypes(position: 0, o, name: null)); 37680Assert.Empty(model.LookupNamespacesAndTypes(position: 0, o, name: null)); 37704Assert.Empty(model.LookupNamespacesAndTypes(position, null, name: "o")); 37707Assert.Empty(model.LookupSymbols(position, null, name: "o")); 37708Assert.Empty(model.LookupSymbols(position, null, name: null).OfType<IParameterSymbol>()); 49332Assert.Empty(comp.GlobalNamespace.GetTypeMember("E").GetTypeMembers());