442Assert.Empty(exportedActivities);

122Assert.Empty(messageService.AllMessages);

81Assert.Empty(telemetryRepository.TracesSubscriptions);

440Assert.Empty(app.ValidationFailures); 459Assert.Empty(app.ValidationFailures); 478Assert.Empty(app.ValidationFailures);

103Assert.Empty(testSink.Writes);

22Assert.Empty(endpoints);

40Assert.Empty(e.Children);

430Assert.Empty(logs.Items); 443Assert.Empty(propertyKeys); 809Assert.Empty(repository.GetLogs(new GetLogsContext

144Assert.Empty(traces.PagedResult.Items); 1227Assert.Empty(traces.PagedResult.Items); 1277Assert.Empty(traces.PagedResult.Items);

25Assert.Empty(missingProperties);

380Assert.Empty(model.Resources); 396Assert.Empty(model.Resources);

15Assert.Empty(dcpNamespaceTypes);

43Assert.Empty(appModel.Resources);

84Assert.Empty(service.GetResourceLoggerState(testResource.Name).GetBacklogSnapshot()); 197Assert.Empty(service.GetResourceLoggerState(testResource.Name).GetBacklogSnapshot());

36Assert.Empty(state.EnvironmentVariables);

166Assert.Empty(exportedActivities);

373Assert.Empty(connection1.GetServers().Single().Keys()); 375Assert.Empty(connection3.GetServers().Single().Keys()); 380Assert.Empty(connection1.GetServers().Single().Keys());

1564Assert.Empty(compilation.GetDiagnostics().Where(diagnostic => diagnostic.Severity > DiagnosticSeverity.Hidden));

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

324Assert.Empty(response.TrailingHeaders);

73Assert.Empty(matchedEntries);

324Assert.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);

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

42Assert.Empty(diagnostics); 59Assert.Empty(diagnostics); 76Assert.Empty(diagnostics); 94Assert.Empty(diagnostics); 112Assert.Empty(diagnostics); 130Assert.Empty(diagnostics); 147Assert.Empty(diagnostics); 164Assert.Empty(diagnostics); 181Assert.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); 272Assert.Empty(missing); 273Assert.Empty(unexpected); 340Assert.Empty(missing); 341Assert.Empty(unexpected); 393Assert.Empty(missing); 394Assert.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);

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

785Assert.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);

69Assert.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]);

273Assert.Empty(reportedErrors);

149Assert.Empty(registry.ConnectedCircuits);

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

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

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

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

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

35Assert.Empty(state); 179Assert.Empty(sequence);

697Assert.Empty(navigationManager.ExceptionsThrownFromLocationChangingHandlers);

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

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

86Assert.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());

26Assert.Empty(handlerActions.ClearCache);

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

41Assert.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);

345Assert.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)); 393Assert.Empty(httpsCertificateList); 411Assert.Empty(httpsCertificateList);

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

268Assert.Empty(sensitiveParameters);

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

91Assert.Empty(context.Request.RouteValues); 226Assert.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);

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

146Assert.Empty(resolvedSchema.Properties);

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

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

403Assert.Empty(requestDurationCollector.GetMeasurementSnapshot()); 458Assert.Empty(requestDurationCollector.GetMeasurementSnapshot());

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

114Assert.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);

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

34Assert.Empty(result.GeneratedSources); 86Assert.Empty(result.GeneratedSources); 104Assert.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);

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); 726Assert.Empty(TestSink.Writes); 1059Assert.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);

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); 272Assert.Empty(responseType.ApiResponseFormats); 320Assert.Empty(responseType.ApiResponseFormats); 507Assert.Empty(responseType.ApiResponseFormats); 513Assert.Empty(responseType.ApiResponseFormats); 545Assert.Empty(responseType.ApiResponseFormats); 561Assert.Empty(responseType.ApiResponseFormats); 749Assert.Empty(GetSortedMediaTypes(responseType));

46Assert.Empty(descriptions); 59Assert.Empty(descriptions); 267Assert.Empty(description.ParameterDescriptions); 439Assert.Empty(id1.RouteInfo.Constraints); 633Assert.Empty(description.SupportedResponseTypes); 715Assert.Empty(responseType.ApiResponseFormats); 818Assert.Empty(responseType.ApiResponseFormats); 888Assert.Empty(GetSortedMediaTypes(responseType)); 958Assert.Empty(GetSortedMediaTypes(responseType)); 1219Assert.Empty(description.SupportedRequestFormats); 1491Assert.Empty(description.ParameterDescriptions);

42Assert.Empty(apiDescriptions); 176Assert.Empty(responseType.ApiResponseFormats); 274Assert.Empty(badRequestResponseType.ApiResponseFormats); 300Assert.Empty(badRequestResponseType.ApiResponseFormats); 379Assert.Empty(badRequestResponseType.ApiResponseFormats); 413Assert.Empty(badRequestResponseType.ApiResponseFormats); 581Assert.Empty(GetApiDescription((IInferredServiceInterface foo) => { }).ParameterDescriptions); 582Assert.Empty(GetApiDescription(([FromServices] InferredServiceClass foo) => { }).ParameterDescriptions); 583Assert.Empty(GetApiDescription(([FromKeyedServices("foo")] InferredServiceClass foo) => { }).ParameterDescriptions); 584Assert.Empty(GetApiDescription((HttpContext context) => { }).ParameterDescriptions); 585Assert.Empty(GetApiDescription((HttpRequest request) => { }).ParameterDescriptions); 586Assert.Empty(GetApiDescription((HttpResponse response) => { }).ParameterDescriptions); 587Assert.Empty(GetApiDescription((ClaimsPrincipal user) => { }).ParameterDescriptions); 588Assert.Empty(GetApiDescription((CancellationToken token) => { }).ParameterDescriptions); 589Assert.Empty(GetApiDescription((BindAsyncRecord context) => { }).ParameterDescriptions); 899Assert.Empty(context.Results); 1392Assert.Empty(parameter.RouteInfo.Constraints);

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

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

93Assert.Empty(property.Attributes); 145Assert.Empty(property.Attributes); 198Assert.Empty(parameter.Attributes); 428Assert.Empty(model.Filters); 761Assert.Empty(GetAttributeRoutes(action.Selectors)); 784Assert.Empty(GetAttributeRoutes(action.Selectors)); 808Assert.Empty(GetAttributeRoutes(action.Selectors)); 833Assert.Empty(GetAttributeRoutes(action.Selectors)); 856Assert.Empty(GetAttributeRoutes(action.Selectors)); 1016Assert.Empty(GetAttributeRoutes(action.Selectors)); 1259Assert.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);

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

31Assert.Empty(metadata.AdditionalValues);

190Assert.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());

58Assert.Empty(result); 71Assert.Empty(result); 188Assert.Empty(parameter.RouteInfo.ConstraintTypes); 472Assert.Empty(responseType.ResponseFormats); 492Assert.Empty(responseType.ResponseFormats); 513Assert.Empty(description.SupportedResponseTypes); 1182Assert.Empty(description.ParameterDescriptions); 1203Assert.Empty(description.ParameterDescriptions); 1216Assert.Empty(description.ParameterDescriptions); 1340Assert.Empty(responseType.ResponseFormats); 1375Assert.Empty(responseType.ResponseFormats); 1410Assert.Empty(responseType.ResponseFormats); 1445Assert.Empty(responseType.ResponseFormats); 1485Assert.Empty(responseType.ResponseFormats); 1522Assert.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);

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

312Assert.Empty(propertyNames);

200Assert.Empty(diagnostic.Errors);

59Assert.Empty(operation.Responses);

262Assert.Empty(propertyNames);

55Assert.Empty(diagnostic.Errors);

83Assert.Empty(servers); 107Assert.Empty(servers);

86Assert.Empty(operation.Parameters); 104Assert.Empty(operation.Parameters); 119Assert.Empty(operation.Parameters); 140Assert.Empty(operation.Parameters); 185Assert.Empty(response.Value.Content); 240Assert.Empty(badRequestResponseType.Content); 334Assert.Empty(param.Content); 348Assert.Empty(param.Content); 360Assert.Empty(param.Content); 374Assert.Empty(param.Content); 386Assert.Empty(param.Content); 405Assert.Empty(param.Content); 411Assert.Empty(GetOpenApiOperation((IInferredServiceInterface foo) => { }).Parameters); 412Assert.Empty(GetOpenApiOperation(([FromServices] int foo) => { }).Parameters); 413Assert.Empty(GetOpenApiOperation(([FromKeyedServices("foo")] int foo) => { }).Parameters); 414Assert.Empty(GetOpenApiOperation((HttpContext context) => { }).Parameters); 415Assert.Empty(GetOpenApiOperation((HttpRequest request) => { }).Parameters); 416Assert.Empty(GetOpenApiOperation((HttpResponse response) => { }).Parameters); 417Assert.Empty(GetOpenApiOperation((ClaimsPrincipal user) => { }).Parameters); 418Assert.Empty(GetOpenApiOperation((CancellationToken token) => { }).Parameters); 419Assert.Empty(GetOpenApiOperation((BindAsyncRecord context) => { }).Parameters); 430Assert.Empty(operation.Parameters); 449Assert.Empty(fooParam.Content); 455Assert.Empty(barParam.Content); 476Assert.Empty(param.Content); 483Assert.Empty(param.Content); 508Assert.Empty(fooParam.Content); 514Assert.Empty(barParam.Content); 666Assert.Empty(operation.Parameters); 693Assert.Empty(operation.Parameters); 709Assert.Empty(operation.Parameters); 723Assert.Empty(operation.Parameters); 737Assert.Empty(operation.Parameters); 751Assert.Empty(operation.Parameters); 765Assert.Empty(operation.Parameters); 779Assert.Empty(operation.Parameters); 799Assert.Empty(operation.Parameters); 829Assert.Empty(operation.Parameters); 852Assert.Empty(operation.Parameters); 914Assert.Empty(operationWithNoParams.Parameters);

314Assert.Empty(schema.AnyOf);

27Assert.Empty(options.OperationTransformers); 28Assert.Empty(options.SchemaTransformers); 45Assert.Empty(options.OperationTransformers); 46Assert.Empty(options.SchemaTransformers); 62Assert.Empty(options.OperationTransformers); 63Assert.Empty(options.SchemaTransformers); 84Assert.Empty(options.DocumentTransformers); 85Assert.Empty(options.SchemaTransformers); 102Assert.Empty(options.DocumentTransformers); 103Assert.Empty(options.SchemaTransformers); 119Assert.Empty(options.DocumentTransformers); 120Assert.Empty(options.SchemaTransformers); 141Assert.Empty(options.DocumentTransformers); 142Assert.Empty(options.OperationTransformers); 159Assert.Empty(options.DocumentTransformers); 160Assert.Empty(options.OperationTransformers); 176Assert.Empty(options.DocumentTransformers); 177Assert.Empty(options.OperationTransformers);

39Assert.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);

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

47Assert.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); 100Assert.Empty(tree.Matches); 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);

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); 396Assert.Empty(allMatches);

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

159Assert.Empty(matches); 181Assert.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);

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

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

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

49Assert.Empty(headers);

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

910Assert.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);

85Assert.Empty(serverOptions.GetListenOptions()); 102Assert.Empty(serverOptions.GetListenOptions()); 130Assert.Empty(serverOptions.GetListenOptions()); 1737Assert.Empty(serverOptions.ConfigurationBackedListenOptions); 1750Assert.Empty(serverOptions.ConfigurationBackedListenOptions); 1769Assert.Empty(serverOptions.ConfigurationBackedListenOptions); 1776Assert.Empty(serverOptions.ConfigurationBackedListenOptions); 1855Assert.Empty(serverOptions.GetListenOptions());

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

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

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

163Assert.Empty(buffer.Pages);

101Assert.Empty(collection);

812Assert.Empty(parameters); 826Assert.Empty(parameters); 855Assert.Empty(parameters); 1318Assert.Empty(actualWarningsAsErrors); 1359Assert.Empty(actualWarningsAsErrors);

31Assert.Empty(project.Imports);

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

27Assert.Empty(project.ItemDefinitionGroups);

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

27Assert.Empty(project.ItemGroups);

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

26Assert.Empty(project.PropertyGroups);

476Assert.Empty(root2.Items); 1079Assert.Empty(collection.LoadedProjects);

44Assert.Empty(project.Targets);

37Assert.Empty(parameters); 246Assert.Empty(parameters);

28Assert.Empty(project.UsingTasks);

194Assert.Empty(consoleApplication1.Dependencies); 199Assert.Empty(vbClassLibrary.Dependencies); 204Assert.Empty(classLibrary1.Dependencies); 276Assert.Empty(classLibrary1.Dependencies); 282Assert.Empty(myPhysicalFolderClassLibrary1.Dependencies); 287Assert.Empty(classLibrary2.Dependencies); 375Assert.Empty(solution.ProjectsInOrder[2].Dependencies);

68Assert.Empty(parameterGroup.Parameters);

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

335Assert.Empty(items); 1195Assert.Empty(Helpers.MakeList(project.GetItems("i"))); 1196Assert.Empty(Helpers.MakeList(project.GetItemsIgnoringCondition("i"))); 1313Assert.Empty(Helpers.MakeList(project.CreateProjectInstance().GetItems("i"))); 1437Assert.Empty(Helpers.MakeList(project.GetItems("i"))); 1447Assert.Empty(itemsIgnoringCondition); 2256Assert.Empty(items);

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

2372Assert.Empty(items);

88Assert.Empty(metadataList);

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

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

1053Assert.Empty(_logger.TargetStartedEvents); 1054Assert.Empty(_logger.TargetFinishedEvents); 1055Assert.Empty(_logger.TaskStartedEvents); 1056Assert.Empty(_logger.TaskFinishedEvents); 3709Assert.Empty(mainInstance.GlobalProperties); 3744Assert.Empty(p2pInstance.GlobalProperties);

72Assert.Empty(request.Targets);

81Assert.Empty(properties); 703Assert.Empty(i1Group); 1631Assert.Empty(lookup.GetItems("i1")); 1649Assert.Empty(lookup.GetItems("i1")); 1712Assert.Empty(lookup.GetItems("i1")); 1731Assert.Empty(lookup.GetItems("i1")); 1750Assert.Empty(lookup.GetItems("i1")); 2304Assert.Empty(p.ItemsToBuildWith["i0"]); 2305Assert.Empty(p.ItemsToBuildWith.ItemTypes); 2337Assert.Empty(p.ItemsToBuildWith["i0"]); 2338Assert.Empty(p.ItemsToBuildWith.ItemTypes); 2411Assert.Empty(p.ItemsToBuildWith["i0"]); 2412Assert.Empty(p.ItemsToBuildWith.ItemTypes); 2455Assert.Empty(p.ItemsToBuildWith["i1"]); 2834Assert.Empty(lookup.GetItems("i1")); 3260Assert.Empty(p.ItemsToBuildWith["i1"]);

602Assert.Empty(_initializedService.LoggerDescriptions); 651Assert.Empty(loggingService.LoggerDescriptions); // "Expected LoggerDescriptions to be empty"

72Assert.Empty(lookup.GetItems("i1")); 278Assert.Empty(lookup.GetItems("i1")); 284Assert.Empty(lookup.GetItems("i1")); 294Assert.Empty(lookup.GetItems("i1")); 297Assert.Empty(table1["i1"]); 333Assert.Empty(lookup.GetItems("i1")); 342Assert.Empty(lookup.GetItems("i1")); 345Assert.Empty(lookup2.GetItems("i1")); 351Assert.Empty(lookup.GetItems("i1")); 352Assert.Empty(lookup2.GetItems("i1")); 379Assert.Empty(lookup.GetItems("i1")); 385Assert.Empty(lookup.GetItems("i1")); 391Assert.Empty(lookup.GetItems("i1")); 1157Assert.Empty(group3); 1194Assert.Empty(group3); 1200Assert.Empty(table1["i1"]);

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

174Assert.Empty(deps); 217Assert.Empty(taskBuilder.ExecutedTasks); 364Assert.Empty(results.Items); 381Assert.Empty(results.Items); 401Assert.Empty(results.Items); 474Assert.Empty(results.Items);

29Assert.Empty(result.Items);

126Assert.Empty(deserializedComplete.TaskOutputParameters);

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

119Assert.Empty(values);

58Assert.Empty(properties); 130Assert.Empty(list); 141Assert.Empty(list); 146Assert.Empty(items["j"]); 189Assert.Empty(dictionary); 199Assert.Empty(dictionary);

1898Assert.Empty(ProjectCollection.GlobalProjectCollection.LoadedProjects); 1902Assert.Empty(ProjectCollection.GlobalProjectCollection.LoadedProjects); 1955Assert.Empty(ProjectCollection.GlobalProjectCollection.LoadedProjects); 1960Assert.Empty(ProjectCollection.GlobalProjectCollection.LoadedProjects); 2054Assert.Empty(logger.Errors);

53Assert.Empty(msbuildToolsetSection.Toolsets); 88Assert.Empty(msbuildToolsetSection.Toolsets.GetElement(0).AllProjectImportSearchPaths); 188Assert.Empty(msbuildToolsetSection.Toolsets.GetElement(0).AllProjectImportSearchPaths);

91Assert.Empty(taskoverrideRegistry.TaskRegistrations); 110Assert.Empty(taskoverrideRegistry.TaskRegistrations); 129Assert.Empty(taskoverrideRegistry.TaskRegistrations); 149Assert.Empty(taskoverrideRegistry.TaskRegistrations);

1729Assert.Empty(project.GetItems("i")); 1810Assert.Empty(project.GetItems("i")); 2204Assert.Empty(project.AllEvaluatedItemDefinitionMetadata); 2227Assert.Empty(project.AllEvaluatedItemDefinitionMetadata); 2228Assert.Empty(project.AllEvaluatedItems);

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

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

335Assert.Empty(project.Imports);

344Assert.Empty(conditionedProperties);

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

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

209Assert.Empty(t.SuggestedRedirects); 254Assert.Empty(t.SuggestedRedirects); 294Assert.Empty(t.SuggestedRedirects); 417Assert.Empty(t.SuggestedRedirects); 460Assert.Empty(t.SuggestedRedirects);

178Assert.Empty(t.AssignedFilesWithCulture);

36Assert.Empty(t.OutputItems); 57Assert.Empty(t.OutputItems); 127Assert.Empty(t.OutputItems); 149Assert.Empty(t.OutputItems); 169Assert.Empty(t.OutputItems);

733Assert.Empty(t.CopiedFiles);

64Assert.Empty(t.Include); 119Assert.Empty(t.Include); 134Assert.Empty(t.Include); 153Assert.Empty(t.Include);

128Assert.Empty(tempFiles); 141Assert.Empty(tempFiles); 828Assert.Empty(exec.Outputs); 912Assert.Empty(exec.ConsoleOutput);

356Assert.Empty(t.CopyLocalFiles); 357Assert.Empty(t.References); 358Assert.Empty(t.RedistFiles); 381Assert.Empty(t.CopyLocalFiles); 382Assert.Empty(t.References); 383Assert.Empty(t.RedistFiles); 407Assert.Empty(t.CopyLocalFiles); 408Assert.Empty(t.References); 409Assert.Empty(t.RedistFiles); 530Assert.Empty(t.References); 556Assert.Empty(t.CopyLocalFiles); 674Assert.Empty(t.CopyLocalFiles); 723Assert.Empty(t.CopyLocalFiles); 815Assert.Empty(t.CopyLocalFiles); 867Assert.Empty(t.CopyLocalFiles); 918Assert.Empty(t.CopyLocalFiles); 955Assert.Empty(t.CopyLocalFiles); 1017Assert.Empty(t.CopyLocalFiles); 1048Assert.Empty(t.CopyLocalFiles); 1080Assert.Empty(t.CopyLocalFiles); 1233Assert.Empty(t.CopyLocalFiles); 1279Assert.Empty(t.CopyLocalFiles); 1322Assert.Empty(t.CopyLocalFiles);

101Assert.Empty(hashGroups);

254Assert.Empty(t.DirectoriesCreated);

110Assert.Empty(_allocatedHandles);

147Assert.Empty(t.MovedFiles);

162Assert.Empty(r.Lines);

150Assert.Empty(t.Filtered);

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

75Assert.Empty(ResolveSDKReference.ParseDependsOnSDK(null)); 76Assert.Empty(ResolveSDKReference.ParseDependsOnSDK(String.Empty)); 77Assert.Empty(ResolveSDKReference.ParseDependsOnSDK(";;")); 78Assert.Empty(ResolveSDKReference.ParseDependsOnSDK("; ;")); 103Assert.Empty(result); 113Assert.Empty(result); 1315Assert.Empty(t.ResolvedSDKReferences); 1392Assert.Empty(t.ResolvedSDKReferences); 1482Assert.Empty(t.ResolvedSDKReferences); 2430Assert.Empty(t.ResolvedSDKReferences); 3405Assert.Empty(t.ResolvedSDKReferences); 3547Assert.Empty(t.ResolvedSDKReferences); 3683Assert.Empty(t.ResolvedSDKReferences);

2796Assert.Empty(t.FilesWritten); 2889Assert.Empty(t.FilesWritten); 2926Assert.Empty(t.FilesWritten); 2963Assert.Empty(t.FilesWritten); 3008Assert.Empty(t.FilesWritten);

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

2328Assert.Empty(parsedArgs.EmbeddedFiles); 2472Assert.Empty(expectedEmbeddedMap); 2549Assert.Empty(fileMap); 2552Assert.Empty(expectedFilesMap); 6495Assert.Empty(diagnostics);

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

156Assert.Empty(exceptions);

146Assert.Empty(result.NamingStyles); 331Assert.Empty(result.NamingRules); 332Assert.Empty(result.NamingStyles); 333Assert.Empty(result.SymbolSpecifications);

35Assert.Empty(results);

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

35Assert.Empty(await _aggregator.GetItemsAsync("Hello")); 378Assert.Empty(await _aggregator.GetItemsAsync("ar")); 413Assert.Empty(await _aggregator.GetItemsAsync("ar")); 1078Assert.Empty(items); 1120Assert.Empty(items);

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

362Assert.Empty(workspace.CurrentSolution.Projects); 394Assert.Empty(workspace.CurrentSolution.Projects.Single().Documents); 1183Assert.Empty(workspace.GetOpenDocumentIds()); 1188Assert.Empty(workspace.GetOpenDocumentIds()); 1212Assert.Empty(workspace.GetOpenDocumentIds()); 1217Assert.Empty(workspace.GetOpenDocumentIds());

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

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

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

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

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

4640Assert.Empty(result.Diagnostics);

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

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

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

776Assert.Empty(result.Arguments); 786Assert.Empty(result.Arguments); 1927Assert.Empty(GetAttributeStrings(attributes3)); 1989Assert.Empty(GetAttributeStrings(attributes3)); 2274Assert.Empty(GetAttributeStrings(field3.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());

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

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

622Assert.Empty(synthesizedTupleElementNamesAttr);

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

381Assert.Empty(diagIds); 3362Assert.Empty(analyzer2.SymbolsStarted); 3363Assert.Empty(tree1SemanticDiagnostics); 3993Assert.Empty(diagnostics); 4234Assert.Empty(analyzer.CanceledCompilations);

925Assert.Empty(result.SyntaxDiagnostics); 1084Assert.Empty(diagnosticsByAnalyzerMap); 1146Assert.Empty(result.SemanticDiagnostics); 1152Assert.Empty(result.SyntaxDiagnostics); 1525Assert.Empty(syntaxResult.GetAllDiagnostics()); 1530Assert.Empty(analyzer.AnalyzedSymbols); 1531Assert.Empty(analyzer.AnalyzedSymbolStartSymbols); 1532Assert.Empty(analyzer.AnalyzedSymbolEndSymbols); 1533Assert.Empty(analyzer.AnalyzedCodeBlockSymbols); 1534Assert.Empty(analyzer.AnalyzedCodeBlockStartSymbols); 1535Assert.Empty(analyzer.AnalyzedCodeBlockEndSymbols); 1536Assert.Empty(analyzer.AnalyzedOperationBlockSymbols); 1537Assert.Empty(analyzer.AnalyzedOperationBlockStartSymbols); 1538Assert.Empty(analyzer.AnalyzedOperationBlockEndSymbols); 1539Assert.Empty(analyzer.AnalyzedOperations); 1540Assert.Empty(analyzer.AnalyzedOperationsInsideOperationBlock); 1541Assert.Empty(analyzer.AnalyzedSyntaxNodes); 1542Assert.Empty(analyzer.AnalyzedSyntaxNodesInsideCodeBlock); 1543Assert.Empty(analyzer.AnalyzedSemanticModels); 1554Assert.Empty(result.GetAllDiagnostics()); 1557Assert.Empty(analyzer.AnalyzedTrees); 1706Assert.Empty(result.CompilationDiagnostics);

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

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

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

1012Assert.Empty(symbolInfo.CandidateSymbols); 18451Assert.Empty(group); // https://github.com/dotnet/roslyn/issues/24936 20828Assert.Empty(GetOutVarDeclarations(tree, "x1")); 20958=> Assert.Empty(decl.Ancestors().OfType<VariableDeclaratorSyntax>());

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

354=> Assert.Empty(decl.Ancestors().OfType<VariableDeclaratorSyntax>()); 428Assert.Empty(tree.GetRoot().DescendantNodes().OfType<GlobalStatementSyntax>()); 449Assert.Empty(info.CandidateSymbols);

1025Assert.Empty(symbolInfo.CandidateSymbols);

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

137Assert.Empty(members); 1093Assert.Empty(model.GetMemberGroup((SyntaxNode)baseWithargs)); 1094Assert.Empty(model.GetMemberGroup(baseWithargs)); 1104Assert.Empty(model.GetMemberGroup((SyntaxNode)baseWithargs)); 1106Assert.Empty(model.GetMemberGroup(baseWithargs)); 1370Assert.Empty(symbolInfo.CandidateSymbols); 1373Assert.Empty(model.LookupSymbols(x.SpanStart, name: "X")); 1416Assert.Empty(symbolInfo.CandidateSymbols); 1419Assert.Empty(model.LookupSymbols(x.SpanStart, name: "X")); 1476Assert.Empty(symbolInfo.CandidateSymbols); 1479Assert.Empty(model.LookupSymbols(x.SpanStart, name: "X")); 1545Assert.Empty(symbolInfo.CandidateSymbols); 1548Assert.Empty(model.LookupSymbols(x.SpanStart, name: "X")); 1634Assert.Empty(symbolInfo.CandidateSymbols); 1637Assert.Empty(model.LookupSymbols(x.SpanStart, name: "X")); 1819Assert.Empty(symbolInfo.CandidateSymbols); 1822Assert.Empty(model.LookupSymbols(x.SpanStart, name: "X")); 1859Assert.Empty(symbolInfo.CandidateSymbols); 1862Assert.Empty(model.LookupSymbols(x.SpanStart, name: "X")); 1978Assert.Empty(((SynthesizedPrimaryConstructor)symbol.GetSymbol().ContainingSymbol).GetCapturedParameters()); 2136Assert.Empty(model.GetMemberGroup((SyntaxNode)baseWithargs)); 2137Assert.Empty(model.GetMemberGroup(baseWithargs)); 2156Assert.Empty(model.GetMemberGroup((SyntaxNode)baseWithargs)); 2158Assert.Empty(model.GetMemberGroup(baseWithargs)); 2311Assert.Empty(model.GetMemberGroup((SyntaxNode)baseWithargs)); 2312Assert.Empty(model.GetMemberGroup(baseWithargs)); 2430Assert.Empty(symbolInfo.CandidateSymbols); 2433Assert.Empty(model.LookupSymbols(x.SpanStart, name: "X")); 3221Assert.Empty(c.GetAttributes()); 3249Assert.Empty(c.GetAttributes()); 3281Assert.Empty(i.GetAttributes()); 3284Assert.Empty(i.Constructors); 3323Assert.Empty(e.GetAttributes()); 3355Assert.Empty(c.GetAttributes()); 3442Assert.Empty(c1.GetAttributes()); 3448Assert.Empty(c2.GetAttributes()); 3504Assert.Empty(c1.GetAttributes()); 3510Assert.Empty(c2.GetAttributes()); 6099Assert.Empty(symbolInfo.CandidateSymbols); 7803Assert.Empty(symbolInfo.CandidateSymbols); 7805Assert.Empty(model.LookupSymbols(p1.SpanStart, name: "p1")); 7846Assert.Empty(capturedParameters); 8702Assert.Empty(((CSharpCompilation)verifier.Compilation).GetTypeByMetadataName("C1").InstanceConstructors.OfType<SynthesizedPrimaryConstructor>().Single().GetCapturedParameters()); 9885Assert.Empty(comp.GetTypeByMetadataName("C1").InstanceConstructors.OfType<SynthesizedPrimaryConstructor>().Single().GetCapturedParameters()); 9946Assert.Empty(comp.GetTypeByMetadataName("C1").InstanceConstructors.OfType<SynthesizedPrimaryConstructor>().Single().GetCapturedParameters()); 9998Assert.Empty(comp.GetTypeByMetadataName("C1").InstanceConstructors.OfType<SynthesizedPrimaryConstructor>().Single().GetCapturedParameters()); 10192Assert.Empty(comp.GetTypeByMetadataName("Color+C1").InstanceConstructors.OfType<SynthesizedPrimaryConstructor>().Single().GetCapturedParameters()); 10227Assert.Empty(comp.GetTypeByMetadataName("Color+C1").InstanceConstructors.OfType<SynthesizedPrimaryConstructor>().Single().GetCapturedParameters()); 10270Assert.Empty(comp.GetTypeByMetadataName("Color+C1").InstanceConstructors.OfType<SynthesizedPrimaryConstructor>().Single().GetCapturedParameters()); 10877Assert.Empty(comp.GetTypeByMetadataName("S1").InstanceConstructors.OfType<SynthesizedPrimaryConstructor>().Single().GetCapturedParameters()); 10921Assert.Empty(comp.GetTypeByMetadataName("S1").InstanceConstructors.OfType<SynthesizedPrimaryConstructor>().Single().GetCapturedParameters()); 11051Assert.Empty(comp.GetTypeByMetadataName("S1").InstanceConstructors.OfType<SynthesizedPrimaryConstructor>().Single().GetCapturedParameters()); 11093Assert.Empty(comp.GetTypeByMetadataName("S1").InstanceConstructors.OfType<SynthesizedPrimaryConstructor>().Single().GetCapturedParameters()); 11138Assert.Empty(comp.GetTypeByMetadataName("S1").InstanceConstructors.OfType<SynthesizedPrimaryConstructor>().Single().GetCapturedParameters()); 11173Assert.Empty(comp.GetTypeByMetadataName("S1").InstanceConstructors.OfType<SynthesizedPrimaryConstructor>().Single().GetCapturedParameters()); 11203Assert.Empty(comp.GetTypeByMetadataName("S1").InstanceConstructors.OfType<SynthesizedPrimaryConstructor>().Single().GetCapturedParameters()); 11238Assert.Empty(comp.GetTypeByMetadataName("S1").InstanceConstructors.OfType<SynthesizedPrimaryConstructor>().Single().GetCapturedParameters()); 11268Assert.Empty(comp.GetTypeByMetadataName("S1").InstanceConstructors.OfType<SynthesizedPrimaryConstructor>().Single().GetCapturedParameters()); 11303Assert.Empty(comp.GetTypeByMetadataName("S1").InstanceConstructors.OfType<SynthesizedPrimaryConstructor>().Single().GetCapturedParameters()); 11334Assert.Empty(comp.GetTypeByMetadataName("S1").InstanceConstructors.OfType<SynthesizedPrimaryConstructor>().Single().GetCapturedParameters()); 11444Assert.Empty(comp.GetTypeByMetadataName("S1").InstanceConstructors.OfType<SynthesizedPrimaryConstructor>().Single().GetCapturedParameters()); 11483Assert.Empty(comp.GetTypeByMetadataName("S1").InstanceConstructors.OfType<SynthesizedPrimaryConstructor>().Single().GetCapturedParameters()); 11522Assert.Empty(comp.GetTypeByMetadataName("Color+C1").InstanceConstructors.OfType<SynthesizedPrimaryConstructor>().Single().GetCapturedParameters()); 11562Assert.Empty(comp.GetTypeByMetadataName("Color+C1").InstanceConstructors.OfType<SynthesizedPrimaryConstructor>().Single().GetCapturedParameters()); 11605Assert.Empty(comp.GetTypeByMetadataName("Color+C1").InstanceConstructors.OfType<SynthesizedPrimaryConstructor>().Single().GetCapturedParameters()); 11840Assert.Empty(comp.GetTypeByMetadataName("S2").InstanceConstructors.OfType<SynthesizedPrimaryConstructor>().Single().GetCapturedParameters()); 12072Assert.Empty(comp2.GetTypeByMetadataName("C1").InstanceConstructors.OfType<SynthesizedPrimaryConstructor>().Single().GetCapturedParameters()); 12073Assert.Empty(comp2.GetTypeByMetadataName("C2").InstanceConstructors.OfType<SynthesizedPrimaryConstructor>().Single().GetCapturedParameters()); 12157Assert.Empty(comp.GetTypeByMetadataName("S1").InstanceConstructors.OfType<SynthesizedPrimaryConstructor>().Single().GetCapturedParameters()); 20221Assert.Empty(comp.GetTypeByMetadataName("C").InstanceConstructors.OfType<SynthesizedPrimaryConstructor>().Single().GetCapturedParameters());

21210Assert.Empty(model.GetMemberGroup((SyntaxNode)baseWithargs)); 21211Assert.Empty(model.GetMemberGroup(baseWithargs)); 21221Assert.Empty(model.GetMemberGroup((SyntaxNode)baseWithargs)); 21223Assert.Empty(model.GetMemberGroup(baseWithargs)); 21489Assert.Empty(symbolInfo.CandidateSymbols); 21492Assert.Empty(model.LookupSymbols(x.SpanStart, name: "X")); 21535Assert.Empty(symbolInfo.CandidateSymbols); 21538Assert.Empty(model.LookupSymbols(x.SpanStart, name: "X")); 21595Assert.Empty(symbolInfo.CandidateSymbols); 21598Assert.Empty(model.LookupSymbols(x.SpanStart, name: "X")); 21664Assert.Empty(symbolInfo.CandidateSymbols); 21667Assert.Empty(model.LookupSymbols(x.SpanStart, name: "X")); 21753Assert.Empty(symbolInfo.CandidateSymbols); 21756Assert.Empty(model.LookupSymbols(x.SpanStart, name: "X")); 21938Assert.Empty(symbolInfo.CandidateSymbols); 21941Assert.Empty(model.LookupSymbols(x.SpanStart, name: "X")); 21975Assert.Empty(symbolInfo.CandidateSymbols); 21978Assert.Empty(model.LookupSymbols(x.SpanStart, name: "X")); 22050Assert.Empty(symbolInfo.CandidateSymbols); 22053Assert.Empty(model.LookupSymbols(x.SpanStart, name: "X")); 22135Assert.Empty(((SynthesizedPrimaryConstructor)symbol.GetSymbol().ContainingSymbol).GetCapturedParameters()); 22293Assert.Empty(model.GetMemberGroup((SyntaxNode)baseWithargs)); 22294Assert.Empty(model.GetMemberGroup(baseWithargs)); 22313Assert.Empty(model.GetMemberGroup((SyntaxNode)baseWithargs)); 22315Assert.Empty(model.GetMemberGroup(baseWithargs)); 22468Assert.Empty(model.GetMemberGroup((SyntaxNode)baseWithargs)); 22469Assert.Empty(model.GetMemberGroup(baseWithargs)); 28240Assert.Empty(symbolInfo.CandidateSymbols);

683Assert.Empty(result.Single().RudeEdits); 729Assert.Empty(result.Single().RudeEdits);

133Assert.Empty(exceptions);

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

676Assert.Empty(operation.ChildOperations);

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

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

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

4266Assert.Empty(symbolInfo.CandidateSymbols); 4278Assert.Empty(symbolInfo.CandidateSymbols); 4296Assert.Empty(symbolInfo.CandidateSymbols); 4321Assert.Empty(symbolInfo.CandidateSymbols); 4401Assert.Empty(symbolInfo.CandidateSymbols); 4409Assert.Empty(symbolInfo.CandidateSymbols); 4427Assert.Empty(symbolInfo.CandidateSymbols); 4452Assert.Empty(symbolInfo.CandidateSymbols); 4525Assert.Empty(symbolInfo.CandidateSymbols); 4537Assert.Empty(symbolInfo.CandidateSymbols); 4549Assert.Empty(symbolInfo.CandidateSymbols); 4558Assert.Empty(symbolInfo.CandidateSymbols); 4569Assert.Empty(symbolInfo.CandidateSymbols); 4586Assert.Empty(symbolInfo.CandidateSymbols); 4675Assert.Empty(symbolInfo.CandidateSymbols); 4683Assert.Empty(symbolInfo.CandidateSymbols); 4769Assert.Empty(symbolInfo.CandidateSymbols); 4777Assert.Empty(symbolInfo.CandidateSymbols); 4847Assert.Empty(symbolInfo.CandidateSymbols); 4855Assert.Empty(symbolInfo.CandidateSymbols); 4866Assert.Empty(symbolInfo.CandidateSymbols); 5055Assert.Empty(symbolInfo.CandidateSymbols); 5215Assert.Empty(symbolInfo.CandidateSymbols); 5223Assert.Empty(symbolInfo.CandidateSymbols); 5241Assert.Empty(symbolInfo.CandidateSymbols); 5269Assert.Empty(symbolInfo.CandidateSymbols); 5279Assert.Empty(symbolInfo.CandidateSymbols); 5359Assert.Empty(symbolInfo.CandidateSymbols); 5367Assert.Empty(symbolInfo.CandidateSymbols); 5385Assert.Empty(symbolInfo.CandidateSymbols); 5413Assert.Empty(symbolInfo.CandidateSymbols); 5423Assert.Empty(symbolInfo.CandidateSymbols); 5496Assert.Empty(symbolInfo.CandidateSymbols); 5504Assert.Empty(symbolInfo.CandidateSymbols); 5516Assert.Empty(symbolInfo.CandidateSymbols); 5525Assert.Empty(symbolInfo.CandidateSymbols); 5536Assert.Empty(symbolInfo.CandidateSymbols); 5556Assert.Empty(symbolInfo.CandidateSymbols); 5566Assert.Empty(symbolInfo.CandidateSymbols); 5683Assert.Empty(symbolInfo.CandidateSymbols); 5691Assert.Empty(symbolInfo.CandidateSymbols); 5716Assert.Empty(symbolInfo.CandidateSymbols); 5793Assert.Empty(symbolInfo.CandidateSymbols); 5801Assert.Empty(symbolInfo.CandidateSymbols); 5826Assert.Empty(symbolInfo.CandidateSymbols); 5896Assert.Empty(symbolInfo.CandidateSymbols); 5904Assert.Empty(symbolInfo.CandidateSymbols); 5915Assert.Empty(symbolInfo.CandidateSymbols); 5932Assert.Empty(symbolInfo.CandidateSymbols); 5993Assert.Empty(symbols.CandidateSymbols); 6003Assert.Empty(symbols.CandidateSymbols); 6036Assert.Empty(symbols.CandidateSymbols); 6046Assert.Empty(symbols.CandidateSymbols); 6076Assert.Empty(symbols.CandidateSymbols); 6086Assert.Empty(symbols.CandidateSymbols); 6118Assert.Empty(symbols.CandidateSymbols); 6128Assert.Empty(symbols.CandidateSymbols); 6158Assert.Empty(symbols.CandidateSymbols); 6168Assert.Empty(symbols.CandidateSymbols); 6558Assert.All(nestedConversions, n => Assert.Empty(n.Nested));

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

3969Assert.Empty(semanticInfo.CandidateSymbols);

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

3991Assert.Empty(property0.RefCustomModifiers);

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

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

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

299Assert.Empty(nativeIntegerType.GetTypeMembers()); 408Assert.Empty(nativeIntegerType.GetTypeMembers());

48000Assert.Empty(getter.GetAttributes()); 97653Assert.Empty(t1.GetAttributes()); 97665Assert.Empty(t2.GetAttributes()); 97706Assert.Empty(t1.GetAttributes()); 97719Assert.Empty(t2.GetAttributes()); 97764Assert.Empty(t1.GetAttributes()); 97770Assert.Empty(t2.GetAttributes()); 97813Assert.Empty(t1.GetAttributes()); 97826Assert.Empty(t2.GetAttributes()); 98422Assert.Empty(bf1.GetAttributes()); 98430Assert.Empty(t11.GetAttributes()); 98436Assert.Empty(bf2.GetAttributes()); 98445Assert.Empty(t22.GetAttributes()); 98613Assert.Empty(bf1.GetAttributes()); 98621Assert.Empty(t11.GetAttributes()); 98627Assert.Empty(bf2.GetAttributes()); 98636Assert.Empty(t22.GetAttributes()); 98720Assert.Empty(bf1.GetAttributes()); 98728Assert.Empty(t11.GetAttributes()); 98734Assert.Empty(bf2.GetAttributes()); 98743Assert.Empty(t22.GetAttributes()); 98786Assert.Empty(bf1.GetAttributes()); 98794Assert.Empty(t11.GetAttributes()); 98800Assert.Empty(bf2.GetAttributes()); 98812Assert.Empty(t22.GetAttributes()); 98858Assert.Empty(bf1.GetAttributes()); 98867Assert.Empty(t11.GetAttributes()); 98873Assert.Empty(bf2.GetAttributes()); 98884Assert.Empty(t22.GetAttributes()); 98927Assert.Empty(bf1.GetAttributes()); 98935Assert.Empty(t11.GetAttributes()); 98941Assert.Empty(bf2.GetAttributes()); 98950Assert.Empty(t22.GetAttributes()); 99017Assert.Empty(f2.GetAttributes()); 99025Assert.Empty(t2.GetAttributes()); 99052Assert.Empty(t2.GetAttributes()); 99093Assert.Empty(t2.GetAttributes()); 99301Assert.Empty(bf1.GetAttributes()); 99309Assert.Empty(t11.GetAttributes()); 99315Assert.Empty(bf2.GetAttributes()); 99324Assert.Empty(t22.GetAttributes()); 100295Assert.Empty(f1.GetAttributes()); 100305Assert.Empty(attributes); 100333Assert.Empty(f1.GetAttributes()); 100344Assert.Empty(attributes); 100386Assert.Empty(t1.GetAttributes()); 100393Assert.Empty(t2.GetAttributes()); 100425Assert.Empty(t1.GetAttributes()); 100445Assert.Empty(t1.GetAttributes()); 100501Assert.Empty(t1.GetAttributes()); 100509Assert.Empty(t2.GetAttributes()); 100544Assert.Empty(t1.GetAttributes()); 100551Assert.Empty(t2.GetAttributes()); 100589Assert.Empty(t1.GetAttributes()); 100596Assert.Empty(t2.GetAttributes()); 100681Assert.Empty(at1.GetAttributes()); 100710Assert.Empty(tf1.GetAttributes()); 100776Assert.Empty(at1.GetAttributes()); 100795Assert.Empty(bf1.GetAttributes()); 100803Assert.Empty(tf1.GetAttributes()); 100808Assert.Empty(tf1.GetAttributes()); 101930Assert.Empty(tf1.GetAttributes()); 101954Assert.Empty(tf1.GetAttributes()); 101982Assert.Empty(tf1.GetAttributes()); 102009Assert.Empty(tf1.GetAttributes()); 102036Assert.Empty(tf1.GetAttributes()); 102063Assert.Empty(tf1.GetAttributes()); 102090Assert.Empty(tf1.GetAttributes()); 102132Assert.Empty(tf1.GetAttributes()); 102163Assert.Empty(tf1.GetAttributes()); 102201Assert.Empty(tf1.GetAttributes()); 102236Assert.Empty(tf1.GetAttributes()); 102275Assert.Empty(tf1.GetAttributes()); 102313Assert.Empty(tf1.GetAttributes()); 102341Assert.Empty(attributes); 102369Assert.Empty(attributes); 102397Assert.Empty(attributes); 102436Assert.Empty(attributes); 102464Assert.Empty(attributes); 102490Assert.Empty(tf1.GetAttributes()); 102513Assert.Empty(tf1.GetAttributes()); 102540Assert.Empty(tf1.GetAttributes()); 102566Assert.Empty(tf1.GetAttributes()); 102592Assert.Empty(tf1.GetAttributes()); 102618Assert.Empty(tf1.GetAttributes()); 102644Assert.Empty(tf1.GetAttributes()); 102685Assert.Empty(attributes); 102715Assert.Empty(tf1.GetAttributes()); 102752Assert.Empty(attributes); 102786Assert.Empty(attributes); 102824Assert.Empty(attributes); 102861Assert.Empty(attributes); 102888Assert.Empty(attributes); 102915Assert.Empty(attributes); 102942Assert.Empty(attributes); 102979Assert.Empty(attributes); 103006Assert.Empty(attributes); 103038Assert.Empty(attributes); 103079Assert.Empty(attributes); 103122Assert.Empty(attributes); 103166Assert.Empty(attributes); 104814Assert.Empty(t11.GetAttributes()); 104827Assert.Empty(t1.GetAttributes()); 104841Assert.Empty(t22.GetAttributes()); 104855Assert.Empty(t2.GetAttributes()); 104916Assert.Empty(t11.GetAttributes()); 104925Assert.Empty(t22.GetAttributes()); 104993Assert.Empty(t11.GetAttributes()); 105002Assert.Empty(t22.GetAttributes()); 108277Assert.Empty(tm1.GetAttributes());