127double documentCount = documentPerformance.Where(x => x.Key.ProjectId == projectId).Count(); 160Console.WriteLine($" {group.Key}: {group.Count()} instances");

214var numberOfTrivia = root.DescendantTrivia(descendIntoTrivia: true).Count();

121var selectedNuGetPackage = filteredPackagesWithShortName.Count() switch { 201var selectedPackage = distinctPackages.Count() switch

131if (connectionBuilder.Count() == 1 &&

117if (connectionBuilder.Count() == 1 &&

75if (connectionBuilder.Count() == 1 &&

85Assert.Equal(5, activities.Where(x => x.OperationName == $"{topic} publish").Count()); 114Assert.Equal(5, activities.Where(x => x.OperationName == $"{topic} receive").Count());

452if (grouping.Count() > 1) 469builder.Add(ToOption(resource, grouping.Count() > 1, applicationName));

124var totalItemCount = page.Count();

424var totalItemCount = results.Count();

68var duplicate = properties.GroupBy(p => p.Key).Where(g => g.Count() >= 2).FirstOrDefault();

79cut.WaitForState(() => cut.Instance.GetFilteredResources().Count() == 2); 171cut.WaitForState(() => cut.Instance.GetFilteredResources().Count() == 2); 337cut.WaitForState(() => cut.Instance.GetFilteredResources().Count() == 1); 347cut.WaitForState(() => cut.Instance.GetFilteredResources().Count() == 2);

93if (packages.Count() > 1)

560.Where(g => g.Count() > 1)

379var schemeAsEndpointName = schemeGroup.Count() <= 1 ? schemeGroup.Key : null;

61if (connectionBuilder.Count() == 1 &&

15if (context.Model.Resources.OfType<IComputeEnvironmentResource>().Count() > 1)

29Assert.Equal(2, endpoints.Count());

15if (context.Model.Resources.OfType<IComputeEnvironmentResource>().Count() > 1)

186Assert.Equal(2, builder.Resources.OfType<MongoExpressContainerResource>().Count());

218if (mySqlInstances.Count() == 1)

179Assert.Equal(2, builder.Resources.OfType<NatsServerResource>().Count());

289Assert.Equal(2, qdrantResource.Annotations.OfType<EndpointAnnotation>().Count());

46Assert.Equal(2, httpEndpoints.Count());

1191Assert.Equal(4, kubernetesService.CreatedResources.OfType<Container>().Count());

125Assert.Equal(2, annotations.Count()); 143Assert.Equal(3, annotations.Count());

396Assert.Equal(3, logs.Where(l => l.Level == LogLevel.Trace).Count());

20Assert.Equal(2, dummyAnnotations.Count()); 34Assert.Equal(2, dummyAnnotations.Count());

61if (connectionBuilder.Count() == 1 &&

61if (connectionBuilder.Count() == 1 &&

241logger.LogInformation("Found {DbContextCount} DbContext types in project '{ProjectName}'", dbContextTypes.Count(), projectName);

93if (packages.Count() > 1)

403var useVarForFirstTerm = values.Count > 1 && values.Select(h => h.FirstNameIgnoreCaseSegment()).Distinct().Count() == 1; 450return start + $@"{Each(groups, (byFirstTerm, i) => $@"{(byFirstTerm.Count() == 1 ? $@"{Each(byFirstTerm, header => $@"

50Assert.True((number == message.Count<char>()), String.Format("The local int variable was not correctly set, expected {0} but got {1}", message.Count<char>(), number)); 143Assert.True((number == message.Count<char>()), 144String.Format("The value of the integer sent by reference was not the expected value. expected {0} but got {1}", message.Count<char>(), number));

597var hashAttributeCount = hashAttributes.Count();

946else if (relevantNodes.Count() == 1) 992else if (relevantNodes.Count() == 1)

49return targetFramework.IsDnx && references.Where(r => !r.IsFramework).Except(TargetFrameworkHelper.ServiceModelPackages).Count() > 0;

133return options?.Errors.Count() == 0; 146if (cmdOptions.Errors.Count() == 0 && cmdOptions.Inputs.Count == 1) 149TryFromFile(fileUri.LocalPath, out var fileOptions) && fileOptions.GetOptions().Count() > 0) 165if (disallowedSwitchesOnParamsFilesProvided.Count() > 0) 201if (this.Help != true && this.Errors.Count() == 0) 503if (paramsFiles.Count() == 1) 507else if (paramsFiles.Count() == 0) 513if (paramsFiles.Count() > 1) 661if (invalidNamespaces.Count() > 0) 737await safeLogger.WriteMessageAsync($"resolved inputs: {inputFiles.Count()}", logToUI: false).ConfigureAwait(false);

144if (missingRefs.Count() == 0)

249if (binding.Extensions.OfType<WsdlNS.HttpBinding>().Count() != 0)

81if (refItems == null || refItems.Count() == 0) 104if (refItems == null || refItems.Count() == 0) 128if (refItems == null || refItems.Count() == 0) 190if (targetFrameworkElements.Count() > 0) 212if (targetFrameworksElements.Count() > 0) 246if (runtimeIdentifierElements.Count() > 0) 447if (createOnMissing && groups.Count() == 0) 601if (existingElements.Count() > 0) 658if (targetFrameworkElements.Count() > 0) 666if (targetFrameworksElements.Count() > 0) 777await safeLogger.WriteMessageAsync($"Resolved project reference count: {dependencies.Count()}", logToUI: false).ConfigureAwait(false); 974if (propertyTable.Count() != propertyNames.Count())

75if (!string.IsNullOrWhiteSpace(filePath) && Path.GetInvalidPathChars().Intersect(filePath).Count() > 0) 80if (!string.IsNullOrWhiteSpace(packageName) && Path.GetInvalidFileNameChars().Intersect(packageName).Count() > 0)

27using (var safeLogger = await SafeLogger.WriteStartOperationAsync(logger, $"Resolving {propertyNames.Count()} project properties ...").ConfigureAwait(false))

217var displayUri = serviceDescriptor.MetadataFiles.Count() == 1 ? serviceDescriptor.MetadataFiles.First().LocalPath : SR.WsdlOrSchemaFilesMsg; 322if (options.Errors.Count() > 0)

435if (baselineWithNoGenerated.Count() > 0)

252var cmderrors = cmdOptions.Errors.Count() == 0 ? string.Empty : 254var cmdwarnings = cmdOptions.Warnings.Count() == 0 ? string.Empty : 274Assert.False(cmdOptions.Errors.Count() == 0 ^ expectSuccess, cmderrors); 298var cmderrors = cmdOptions.Errors.Count() == 0 ? string.Empty : 300var cmdwarnings = cmdOptions.Warnings.Count() == 0 ? string.Empty :

647var count = data.First().Count(); 648Debug.Assert(data.All(d => d.Count() == count));

179=> $"Interval tree with '{System.Linq.Enumerable.Count(this)}' entries. Use '.ToList()' to visualize contents.";

403if (words.Count() == 1) // Only Split if words have not been split before

145Console.WriteLine("Syntax tree count: " + compilation.SyntaxTrees.Count());

84var docCount = _workspace.CurrentSolution.Projects.SelectMany(p => p.Documents).Count();

537Assert.Equal(2, headerValues.Count());

537Assert.Equal(2, headerValues.Count());

285Debug.Assert(interproceduralState.MethodBodies.GetKnownValues().Count() == 1);

56if (values.Count() != 1)

56if (values.Count() != 1)

164Assert.Equal(10, connectionErrors.Single(e => e.Key == null).Count()); 166Assert.Equal(10, connectionErrors.Single(e => e.Key == KestrelMetrics.GetErrorType(ConnectionEndReason.MaxConcurrentConnectionsExceeded)).Count());

1295Assert.Equal(2, error.Count()); 2652Assert.Equal(2, LogMessages.Where(message => message.LogLevel == LogLevel.Error).Count()); 2712Assert.Equal(2, LogMessages.Where(message => message.LogLevel == LogLevel.Error).Count()); 2852Assert.Equal(2, LogMessages.Where(message => message.LogLevel == LogLevel.Error).Count());

1382Logger.LogInformation($"Client trailer count: {response.TrailingHeaders.Count()}");

1117Assert.Equal(2, TestSink.Writes.Where(context => context.Message.Contains("sending CONTINUATION frame for stream ID 1 with length 15585 and flags NONE")).Count());

926return (type.OperationKind?.Entries?.Where(e => e.EditorBrowsable != false).Count() ?? 0) > 1;

40await context.Response.WriteAsync(strings.Count().ToString(CultureInfo.InvariantCulture));

647var count = data.First().Count(); 648Debug.Assert(data.All(d => d.Count() == count));

179=> $"Interval tree with '{System.Linq.Enumerable.Count(this)}' entries. Use '.ToList()' to visualize contents.";

403if (words.Count() == 1) // Only Split if words have not been split before

647var count = data.First().Count(); 648Debug.Assert(data.All(d => d.Count() == count));

179=> $"Interval tree with '{System.Linq.Enumerable.Count(this)}' entries. Use '.ToList()' to visualize contents.";

403if (words.Count() == 1) // Only Split if words have not been split before

245var result = expected.Count() == actual.Count() && expectedSet.SetEquals(actual);

280if (compositeEndpointDataSource.DataSources.Intersect(_webApplication.DataSources).Count() == _webApplication.DataSources.Count)

38foreach (var ambiguousGroup in groupedByParent.Where(g => g.Count() >= 2))

33if (fromBodyMetadataInterfaceMembers.Count() >= 2) 41if (fromBodyMetadataInterfaceParameters.Count() >= 2)

34foreach (var ambiguousGroup in groupedByParent.Where(g => g.Count() >= 2))

43&& parentNode.DescendantNodes().Count() > 1;

63writer.Write(principal.Identities.Count()); 90writer.Write(identity.Claims.Count());

28Assert.Equal(3, props.GetTokens().Count()); 75Assert.Equal(3, props.GetTokens().Count()); 98Assert.Equal(3, props.GetTokens().Count()); 119Assert.Equal(3, props.GetTokens().Count());

102Assert.Equal(2, identity.FindAll("name0").Count()); 103Assert.Equal(2, identity.FindAll("name1").Count());

1049Assert.Equal(2, jwtBearerOptions.TokenValidationParameters.IssuerSigningKeys.Count());

55if (forms.Count() != 1) 93if (forms.Count() != 1)

24Assert.Equal(3, props.GetTokens().Count()); 71Assert.Equal(3, props.GetTokens().Count()); 94Assert.Equal(3, props.GetTokens().Count()); 115Assert.Equal(3, props.GetTokens().Count());

37Assert.Equal(2, combined.AuthenticationSchemes.Count()); 40Assert.Equal(4, combined.Requirements.Count()); 42Assert.Equal(2, combined.Requirements.OfType<ClaimsAuthorizationRequirement>().Count()); 87Assert.Equal(2, combined.AuthenticationSchemes.Count()); 90Assert.Equal(2, combined.Requirements.Count()); 92Assert.Equal(2, combined.Requirements.OfType<ClaimsAuthorizationRequirement>().Count()); 111Assert.Equal(2, rolesAuthorizationRequirement.AllowedRoles.Count()); 131Assert.Equal(2, combined.AuthenticationSchemes.Count()); 151Assert.Equal(2, combined.AuthenticationSchemes.Count()); 172Assert.Equal(2, rolesAuthorizationRequirement.AllowedRoles.Count());

190Assert.Equal(2, allowed.Failure.FailureReasons.Count());

45Assert.Equal(3, result.Principal.Identities.Count());

244else if (arg.GetChildren().Count() > 1)

109int actualCount = actualResults.Count();

112var actual = serviceDescriptors.Count(); 139else if (implementationTypes.Length != implementationTypes.Distinct().Count())

109int actualCount = actualResults.Count();

35Assert.Equal(100, secrets.Distinct(StringComparer.Ordinal).Count());

797Assert.Equal(2, services.Count()); 812Assert.Equal(2, services.Count()); 827Assert.Equal(2, services.Count());

75Assert.Equal(routes.GroupBy(x => x.Handler).Count(), routes.Count);

74Assert.Equal(3, new[] { instance1, instance2, instance3 }.Distinct().Count()); 86Assert.Equal(4, new[] { instance1, instance2, instance3, instance2b }.Distinct().Count());

99Assert.Equal(2, response.Headers.Count());

1869Assert.Equal(2, connection.User.Identities.Count()); 1921Assert.Equal(2, connection.User.Identities.Count());

64(expectedCount == serviceDescriptors.Count()), 66$" time(s) but was actually registered {serviceDescriptors.Count()} time(s).");

62Assert.True(errors.EnumerateObject().Count() == 1); 112Assert.True(errors.EnumerateObject().Count() == 1); 170Assert.True(errors.EnumerateObject().Count() == 1);

477var numOfConstructors = constructors.Count();

42Assert.Equal(3, context.Session.Keys.Count()); 161Assert.Equal(4, features.Count()); 165Assert.NotEqual(4, features.Count()); 181Assert.Equal(4, newFeatures.Count()); 185Assert.NotEqual(4, newFeatures.Count());

111Assert.Equal(3, userClaims.Intersect(claims, ClaimEqualityComparer.Default).Count());

190Assert.Equal(2, result.Errors.Count());

395Assert.Equal(2, result.Errors.Count()); 1755Assert.Equal(numCodes, newCodes.Count()); 1783Assert.Equal(numCodes, newCodes.Count()); 1785Assert.Equal(numCodes, realCodes.Count());

247Assert.Equal(4, tokenProviders.Count());

99Assert.Equal(3, authorizeFilters.First().Policy.Requirements.Count()); // Basic + Basic2 + Derived authorize

259Assert.Equal(2, descriptors.Count()); 454Assert.Equal(4, actions.Count()); 479Assert.Equal(2, actions.Count()); 531Assert.Equal(4, actions.Count()); 542Assert.Equal(4, constrainedActions.Count()); 547Assert.Equal(2, putActions.Count()); 554Assert.Equal(2, routeActions.Count()); 570Assert.Equal(6, actions.Count()); 581Assert.Equal(4, constrainedActions.Count()); 586Assert.Equal(2, postActions.Count()); 593Assert.Equal(2, putActions.Count()); 599Assert.Equal(2, unconstrainedActions.Count()); 640Assert.Equal(5, actions.Count()); 812Assert.Equal(2, getActions.Count()); 840Assert.Equal(2, getActions.Count()); 899Assert.Equal(4, actionDescriptors.Count()); 968Assert.Equal(2, actions.Count()); 1048Assert.Equal(2, actions.Count()); 1188Assert.Equal(2, actions.Count()); 1214Assert.Equal(2, actions.Count()); 1241Assert.Equal(4, actions.Count());

1183Assert.Equal(2, actionModel.Attributes.OfType<RouteAndConstraintAttribute>().Count());

344var actual = serviceDescriptors.Count();

193Assert.Equal(3, sink.Writes.Count()); 283Assert.Equal(2, sink.Writes.Count());

142Assert.Equal(3, sink.Writes.Count()); 210Assert.Equal(2, sink.Writes.Count());

567Assert.Equal(expectedNames.Count(), properties.Count); 679Assert.Equal(expectedNames.Count(), properties.Count);

221Assert.Equal(4, sink.Writes.Count());

44Assert.Equal(errors.Length, delegatingEnumerable.Count());

90Assert.Equal(10, projects.Count());

105Assert.Equal(expectedErrorMessages.Count(), modelBindingInfo.ModelStateErrorMessages.Count);

89Assert.Equal(2, products.Count());

24.FirstOrDefault(g => g.Count() > 1);

620var actual = serviceDescriptors.Count();

81var count = matches.Count();

1556Assert.Equal(expected.Count(), actual.Count()); 1557for (var i = 0; i < actual.Count(); i++)

109if (bodyParameters.Count() == 1)

559var hasMultipleFormParameters = groupedFormParameters.Count() > 1;

95Assert.Equal(4, documentNames.Count());

365var attributeDestination = new TagHelperAttribute[expectedAttributes.Count()];

131groups.Sort(static (a, b) => b.Count().CompareTo(a.Count())); 351groups.Sort(static (a, b) => b.Count().CompareTo(a.Count())); 476groups.Sort(static (a, b) => b.Count().CompareTo(a.Count()));

143Assert.Equal(2, compositeConstraint.Constraints.Count());

324Assert.Equal(2, compositeConstraint.Constraints.Count<IRouteConstraint>());

885if (x.InlineConstraints.Count() != y.InlineConstraints.Count())

260Assert.Equal(authTypeList.Count(), response.Headers.WwwAuthenticate.Count); 283Assert.Equal(authTypeList.Count(), response.Headers.WwwAuthenticate.Count); 327Assert.Equal(authTypeList.Count(), response.Headers.WwwAuthenticate.Count);

40Assert.Equal(2, response.Headers.Count()); 62Assert.Equal(3, response.Headers.Count()); 85Assert.Equal(2, response.Headers.Count()); 113Assert.Equal(3, response.Headers.Count()); 143Assert.Equal(2, response.Headers.Count()); 172Assert.Equal(2, response.Headers.Count()); 195Assert.Equal(2, response.Headers.Count());

31Assert.Equal(2, response.Headers.Count()); 235Assert.Equal(5, response.Headers.Count()); // Date, Server, Chunked 237Assert.Equal(2, response.Headers.GetValues("Custom1").Count()); 265Assert.Equal(5, response.Headers.Count()); // Date, Server, Chunked 267Assert.Equal(2, response.Headers.GetValues("Custom1").Count());

857Assert.True(expectedHeaderNames.Count() == expectedHeaderValues.Count(), $"{nameof(expectedHeaderNames)} and {nameof(expectedHeaderValues)} sizes must match"); 868Assert.Equal(expectedHeaderNames.Count(), parsedHeaders.Length);

841Assert.Equal(2, headers.Count()); // NB: enumerable count, not property 843Assert.Equal(3, headers.Count()); // NB: enumerable count, not property

407Assert.Equal(2, headers.Count()); // NB: enumerable count, not property 409Assert.Equal(3, headers.Count()); // NB: enumerable count, not property

174Assert.Equal(2, infos.Count()); // ipv4 and ipv6 182Assert.Equal(2, warnings.Count()); // ipv4 and ipv6 191Assert.Equal(2, warnings.Count()); // ipv4 and ipv6 192Assert.Equal(2, infos.Count()); // ipv4 and ipv6

403var useVarForFirstTerm = values.Count > 1 && values.Select(h => h.FirstNameIgnoreCaseSegment()).Distinct().Count() == 1; 450return start + $@"{Each(groups, (byFirstTerm, i) => $@"{(byFirstTerm.Count() == 1 ? $@"{Each(byFirstTerm, header => $@"

174Assert.Equal(4, endpoints.Count());

414if (connectionListener._pendingConnections.Count() == 0)

808Assert.Equal(2, app.GetOptions().Count());

44Assert.Equal(3, user.Identities.Count()); 74Assert.Equal(4, user.Identities.Count()); 86Assert.Equal(4, user.Identities.Count());

26Assert.Equal(3, hubMethods.Count()); 38Assert.Equal(4, hubMethods.Count());

63writer.Write(EntryProjectsFullPath.Count()); 69writer.Write(TargetNames.Count());

388var propertyCount = validProperties.Count();

597var hashAttributeCount = hashAttributes.Count();

597var hashAttributeCount = hashAttributes.Count();

38if (types.Count() > 0)

133if (attribute.Arguments == null || attribute.Arguments.Count() != 1) 159if (attribute.Arguments == null || attribute.Arguments.Count() != 2)

330genericArgumentsCount = genericType.GenericArguments.Count();

269if (excludedFields.Count() == 1)

876NestedTypes.Select(t => t.Name).Distinct().Count() == NestedTypes.Count());

1338Debug.Assert(debugTokens.Distinct().Count() == debugTokens.Count);

8091return set.Count == properties.Count();

891WriteValue(CompilationOptionNames.SourceFileCount, module.CommonCompilation.SyntaxTrees.Count().ToString());

33Debug.Assert(state.Generators.GroupBy(s => s.GetGeneratorType()).Count() == state.Generators.Length); // ensure we don't have duplicate generator types

647var count = data.First().Count(); 648Debug.Assert(data.All(d => d.Count() == count));

333int argumentCount = arguments.Count();

647var count = data.First().Count(); 648Debug.Assert(data.All(d => d.Count() == count));

179=> $"Interval tree with '{System.Linq.Enumerable.Count(this)}' entries. Use '.ToList()' to visualize contents.";

403if (words.Count() == 1) // Only Split if words have not been split before

647var count = data.First().Count(); 648Debug.Assert(data.All(d => d.Count() == count));

55this.PropertyValuesCount = propertyMappers.Count();

49arguments.Count() == 5 && 62arguments.Count() == 1 && 77arguments.Count() == 5 && 87arguments.Count() == 5 &&

179=> $"Interval tree with '{System.Linq.Enumerable.Count(this)}' entries. Use '.ToList()' to visualize contents.";

403if (words.Count() == 1) // Only Split if words have not been split before

647var count = data.First().Count(); 648Debug.Assert(data.All(d => d.Count() == count));

179=> $"Interval tree with '{System.Linq.Enumerable.Count(this)}' entries. Use '.ToList()' to visualize contents.";

403if (words.Count() == 1) // Only Split if words have not been split before

87if (group.Count() >= 2)

216properties = properties.AddRange(tagIndices.Select(kvp => new KeyValuePair<string, string?>(kvp.Key, EncodeIndices(kvp.Value, additionalLocations.Count()))));

647var count = data.First().Count(); 648Debug.Assert(data.All(d => d.Count() == count));

179=> $"Interval tree with '{System.Linq.Enumerable.Count(this)}' entries. Use '.ToList()' to visualize contents.";

403if (words.Count() == 1) // Only Split if words have not been split before

66if (declarationDeclarators.Count == fieldDeclarators.Count())

45Debug.Assert(diagnostics.Select(diagnostic => diagnostic.Properties[MatchFolderAndNamespaceConstants.TargetNamespace]).Distinct().Count() == 1);

925return referencedSymbols.Count() == 1 &&

647var count = data.First().Count(); 648Debug.Assert(data.All(d => d.Count() == count));

343Debug.Assert(ordinals is null || ordinals.Values.Count() == ordinals.Values.Distinct().Count());

831Debug.Assert(result.Result.BadArgumentsOpt.TrueBits().Count() == 1);

113if (parent.DescendantNodes().OfType<StatementSyntax>().Count() <= 1)

438if (group.Any(t => t.parameterIsWrittenTo) && group.Count() > 1)

72return [.. triviaList.Skip(triviaInLeadingBlankLines.Count())];

278Debug.Assert(originalIdentifierNodes.Count() == replacedIdentifierNodes.Count());

416return allNamespaces.Take(2).Count() == 1;

44var clauses = SyntaxFactory.List(allClauses.Take(allClauses.Count() - 1).Cast<QueryClauseSyntax>());

758Assert.Equal(1, errors.Count()); 760Assert.Equal(2, errors.First().Arguments.Count()); 770Assert.Equal(1, errors.Count()); 772Assert.Equal(2, errors.First().Arguments.Count()); 781Assert.Equal(1, errors.Count()); 783Assert.Equal(2, errors.First().Arguments.Count()); 792Assert.Equal(1, errors.Count()); 794Assert.Equal(2, errors.First().Arguments.Count()); 803Assert.Equal(1, errors.Count()); 805Assert.Equal(2, errors.First().Arguments.Count()); 814Assert.Equal(1, errors.Count()); 816Assert.Equal(2, errors.First().Arguments.Count()); 883Assert.Equal(1, errors.Count()); 885Assert.Equal(1, errors.First().Arguments.Count()); 1891Assert.Equal(0, parsedArgs.ParseOptions.PreprocessorSymbolNames.Count()); 1895Assert.Equal(1, parsedArgs.ParseOptions.PreprocessorSymbolNames.Count()); 1900Assert.Equal(3, parsedArgs.ParseOptions.PreprocessorSymbolNames.Count()); 1907Assert.Equal(1, parsedArgs.ParseOptions.PreprocessorSymbolNames.Count()); 4488Assert.Equal(1, Directory.EnumerateFiles(dir.Path, exeName).Count()); 7076Assert.Equal(1, Directory.EnumerateFiles(dir.Path, "*" + PathUtilities.GetExtension(expectedOutputName)).Count()); 7077Assert.Equal(1, Directory.EnumerateFiles(dir.Path, expectedOutputName).Count()); 11525Assert.Equal(1, parsedArgs.Errors.Count()); 11529Assert.Equal(1, parsedArgs.Errors.Count()); 11533Assert.Equal(2, parsedArgs.Errors.Count()); 11538Assert.Equal(1, parsedArgs.Errors.Count()); 11542Assert.Equal(1, parsedArgs.Errors.Count()); 11546Assert.Equal(1, parsedArgs.Errors.Count());

88Assert.True(expectedFolderPaths.Count() == actualFolderPaths.Count, "Number of available \"Move file\" actions are not equal.");

139if (spans.Count() == 1)

37Assert.Equal(0, results.Count());

211Assert.Equal(1, diagnosticsFromAnalyzer.Count()); 265Assert.Equal(2, diagnosticsFromAnalyzer.Count()); 284Assert.Equal(4, diagnosticsFromAnalyzer.Count());

68Assert.Equal(3, textElement.Runs.Count());

163Assert.Equal(0, items.Count()); 575Assert.Equal(expecteditems.Count, items.Count());

238Assert.Equal(0, items.Count());

86Assert.Equal(0, solution.Projects.Count()); 93Assert.Equal(1, solution.Projects.Count()); 108Assert.Equal(0, solution.Projects.Count()); 124Assert.Equal(0, solution.Projects.Count()); 327Assert.Equal(0, snapshot.GetProject(id1).ProjectReferences.Count()); 777Assert.Equal(2, workspace.CurrentSolution.GetProject(project1.Id).Documents.Count()); 798Assert.Equal(0, workspace.CurrentSolution.GetProject(project1.Id).Documents.Count()); 1068Assert.Equal(1, project.Documents.Count()); 1069Assert.Equal(1, project.AdditionalDocuments.Count()); 1092Assert.Equal(1, project.Documents.Count()); 1093Assert.Equal(1, project.AnalyzerConfigDocuments.Count()); 1256Assert.Equal(1, workspace.CurrentSolution.GetProject(project1.Id).Documents.Count()); 1257Assert.Equal(2, workspace.CurrentSolution.GetProject(project1.Id).AdditionalDocuments.Count()); 1266Assert.Equal(1, workspace.CurrentSolution.GetProject(project1.Id).Documents.Count()); 1267Assert.Equal(1, workspace.CurrentSolution.GetProject(project1.Id).AdditionalDocuments.Count()); 1292Assert.Equal(1, workspace.CurrentSolution.GetProject(project1.Id).Documents.Count()); 1293Assert.Equal(2, workspace.CurrentSolution.GetProject(project1.Id).AnalyzerConfigDocuments.Count()); 1302Assert.Equal(1, workspace.CurrentSolution.GetProject(project1.Id).Documents.Count()); 1303Assert.Equal(1, workspace.CurrentSolution.GetProject(project1.Id).AnalyzerConfigDocuments.Count()); 1325Assert.Equal(1, workspace.CurrentSolution.GetProject(project1.Id).Documents.Count()); 1326Assert.Equal(2, workspace.CurrentSolution.GetProject(project1.Id).AdditionalDocuments.Count()); 1332Assert.Equal(1, workspace.CurrentSolution.GetProject(project1.Id).Documents.Count()); 1333Assert.Equal(1, workspace.CurrentSolution.GetProject(project1.Id).AdditionalDocuments.Count()); 1353Assert.Equal(1, workspace.CurrentSolution.GetProject(project1.Id).Documents.Count()); 1354Assert.Equal(2, workspace.CurrentSolution.GetProject(project1.Id).AnalyzerConfigDocuments.Count()); 1360Assert.Equal(1, workspace.CurrentSolution.GetProject(project1.Id).Documents.Count()); 1361Assert.Equal(1, workspace.CurrentSolution.GetProject(project1.Id).AnalyzerConfigDocuments.Count());

67Assert.Equal(0, comp.GetDiagnostics().Count()); 202Assert.Equal(8, tree.GetDiagnostics().Count());

967Assert.Equal(1, spillFieldsByType.Count()); 968Assert.Equal(1, spillFieldsByType.Single(x => TypeSymbol.Equals(x.Key, comp.GetSpecialType(SpecialType.System_Int32), TypeCompareKind.ConsiderEverything2)).Count());

4242Assert.Equal(0, ctrlFlowAnalysis.ExitPoints.Count());

6440Assert.Equal(2, refs.Count());

643Assert.Equal(2, c.GetMembers().OfType<NamedTypeSymbol>().Count());

3169Assert.Equal(0, comp2.GetDiagnostics().Count()); 4147Assert.Equal(1, paramArrayAttributes.Count());

13301Assert.Equal(1, diagnostics.DiagnosticBag.AsEnumerable().Count());

20360Assert.Equal(2, model.GetDeclaredSymbol(c1).AllInterfaces.Count()); 20365Assert.Equal(1, model.GetDeclaredSymbol(c2).AllInterfaces.Count()); 20369Assert.Equal(1, model.GetDeclaredSymbol(c3).AllInterfaces.Count());

2738Assert.Equal(symbolsSynthesizedCount, cciExplicit.Count()); 2739Assert.Equal(symbolsSynthesizedCount, cciMethods.Count());

213Assert.Equal(2, refs2.Count());

6369var baseParameterCount = reader0.GetParameters().Count();

10693Assert.Equal(4, methods.Count());

2870Assert.Equal(1, delegateType.GetAttributes(typeAttrType).Count()); 2875Assert.Equal(1, typeParameters[0].GetAttributes(typeParamAttrType).Count()); 2883Assert.Equal(1, invokeMethod.GetReturnTypeAttributes().Where(a => TypeSymbol.Equals(a.AttributeClass, returnTypeAttrType, TypeCompareKind.ConsiderEverything2)).Count()); 2888Assert.Equal(1, parameters[0].GetAttributes(paramAttrType).Count()); 2890Assert.Equal(1, parameters[1].GetAttributes(paramAttrType).Count()); 2892Assert.Equal(1, parameters[2].GetAttributes(paramAttrType).Count()); 2912Assert.Equal(1, parameters[0].GetAttributes(paramAttrType).Count()); 2914Assert.Equal(1, parameters[1].GetAttributes(paramAttrType).Count()); 2916Assert.Equal(1, parameters[2].GetAttributes(paramAttrType).Count()); 2917Assert.Equal(0, parameters[3].GetAttributes(paramAttrType).Count()); 2918Assert.Equal(0, parameters[4].GetAttributes(paramAttrType).Count()); 2925Assert.Equal(1, endInvokeMethod.GetReturnTypeAttributes().Where(a => TypeSymbol.Equals(a.AttributeClass, returnTypeAttrType, TypeCompareKind.ConsiderEverything2)).Count()); 2929Assert.Equal(1, parameters[0].GetAttributes(paramAttrType).Count()); 2931Assert.Equal(1, parameters[1].GetAttributes(paramAttrType).Count()); 2932Assert.Equal(0, parameters[2].GetAttributes(paramAttrType).Count()); 3011Assert.Equal(1, parameters[0].GetAttributes(paramAttrType).Count()); 3013Assert.Equal(1, parameters[1].GetAttributes(paramAttrType).Count()); 3033Assert.Equal(1, parameters[0].GetAttributes(paramAttrType).Count()); 3035Assert.Equal(1, parameters[1].GetAttributes(paramAttrType).Count()); 3036Assert.Equal(0, parameters[2].GetAttributes(paramAttrType).Count()); 3037Assert.Equal(0, parameters[3].GetAttributes(paramAttrType).Count()); 3125Assert.Equal(2, syntax.ArgumentList.Arguments.Count()); 3127Assert.Equal(0, syntax.ArgumentList.Arguments.Count()); 3870Assert.Equal(1, attrs.Count()); 3873Assert.Equal(1, attrs.Count()); 3907Assert.Equal(1, attrs.Count()); 3955Assert.Equal(1, attrs.Count()); 4010Assert.Equal(1, attrs.Count()); 4016Assert.Equal(1, attrs.Count()); 4021Assert.Equal(1, attrs.Count()); 4029Assert.Equal(1, attrs.Count()); 4034Assert.Equal(1, attrs.Count()); 4520Assert.Equal(1, attrs.Count()); 4526Assert.Equal(1, attrs.Count()); 4575Assert.Equal(1, attrs.Count()); 4615Assert.Equal(1, attrs.Count()); 4965Assert.Equal(12, attrs.Count()); 5091Assert.Equal(1, gooMethod.GetAttributes(a1Class).Count()); 5092Assert.Equal(1, gooMethod.GetAttributes(a2Class).Count()); 5094Assert.Equal(1, gooMethod.GetReturnTypeAttributes().Where(a => TypeSymbol.Equals(a.AttributeClass, b1Class, TypeCompareKind.ConsiderEverything2)).Count()); 5095Assert.Equal(1, gooMethod.GetReturnTypeAttributes().Where(a => TypeSymbol.Equals(a.AttributeClass, b2Class, TypeCompareKind.ConsiderEverything2)).Count()); 5098Assert.Equal(1, typeParam1.GetAttributes(c1Class).Count()); 5099Assert.Equal(1, typeParam1.GetAttributes(c2Class).Count()); 5102Assert.Equal(1, typeParam2.GetAttributes(d1Class).Count()); 5103Assert.Equal(1, typeParam2.GetAttributes(d2Class).Count()); 5106Assert.Equal(1, param.GetAttributes(e1Class).Count()); 5107Assert.Equal(1, param.GetAttributes(e2Class).Count()); 5143Assert.Equal(1, type.GetAttributes(aClass).Count()); 5144Assert.Equal(1, type.GetAttributes(bClass).Count()); 5180Assert.Equal(1, typeParameter.GetAttributes(aClass).Count()); 5181Assert.Equal(1, typeParameter.GetAttributes(bClass).Count()); 5213Assert.Equal(1, GClass.GetAttributes(attributeType).Count()); 5216Assert.Equal(1, enumE.GetAttributes(attributeType).Count()); 5252Assert.Equal(1, attrs.Count()); 5258Assert.Equal(1, attrs.Count()); 5312Assert.Equal(2, attrs.Count()); 5324Assert.Equal(2, attrs.Count()); 5372Assert.Equal(1, attrs.Count()); 7540Assert.Equal(3, attrArgSyntaxes.Count()); 8857Assert.Equal(0, type.GetAttributes()[0].ConstructorArguments.Count());

1025Assert.Equal(expectedSrcAttrCount, sourceAttributes.Count()); 1038Assert.Equal(expectedEmittedAttrsCount, metadataAttributes.Count()); 2249Assert.Equal(1, attrlist.Count());

817Assert.Equal(0, attribute.ConstructorArguments.Count());

55Assert.Equal(1, typeSecurityAttributes.Count());

2810Assert.Equal(0, metadataReader.FieldDefinitions.AsEnumerable().Count()); 3761Assert.Equal(3, attrs.Count()); 3764Assert.Equal(1, attrs.Count()); 3768Assert.Equal(2, attrs.Count()); 3772Assert.Equal(0, attrs.Count()); 3776Assert.Equal(1, attrs.Count()); 3779Assert.Equal(1, attrs.Count()); 3892Assert.Equal(3, attrs.Count()); 3895Assert.Equal(1, attrs.Count()); 3899Assert.Equal(2, attrs.Count()); 3903Assert.Equal(0, attrs.Count()); 3907Assert.Equal(1, attrs.Count()); 3910Assert.Equal(1, attrs.Count()); 5151Assert.Equal(2, attrs.Count()); 5637Assert.Equal(1, typeA.GetAttributes(windowsRuntimeImportAttrType).Count()); 5701Assert.Equal(1, method.GetAttributes(dynamicSecurityMethodAttrType).Count());

1543Assert.Equal(1, attrInfos.Count());

98Assert.Equal(1, paramArrayAttributes.Count());

1723for (int i = 0; i < compilation.SyntaxTrees.Count(); i++)

119Assert.Equal(0, errs.Count()); 134Assert.Equal(1, errs.Count()); 232Assert.Equal(0, this.FlowDiagnostics(comp).Count()); 256Assert.Equal(0, this.FlowDiagnostics(comp).Count()); 272Assert.Equal(0, this.FlowDiagnostics(comp).Count()); 290Assert.Equal(0, this.FlowDiagnostics(comp).Count()); 305Assert.Equal(2, this.FlowDiagnostics(comp).Count()); 325Assert.Equal(1, this.FlowDiagnostics(comp).Count()); 432Assert.Equal(0, this.FlowDiagnostics(comp).Count()); 455Assert.Equal(0, this.FlowDiagnostics(comp).Count()); 479Assert.Equal(0, this.FlowDiagnostics(comp).Count());

42Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()); 43Assert.Equal(1, controlFlowAnalysisResults.ExitPoints.Count()); 44Assert.Equal(0, controlFlowAnalysisResults.ReturnStatements.Count()); 76Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()); 77Assert.Equal(1, controlFlowAnalysisResults.ExitPoints.Count()); 78Assert.Equal(0, controlFlowAnalysisResults.ReturnStatements.Count()); 106Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()); 107Assert.Equal(0, controlFlowAnalysisResults.ExitPoints.Count()); 108Assert.Equal(0, controlFlowAnalysisResults.ReturnStatements.Count()); 136Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()); 137Assert.Equal(0, controlFlowAnalysisResults.ExitPoints.Count()); 138Assert.Equal(0, controlFlowAnalysisResults.ReturnStatements.Count()); 166Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()); 167Assert.Equal(0, controlFlowAnalysisResults.ExitPoints.Count()); 168Assert.Equal(0, controlFlowAnalysisResults.ReturnStatements.Count()); 195Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()); 196Assert.Equal(0, controlFlowAnalysisResults.ExitPoints.Count()); 197Assert.Equal(0, controlFlowAnalysisResults.ReturnStatements.Count()); 225Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()); 226Assert.Equal(0, controlFlowAnalysisResults.ExitPoints.Count()); 227Assert.Equal(0, controlFlowAnalysisResults.ReturnStatements.Count()); 254Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()); 255Assert.Equal(0, controlFlowAnalysisResults.ExitPoints.Count()); 256Assert.Equal(0, controlFlowAnalysisResults.ReturnStatements.Count()); 300Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()); 301Assert.Equal(0, controlFlowAnalysisResults.ExitPoints.Count()); 302Assert.Equal(0, controlFlowAnalysisResults.ReturnStatements.Count()); 329Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()); 330Assert.Equal(0, controlFlowAnalysisResults.ExitPoints.Count()); 331Assert.Equal(0, controlFlowAnalysisResults.ReturnStatements.Count()); 358Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()); 359Assert.Equal(0, controlFlowAnalysisResults.ExitPoints.Count()); 360Assert.Equal(0, controlFlowAnalysisResults.ReturnStatements.Count()); 387Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()); 388Assert.Equal(0, controlFlowAnalysisResults.ExitPoints.Count()); 389Assert.Equal(0, controlFlowAnalysisResults.ReturnStatements.Count()); 416Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()); 417Assert.Equal(0, controlFlowAnalysisResults.ExitPoints.Count()); 418Assert.Equal(0, controlFlowAnalysisResults.ReturnStatements.Count()); 445Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()); 446Assert.Equal(0, controlFlowAnalysisResults.ExitPoints.Count()); 447Assert.Equal(0, controlFlowAnalysisResults.ReturnStatements.Count()); 471Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()); 472Assert.Equal(0, controlFlowAnalysisResults.ExitPoints.Count()); 473Assert.Equal(0, controlFlowAnalysisResults.ReturnStatements.Count()); 490Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()); 491Assert.Equal(0, controlFlowAnalysisResults.ExitPoints.Count()); 492Assert.Equal(0, controlFlowAnalysisResults.ReturnStatements.Count()); 509Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()); 510Assert.Equal(0, controlFlowAnalysisResults.ExitPoints.Count()); 511Assert.Equal(0, controlFlowAnalysisResults.ReturnStatements.Count()); 528Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()); 529Assert.Equal(0, controlFlowAnalysisResults.ExitPoints.Count()); 530Assert.Equal(0, controlFlowAnalysisResults.ReturnStatements.Count()); 547Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()); 548Assert.Equal(0, controlFlowAnalysisResults.ExitPoints.Count()); 549Assert.Equal(0, controlFlowAnalysisResults.ReturnStatements.Count()); 569Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()); 570Assert.Equal(0, controlFlowAnalysisResults.ExitPoints.Count()); 571Assert.Equal(0, controlFlowAnalysisResults.ReturnStatements.Count()); 688Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()); 689Assert.Equal(0, controlFlowAnalysisResults.ExitPoints.Count()); 690Assert.Equal(0, controlFlowAnalysisResults.ReturnStatements.Count()); 722Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()); 723Assert.Equal(0, controlFlowAnalysisResults.ExitPoints.Count()); 724Assert.Equal(0, controlFlowAnalysisResults.ReturnStatements.Count()); 884Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()); 885Assert.Equal(1, controlFlowAnalysisResults.ExitPoints.Count()); 916Assert.Equal(2, flow.VariablesDeclared.Count()); 938Assert.Equal(1, analysis.ExitPoints.Count()); 955Assert.Equal(1, analysis.ExitPoints.Count()); 975Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()); 976Assert.Equal(1, controlFlowAnalysisResults.ExitPoints.Count()); 1003Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()); 1004Assert.Equal(1, controlFlowAnalysisResults.ExitPoints.Count()); 1031Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()); 1032Assert.Equal(1, controlFlowAnalysisResults.ExitPoints.Count()); 1059Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()); 1060Assert.Equal(1, controlFlowAnalysisResults.ExitPoints.Count()); 1103Assert.Equal(1, controlFlowAnalysisResults.ExitPoints.Count()); 1168Assert.Equal(bkcount[idx], ctrlFlow.ExitPoints.Count()); 1233Assert.Equal(2, ctrlFlow.ExitPoints.Count()); 1237Assert.Equal(2, ctrlFlow.ExitPoints.Count()); 1241Assert.Equal(1, ctrlFlow.ExitPoints.Count()); 1323Assert.Equal(2, ctrlFlow.ExitPoints.Count()); 1327Assert.Equal(1, ctrlFlow.ExitPoints.Count()); 1331Assert.Equal(2, ctrlFlow.ExitPoints.Count()); 1335Assert.Equal(1, ctrlFlow.ExitPoints.Count());

2874Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()); 2875Assert.Equal(0, controlFlowAnalysisResults.ExitPoints.Count()); 2876Assert.Equal(0, controlFlowAnalysisResults.ReturnStatements.Count()); 2907Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()); 2908Assert.Equal(0, controlFlowAnalysisResults.ExitPoints.Count()); 2909Assert.Equal(0, controlFlowAnalysisResults.ReturnStatements.Count()); 3007Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()); 3008Assert.Equal(0, controlFlowAnalysisResults.ExitPoints.Count()); 3009Assert.Equal(0, controlFlowAnalysisResults.ReturnStatements.Count()); 3036Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()); 3037Assert.Equal(0, controlFlowAnalysisResults.ExitPoints.Count()); 3038Assert.Equal(0, controlFlowAnalysisResults.ReturnStatements.Count()); 3069Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()); 3070Assert.Equal(0, controlFlowAnalysisResults.ExitPoints.Count()); 3071Assert.Equal(0, controlFlowAnalysisResults.ReturnStatements.Count()); 3163Assert.Equal(1, analysis.EntryPoints.Count()); 3183Assert.Equal(2, analysis.ExitPoints.Count()); 3231Assert.Equal(1, analysis.ExitPoints.Count()); 3821Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()); 3822Assert.Equal(0, controlFlowAnalysisResults.ExitPoints.Count()); 3823Assert.Equal(0, controlFlowAnalysisResults.ReturnStatements.Count()); 3853Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()); 3854Assert.Equal(0, controlFlowAnalysisResults.ExitPoints.Count()); 3855Assert.Equal(0, controlFlowAnalysisResults.ReturnStatements.Count()); 3885Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()); 3886Assert.Equal(0, controlFlowAnalysisResults.ExitPoints.Count()); 3887Assert.Equal(0, controlFlowAnalysisResults.ReturnStatements.Count()); 3917Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()); 3918Assert.Equal(0, controlFlowAnalysisResults.ExitPoints.Count()); 3919Assert.Equal(0, controlFlowAnalysisResults.ReturnStatements.Count()); 3982Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()); 3983Assert.Equal(0, controlFlowAnalysisResults.ExitPoints.Count()); 3984Assert.Equal(0, controlFlowAnalysisResults.ReturnStatements.Count()); 4015Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()); 4016Assert.Equal(0, controlFlowAnalysisResults.ExitPoints.Count()); 4017Assert.Equal(0, controlFlowAnalysisResults.ReturnStatements.Count()); 4068Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()); 4069Assert.Equal(1, controlFlowAnalysisResults.ExitPoints.Count()); 4095Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()); 4096Assert.Equal(1, controlFlowAnalysisResults.ExitPoints.Count()); 4204Assert.Equal(2, controlFlowAnalysisResults.ExitPoints.Count()); 4273Assert.Equal(1, controlFlowAnalysisResults.ExitPoints.Count()); 4296Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()); 4297Assert.Equal(0, controlFlowAnalysisResults.ExitPoints.Count()); 4298Assert.Equal(0, controlFlowAnalysisResults.ReturnStatements.Count()); 4889Assert.Equal(2, analysis.ExitPoints.Count()); 4912Assert.Equal(1, analysis.ExitPoints.Count()); 4961Assert.Equal(1, analysis.ExitPoints.Count()); 4983Assert.Equal(1, analysis.ExitPoints.Count()); 5079Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()); 5080Assert.Equal(1, controlFlowAnalysisResults.ExitPoints.Count()); 5494Assert.Equal(4, flowAnalysis.ReadInside.Count()); 5495Assert.Equal(5, flowAnalysis.WrittenInside.Count()); 5496Assert.Equal(5, flowAnalysis.VariablesDeclared.Count()); 5499Assert.Equal(2, flowAnalysis.ReadInside.Count()); 5500Assert.Equal(2, flowAnalysis.WrittenInside.Count()); 5501Assert.Equal(0, flowAnalysis.VariablesDeclared.Count()); 5504Assert.Equal(2, flowAnalysis.ReadInside.Count()); 5505Assert.Equal(2, flowAnalysis.WrittenInside.Count()); 5506Assert.Equal(1, flowAnalysis.VariablesDeclared.Count()); 7421Assert.Equal(0, analysis.EntryPoints.Count()); 7443Assert.Equal(0, analysis.EntryPoints.Count()); 8945Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()); 8946Assert.Equal(0, controlFlowAnalysisResults.ExitPoints.Count()); 8971Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()); 8972Assert.Equal(1, controlFlowAnalysisResults.ExitPoints.Count()); 8996Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()); 8997Assert.Equal(1, controlFlowAnalysisResults.ExitPoints.Count()); 9041Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()); 9042Assert.Equal(0, controlFlowAnalysisResults.ExitPoints.Count()); 9090Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()); 9091Assert.Equal(0, controlFlowAnalysisResults.ExitPoints.Count());

86Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()); 87Assert.Equal(1, controlFlowAnalysisResults.ExitPoints.Count()); 142Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()); 143Assert.Equal(3, controlFlowAnalysisResults.ExitPoints.Count()); 144Assert.Equal(0, controlFlowAnalysisResults.ReturnStatements.Count()); 200Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()); 201Assert.Equal(5, controlFlowAnalysisResults.ExitPoints.Count()); 258Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()); 259Assert.Equal(2, controlFlowAnalysisResults.ExitPoints.Count()); 260Assert.Equal(0, controlFlowAnalysisResults.ReturnStatements.Count()); 296Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()); 297Assert.Equal(0, controlFlowAnalysisResults.ExitPoints.Count()); 298Assert.Equal(0, controlFlowAnalysisResults.ReturnStatements.Count()); 341Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()); 342Assert.Equal(0, controlFlowAnalysisResults.ExitPoints.Count()); 343Assert.Equal(0, controlFlowAnalysisResults.ReturnStatements.Count()); 402Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()); 403Assert.Equal(0, controlFlowAnalysisResults.ExitPoints.Count()); 404Assert.Equal(0, controlFlowAnalysisResults.ReturnStatements.Count()); 447Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()); 448Assert.Equal(0, controlFlowAnalysisResults.ExitPoints.Count()); 449Assert.Equal(0, controlFlowAnalysisResults.ReturnStatements.Count()); 1515Assert.Equal(0, analysisControlFlow.ReturnStatements.Count()); 1701Assert.Equal(1, analysisControlFlow.ExitPoints.Count()); 1702Assert.Equal(0, analysisControlFlow.EntryPoints.Count()); 1740Assert.Equal(0, analysisControlFlow.ExitPoints.Count()); 1741Assert.Equal(0, analysisControlFlow.EntryPoints.Count()); 1742Assert.Equal(0, analysisControlFlow.ReturnStatements.Count());

20658Assert.Equal(1, compilation.SyntaxTrees[0].GetRoot().DescendantNodesAndSelf().OfType<DeclarationExpressionSyntax>().Count()); 32743Assert.True(symbols.Count() > 1); 32772Assert.True(symbols.Count() > 1);

254Assert.True(symbols.Count() > 1); 307Assert.True(symbols.Count() > 1);

11552Assert.Equal(2, yRefs.Count());

828Assert.Equal(1, c.InstanceConstructors.Count()); 832Assert.Equal(2, c.InstanceConstructors.Count()); 3104Assert.Equal(2, comp.GetTypeByMetadataName("Test2").InstanceConstructors.Where(c => !c.IsDefaultValueTypeConstructor()).Single().Parameters[0].GetAttributes().Count()); 3147Assert.Equal(1, comp.GetTypeByMetadataName("Test2").InstanceConstructors.Where(c => !c.IsDefaultValueTypeConstructor()).Single().Parameters[0].GetAttributes().Count()); 6512Assert.Equal(1, cConstructor.DeclaringSyntaxReferences.Count()); 6590Assert.Equal(1, eConstructor.DeclaringSyntaxReferences.Count()); 6634Assert.Equal(1, eConstructor.DeclaringSyntaxReferences.Count()); 6674Assert.Equal(1, eConstructor.DeclaringSyntaxReferences.Count()); 8009Assert.Equal(1, diagnosticsToCheck.Where(d => d.Code is (int)ErrorCode.ERR_BlockBodyAndExpressionBody).Count()); 8016Assert.Equal(1, diagnosticsToCheck.Where(d => d.Code is (int)ErrorCode.ERR_AttributesNotAllowed).Count()); 20405Assert.Equal(1, m.GlobalNamespace.GetTypeMember("S").GetMembers().OfType<FieldSymbol>().Count());

28894Assert.Equal(1, cConstructor.DeclaringSyntaxReferences.Count()); 28998Assert.Equal(1, eConstructor.DeclaringSyntaxReferences.Count()); 29056Assert.Equal(1, eConstructor.DeclaringSyntaxReferences.Count()); 29105Assert.Equal(1, eConstructor.DeclaringSyntaxReferences.Count());

816if (paramNodes.Count() != declaredParameters.Length)

243var groupCount = group.Count();

290statement.SpanStart, cancellationToken), memberDeclarationSymbol)).Count();

49var identifiersCount = identifiers.Count();

753if (memberDeclarationNode.DescendantNodes().OfType<ReturnStatementSyntax>().Count() == 1)

107if (memberDeclaration is null || memberDeclaration is not BaseMethodDeclarationSyntax baseMethodDeclaration || baseMethodDeclaration.GetDiagnostics().Count() > 3)

113if (parent.DescendantNodes().OfType<StatementSyntax>().Count() <= 1)

438if (group.Any(t => t.parameterIsWrittenTo) && group.Count() > 1)

416return allNamespaces.Take(2).Count() == 1;

489Assert.Equal(2, diagnostics.Where(d => d.Id == "CS0219").Count()); 503Assert.Equal(1, diagnostics.Where(d => d.Id == "CS0168").Count());

662Assert.Equal(2, newProject.Documents.Count()); 663Assert.Equal(0, changes.GetChangedDocuments().Count()); 664Assert.Equal(1, changes.GetAddedDocuments().Count()); 708Assert.Equal(2, newProject.Documents.Count()); 709Assert.Equal(0, changes.GetChangedDocuments().Count()); 710Assert.Equal(1, changes.GetAddedDocuments().Count());

208Assert.Equal(0, SyntaxUtilities.GetSuspensionPoints(m0.ExpressionBody).Count()); 209Assert.Equal(1, SyntaxUtilities.GetSuspensionPoints(m1.ExpressionBody).Count()); 210Assert.Equal(1, SyntaxUtilities.GetSuspensionPoints(m2.Body).Count()); 211Assert.Equal(0, SyntaxUtilities.GetSuspensionPoints(m3.Body).Count()); 212Assert.Equal(1, SyntaxUtilities.GetSuspensionPoints(f1.ExpressionBody).Count()); 213Assert.Equal(1, SyntaxUtilities.GetSuspensionPoints(f2.Body).Count()); 214Assert.Equal(1, SyntaxUtilities.GetSuspensionPoints(l1.Body).Count()); 215Assert.Equal(1, SyntaxUtilities.GetSuspensionPoints(l2.Body).Count()); 216Assert.Equal(1, SyntaxUtilities.GetSuspensionPoints(l3.Body).Count());

613Assert.Equal(2, declarator.ChildOperations.Count()); 635Assert.Equal(1, declarator.ChildOperations.Count()); 656Assert.Equal(1, declarator.ChildOperations.Count()); 851Assert.Equal(2, declaration.ChildOperations.Count()); 873Assert.Equal(2, declaration.ChildOperations.Count());

62Assert.True(parens.Count() == 2, "Expect exactly two parenthesized lambda expressions in the syntax tree.");

4170Assert.Equal(2, designations.Count()); 4238Assert.Equal(4, designations.Count()); 4257Assert.Equal(3, declarations.Count()); 4373Assert.Equal(4, designations.Count()); 4392Assert.Equal(3, declarations.Count()); 4516Assert.Equal(3, declarations.Count()); 4666Assert.Equal(2, declarations.Count()); 4760Assert.Equal(2, declarations.Count()); 4838Assert.Equal(2, declarations.Count()); 5187Assert.Equal(4, designations.Count()); 5206Assert.Equal(3, declarations.Count()); 5331Assert.Equal(4, designations.Count()); 5350Assert.Equal(3, declarations.Count()); 5487Assert.Equal(3, declarations.Count()); 5655Assert.Equal(4, designations.Count()); 5674Assert.Equal(2, declarations.Count()); 5765Assert.Equal(4, designations.Count()); 5784Assert.Equal(2, declarations.Count()); 5887Assert.Equal(2, declarations.Count());

616Assert.Equal(1, tree.GetRoot().DescendantNodes().OfType<ArrowExpressionClauseSyntax>().Count()); 840Assert.Equal(2, nodes.Count()); 875Assert.Equal(2, nodes.Count()); 914Assert.Equal(2, nodes.Count());

266int numInitializers = expectedInitializers.Count();

8242Assert.Equal(expectedErrors.Length, actualErrors.Count());

3193Assert.Equal(2, nodes.Count());

384Assert.Equal(0, comp2.GetDiagnostics().Count()); 473Assert.True(0 < errs.Count(), "Diagnostics not empty"); 474Assert.True(0 < errs.Where(e => e.Code == 1525).Select(e => e).Count(), "Diagnostics contains CS1525"); 530Assert.Equal(0, csProject.GetDiagnostics().Count());

56Assert.Equal(0, comp.GetDeclarationDiagnostics().Count()); 78Assert.Equal(0, comp.GetDeclarationDiagnostics().Count()); 325Assert.Equal(1, tree.GetDiagnostics().Count()); 418Assert.Equal(1, comp.GetDiagnostics().Count()); 442Assert.Equal(1, comp.GetDiagnostics().Count()); 465Assert.Equal(1, comp.GetDiagnostics().Count()); 488Assert.Equal(1, comp.GetDiagnostics().Count()); 511Assert.Equal(1, comp.GetDiagnostics().Count()); 955Assert.Equal(0, comp.GetDeclarationDiagnostics().Count());

503int analyzed = nullableAnalysisData.Data.Where(pair => pair.Value.RequiredAnalysis).Count();

3255Assert.Equal(1, errs.Count());

1046Assert.Equal(15, variables.Count()); 1148Assert.Equal(15, variables.Count());

54Assert.Equal(5, variables.Count()); 128Assert.Equal(5, variables.Count());

1737Assert.True(defaults.Count() == 4); 1803Assert.True(defaults.Count() == 4); 1874Assert.True(defaults.Count() == 4);

137Assert.Equal(2, outputCompilation.SyntaxTrees.Count()); 229Assert.Equal(2, outputCompilation1.SyntaxTrees.Count()); 230Assert.Equal(2, outputCompilation2.SyntaxTrees.Count()); 231Assert.Equal(2, outputCompilation3.SyntaxTrees.Count()); 355Assert.Equal(2, outputCompilation.SyntaxTrees.Count()); 473Assert.Equal(2, outputCompilation.SyntaxTrees.Count()); 512Assert.Equal(1, outputCompilation.SyntaxTrees.Count()); 533Assert.Equal(3, outputCompilation.SyntaxTrees.Count()); 898Assert.Equal(2, outputCompilation.SyntaxTrees.Count()); 1676Assert.Equal(2, outputCompilation.SyntaxTrees.Count()); 4692Assert.Equal(2, result.HostOutputs.Keys.Count());

457Assert.Equal(2, compilation.SyntaxTrees.Count());

834Assert.InRange(comp.GetDiagnostics().Count(), 0, int.MaxValue); 835Assert.InRange(comp.GetDeclarationDiagnostics().Count(), 0, int.MaxValue); 888Assert.InRange(comp.GetDiagnostics().Count(), 0, int.MaxValue); 893Assert.Equal(0, comp.GetDiagnostics(cancellationToken: default(CancellationToken)).Count()); 898Assert.InRange(comp.GetDiagnostics().Count(), 0, int.MaxValue); 901Assert.Equal(0, comp.GetDiagnostics().Count()); 906Assert.InRange(error.Count(), 1, int.MaxValue); 909Assert.Equal(0, comp.GetDiagnostics().Count()); 1902Assert.Equal(2, comp.References.Count()); 2610Assert.Equal(1, type.GetMembers().OfType<IPropertySymbol>().Count()); 2631Assert.Equal(2, type.GetMembers().OfType<IPropertySymbol>().Count()); 2646Assert.Equal(2, type.GetMembers().OfType<IPropertySymbol>().Count());

209Assert.Equal(0, new CSharpCompilationOptions(OutputKind.ConsoleApplication).WithUsings("A", "B").WithUsings(null).Usings.Count()); 210Assert.Equal(0, new CSharpCompilationOptions(OutputKind.ConsoleApplication).WithUsings("A", "B").WithUsings((string[])null).Usings.Count());

417Assert.Equal(4, errs.Count()); 419Assert.Equal(1, errs.Count()); 421Assert.Equal(2, errs.Count()); 423Assert.Equal(1, errs.Count()); 444Assert.Equal(0, errs.Count()); 446Assert.Equal(0, errs.Count()); 493Assert.Equal(3, errs.Count()); 495Assert.Equal(0, errs.Count()); 5784Assert.Equal(3, errs.Count()); 5786Assert.Equal(0, errs.Count()); 5788Assert.Equal(1, errs.Count()); 5790Assert.Equal(2, errs.Count());

487Assert.Equal(1, errs.Count()); 519Assert.Equal(1, errs.Count()); 844Assert.Equal(1, typeA.Count()); 846Assert.Equal(1, invalid.Count()); 1042Assert.Equal(4, anonProps.Count()); 1073Assert.Equal(5, anonProps.Count()); 1114Assert.Equal(4, anonProps.Count()); 1158Assert.Equal(9, anonProps.Count()); 1196Assert.Equal(1, paras.Count()); 1201Assert.Equal(2, args.Count());

1387Assert.Equal(9, symbolsInC.Where(s => s.ContainingType == null || s.ContainingType.SpecialType != SpecialType.System_Object).Count()); 1634Assert.Equal(9, symbols.Count()); // A.X, B.Y, C.Z, Object.ToString, Object.Equals, Object.Finalize, Object.GetHashCode, Object.GetType, Object.MemberwiseClone 1637Assert.Equal(9, symbols2.Count()); // A.X, B.Y, C.Z, Object.ToString, Object.Equals, Object.Finalize, Object.GetHashCode, Object.GetType, Object.MemberwiseClone

243Assert.Equal(count, compilation.GetSymbolsWithName(name, filter).Count()); 251Assert.Equal(count, compilation.GetSymbolsWithName(predicate, filter).Count());

116if (tryRemove.Count() > 1) 334if (tryRemove.Count() > 1) 639Assert.True(comp2.References.Count() > 1); 2328Assert.True(comp.References.Count() > 1);

302Assert.Equal(4, crefSyntaxes.Count()); 4699Assert.Equal(5, crefSyntaxes.Count()); 4755Assert.Equal(5, crefSyntaxes.Count()); 5380Assert.Equal(0, GetCrefSyntaxes(compilation).Count());

6938Assert.Equal(2, comp.GetMethodBodyDiagnostics().Count()); 6939Assert.Equal(2, comp.GetDiagnostics().Count());

36Assert.Equal(2, nameSyntaxes.Count()); 59Assert.Equal(2, nameSyntaxes.Count()); 83Assert.Equal(2, nameSyntaxes.Count()); 107Assert.Equal(2, nameSyntaxes.Count()); 136Assert.Equal(2, nameSyntaxes.Count()); 161Assert.Equal(2, nameSyntaxes.Count()); 186Assert.Equal(2, nameSyntaxes.Count()); 207Assert.Equal(2, nameSyntaxes.Count()); 228Assert.Equal(2, nameSyntaxes.Count()); 249Assert.Equal(2, nameSyntaxes.Count()); 274Assert.Equal(2, nameSyntaxes.Count()); 300Assert.Equal(3, nameSyntaxes.Count()); 375Assert.Equal(2, nameSyntaxes.Count()); 628Assert.Equal(1, GetNameAttributeValues(compilation).Count()); 669Assert.Equal(0, GetNameAttributeValues(compilation).Count()); 714Assert.Equal(0, GetNameAttributeValues(compilation).Count());

140Assert.Equal(0, comp.GetDiagnostics().Count());

880Assert.Equal(5, mems.Count());

240Assert.Equal(2, type.GetFields(BindingFlags.NonPublic | BindingFlags.Instance).Count());

138Assert.Equal(1, (from a in asm1[1].BoundReferences() where !a.IsMissing select a).Count()); 139Assert.Equal(1, (from a in asm1[1].BoundReferences() where object.ReferenceEquals(a, asm1[0]) select a).Count()); 156Assert.Equal(2, (from a in asm2[1].BoundReferences() where !a.IsMissing select a).Count()); 157Assert.Equal(1, (from a in asm2[1].BoundReferences() where object.ReferenceEquals(a, asm2[0]) select a).Count()); 158Assert.Equal(1, (from a in asm2[1].BoundReferences() where object.ReferenceEquals(a, asm2[2]) select a).Count()); 169Assert.Equal(1, (from a in asm2[2].BoundReferences() where !a.IsMissing select a).Count()); 170Assert.Equal(1, (from a in asm2[2].BoundReferences() where object.ReferenceEquals(a, asm2[0]) select a).Count()); 187Assert.Equal(2, (from a in asm3[1].BoundReferences() where !a.IsMissing select a).Count()); 188Assert.Equal(1, (from a in asm3[1].BoundReferences() where object.ReferenceEquals(a, asm3[0]) select a).Count()); 189Assert.Equal(1, (from a in asm3[1].BoundReferences() where object.ReferenceEquals(a, asm3[2]) select a).Count()); 202Assert.Equal(1, (from a in asm3[2].BoundReferences() where !a.IsMissing select a).Count()); 203Assert.Equal(1, (from a in asm3[2].BoundReferences() where object.ReferenceEquals(a, asm3[0]) select a).Count()); 206Assert.Equal(3, (from a in asm3[3].BoundReferences() where !a.IsMissing select a).Count()); 207Assert.Equal(1, (from a in asm3[3].BoundReferences() where object.ReferenceEquals(a, asm3[0]) select a).Count()); 208Assert.Equal(1, (from a in asm3[3].BoundReferences() where object.ReferenceEquals(a, asm3[1]) select a).Count()); 209Assert.Equal(1, (from a in asm3[3].BoundReferences() where object.ReferenceEquals(a, asm3[2]) select a).Count()); 246Assert.Equal(2, (from a in asm4[1].BoundReferences() where !a.IsMissing select a).Count()); 247Assert.Equal(1, (from a in asm4[1].BoundReferences() where object.ReferenceEquals(a, asm4[0]) select a).Count()); 248Assert.Equal(1, (from a in asm4[1].BoundReferences() where object.ReferenceEquals(a, asm4[2]) select a).Count()); 263Assert.Equal(1, (from a in asm4[2].BoundReferences() where !a.IsMissing select a).Count()); 264Assert.Equal(1, (from a in asm4[2].BoundReferences() where object.ReferenceEquals(a, asm4[0]) select a).Count()); 269Assert.Equal(3, (from a in asm4[3].BoundReferences() where !a.IsMissing select a).Count()); 270Assert.Equal(1, (from a in asm4[3].BoundReferences() where object.ReferenceEquals(a, asm4[0]) select a).Count()); 271Assert.Equal(1, (from a in asm4[3].BoundReferences() where object.ReferenceEquals(a, asm4[1]) select a).Count()); 272Assert.Equal(1, (from a in asm4[3].BoundReferences() where object.ReferenceEquals(a, asm4[2]) select a).Count()); 293Assert.Equal(4, (from a in asm4[4].BoundReferences() where !a.IsMissing select a).Count()); 294Assert.Equal(1, (from a in asm4[4].BoundReferences() where object.ReferenceEquals(a, asm4[0]) select a).Count()); 295Assert.Equal(1, (from a in asm4[4].BoundReferences() where object.ReferenceEquals(a, asm4[1]) select a).Count()); 296Assert.Equal(1, (from a in asm4[4].BoundReferences() where object.ReferenceEquals(a, asm4[2]) select a).Count()); 297Assert.Equal(1, (from a in asm4[4].BoundReferences() where object.ReferenceEquals(a, asm4[3]) select a).Count()); 361Assert.Equal(2, (from a in asm7[2].BoundReferences() where !a.IsMissing select a).Count()); 362Assert.Equal(1, (from a in asm7[2].BoundReferences() where object.ReferenceEquals(a, asm7[0]) select a).Count()); 363Assert.Equal(1, (from a in asm7[2].BoundReferences() where object.ReferenceEquals(a, asm7[1]) select a).Count()); 383Assert.Equal(3, (from a in asm7[3].BoundReferences() where !a.IsMissing select a).Count()); 384Assert.Equal(1, (from a in asm7[3].BoundReferences() where object.ReferenceEquals(a, asm7[0]) select a).Count()); 385Assert.Equal(1, (from a in asm7[3].BoundReferences() where object.ReferenceEquals(a, asm7[1]) select a).Count()); 386Assert.Equal(1, (from a in asm7[3].BoundReferences() where object.ReferenceEquals(a, asm7[2]) select a).Count()); 456Assert.Equal(1, (from a in asm1[1].BoundReferences() where !a.IsMissing select a).Count()); 457Assert.Equal(1, (from a in asm1[1].BoundReferences() where ReferenceEquals(a, asm1[0]) select a).Count()); 467Assert.Equal(2, (from a in asm2[1].BoundReferences() where !a.IsMissing select a).Count()); 468Assert.Equal(1, (from a in asm2[1].BoundReferences() where ReferenceEquals(a, asm2[0]) select a).Count()); 469Assert.Equal(1, (from a in asm2[1].BoundReferences() where ReferenceEquals(a, asm2[2]) select a).Count()); 480Assert.Equal(1, (from a in asm2[2].BoundReferences() where !a.IsMissing select a).Count()); 481Assert.Equal(1, (from a in asm2[2].BoundReferences() where ReferenceEquals(a, asm2[0]) select a).Count()); 489Assert.Equal(2, (from a in asm3[1].BoundReferences() where !a.IsMissing select a).Count()); 490Assert.Equal(1, (from a in asm3[1].BoundReferences() where ReferenceEquals(a, asm3[0]) select a).Count()); 491Assert.Equal(1, (from a in asm3[1].BoundReferences() where ReferenceEquals(a, asm3[2]) select a).Count()); 504Assert.Equal(1, (from a in asm3[2].BoundReferences() where !a.IsMissing select a).Count()); 505Assert.Equal(1, (from a in asm3[2].BoundReferences() where ReferenceEquals(a, asm3[0]) select a).Count()); 508Assert.Equal(3, (from a in asm3[3].BoundReferences() where !a.IsMissing select a).Count()); 509Assert.Equal(1, (from a in asm3[3].BoundReferences() where ReferenceEquals(a, asm3[0]) select a).Count()); 510Assert.Equal(1, (from a in asm3[3].BoundReferences() where ReferenceEquals(a, asm3[1]) select a).Count()); 511Assert.Equal(1, (from a in asm3[3].BoundReferences() where ReferenceEquals(a, asm3[2]) select a).Count()); 538Assert.Equal(2, (from a in asm4[1].BoundReferences() where !a.IsMissing select a).Count()); 539Assert.Equal(1, (from a in asm4[1].BoundReferences() where ReferenceEquals(a, asm4[0]) select a).Count()); 540Assert.Equal(1, (from a in asm4[1].BoundReferences() where ReferenceEquals(a, asm4[2]) select a).Count()); 555Assert.Equal(1, (from a in asm4[2].BoundReferences() where !a.IsMissing select a).Count()); 556Assert.Equal(1, (from a in asm4[2].BoundReferences() where ReferenceEquals(a, asm4[0]) select a).Count()); 561Assert.Equal(3, (from a in asm4[3].BoundReferences() where !a.IsMissing select a).Count()); 562Assert.Equal(1, (from a in asm4[3].BoundReferences() where ReferenceEquals(a, asm4[0]) select a).Count()); 563Assert.Equal(1, (from a in asm4[3].BoundReferences() where ReferenceEquals(a, asm4[1]) select a).Count()); 564Assert.Equal(1, (from a in asm4[3].BoundReferences() where ReferenceEquals(a, asm4[2]) select a).Count()); 585Assert.Equal(4, (from a in asm4[4].BoundReferences() where !a.IsMissing select a).Count()); 586Assert.Equal(1, (from a in asm4[4].BoundReferences() where ReferenceEquals(a, asm4[0]) select a).Count()); 587Assert.Equal(1, (from a in asm4[4].BoundReferences() where ReferenceEquals(a, asm4[1]) select a).Count()); 588Assert.Equal(1, (from a in asm4[4].BoundReferences() where ReferenceEquals(a, asm4[2]) select a).Count()); 589Assert.Equal(1, (from a in asm4[4].BoundReferences() where ReferenceEquals(a, asm4[3]) select a).Count()); 627Assert.Equal(2, (from a in asm7[2].BoundReferences() where !a.IsMissing select a).Count()); 628Assert.Equal(1, (from a in asm7[2].BoundReferences() where ReferenceEquals(a, asm7[0]) select a).Count()); 629Assert.Equal(1, (from a in asm7[2].BoundReferences() where ReferenceEquals(a, asm7[1]) select a).Count()); 649Assert.Equal(3, (from a in asm7[3].BoundReferences() where !a.IsMissing select a).Count()); 650Assert.Equal(1, (from a in asm7[3].BoundReferences() where ReferenceEquals(a, asm7[0]) select a).Count()); 651Assert.Equal(1, (from a in asm7[3].BoundReferences() where ReferenceEquals(a, asm7[1]) select a).Count()); 652Assert.Equal(1, (from a in asm7[3].BoundReferences() where ReferenceEquals(a, asm7[2]) select a).Count()); 739Assert.Equal(2, (from a in asm2[1].BoundReferences() where !a.IsMissing select a).Count()); 740Assert.Equal(1, (from a in asm2[1].BoundReferences() where object.ReferenceEquals(a, asm2[0]) select a).Count()); 741Assert.Equal(1, (from a in asm2[1].BoundReferences() where object.ReferenceEquals(a, asm2[2]) select a).Count()); 752Assert.Equal(1, (from a in asm2[2].BoundReferences() where !a.IsMissing select a).Count()); 753Assert.Equal(1, (from a in asm2[2].BoundReferences() where object.ReferenceEquals(a, asm2[0]) select a).Count()); 835Assert.Equal(2, (from a in asm3[1].BoundReferences() where !a.IsMissing select a).Count()); 836Assert.Equal(1, (from a in asm3[1].BoundReferences() where object.ReferenceEquals(a, asm3[0]) select a).Count()); 837Assert.Equal(1, (from a in asm3[1].BoundReferences() where object.ReferenceEquals(a, asm3[2]) select a).Count()); 850Assert.Equal(1, (from a in asm3[2].BoundReferences() where !a.IsMissing select a).Count()); 851Assert.Equal(1, (from a in asm3[2].BoundReferences() where object.ReferenceEquals(a, asm3[0]) select a).Count()); 854Assert.Equal(3, (from a in asm3[3].BoundReferences() where !a.IsMissing select a).Count()); 855Assert.Equal(1, (from a in asm3[3].BoundReferences() where object.ReferenceEquals(a, asm3[0]) select a).Count()); 856Assert.Equal(1, (from a in asm3[3].BoundReferences() where object.ReferenceEquals(a, asm3[1]) select a).Count()); 857Assert.Equal(1, (from a in asm3[3].BoundReferences() where object.ReferenceEquals(a, asm3[2]) select a).Count()); 976Assert.Equal(2, (from a in asm4[1].BoundReferences() where !a.IsMissing select a).Count()); 977Assert.Equal(1, (from a in asm4[1].BoundReferences() where object.ReferenceEquals(a, asm4[0]) select a).Count()); 978Assert.Equal(1, (from a in asm4[1].BoundReferences() where object.ReferenceEquals(a, asm4[2]) select a).Count()); 993Assert.Equal(1, (from a in asm4[2].BoundReferences() where !a.IsMissing select a).Count()); 994Assert.Equal(1, (from a in asm4[2].BoundReferences() where object.ReferenceEquals(a, asm4[0]) select a).Count()); 999Assert.Equal(3, (from a in asm4[3].BoundReferences() where !a.IsMissing select a).Count()); 1000Assert.Equal(1, (from a in asm4[3].BoundReferences() where object.ReferenceEquals(a, asm4[0]) select a).Count()); 1001Assert.Equal(1, (from a in asm4[3].BoundReferences() where object.ReferenceEquals(a, asm4[1]) select a).Count()); 1002Assert.Equal(1, (from a in asm4[3].BoundReferences() where object.ReferenceEquals(a, asm4[2]) select a).Count()); 1023Assert.Equal(4, (from a in asm4[4].BoundReferences() where !a.IsMissing select a).Count()); 1024Assert.Equal(1, (from a in asm4[4].BoundReferences() where object.ReferenceEquals(a, asm4[0]) select a).Count()); 1025Assert.Equal(1, (from a in asm4[4].BoundReferences() where object.ReferenceEquals(a, asm4[1]) select a).Count()); 1026Assert.Equal(1, (from a in asm4[4].BoundReferences() where object.ReferenceEquals(a, asm4[2]) select a).Count()); 1027Assert.Equal(1, (from a in asm4[4].BoundReferences() where object.ReferenceEquals(a, asm4[3]) select a).Count()); 1089Assert.Equal(2, (from a in asm7[2].BoundReferences() where !a.IsMissing select a).Count()); 1090Assert.Equal(1, (from a in asm7[2].BoundReferences() where object.ReferenceEquals(a, asm7[0]) select a).Count()); 1091Assert.Equal(1, (from a in asm7[2].BoundReferences() where object.ReferenceEquals(a, asm7[1]) select a).Count()); 1099Assert.Equal(0, (from a in asm7 where a != null && a.Name == "MTTestLib1" select a).Count()); 1112Assert.Equal(3, (from a in asm7[3].BoundReferences() where !a.IsMissing select a).Count()); 1113Assert.Equal(1, (from a in asm7[3].BoundReferences() where object.ReferenceEquals(a, asm7[0]) select a).Count()); 1114Assert.Equal(1, (from a in asm7[3].BoundReferences() where object.ReferenceEquals(a, asm7[1]) select a).Count()); 1115Assert.Equal(1, (from a in asm7[3].BoundReferences() where object.ReferenceEquals(a, asm7[2]) select a).Count()); 1187Assert.Equal(2, (from a in asm2[1].BoundReferences() where !a.IsMissing select a).Count()); 1188Assert.Equal(1, (from a in asm2[1].BoundReferences() where object.ReferenceEquals(a, asm2[0]) select a).Count()); 1189Assert.Equal(1, (from a in asm2[1].BoundReferences() where object.ReferenceEquals(a, asm2[2]) select a).Count()); 1200Assert.Equal(1, (from a in asm2[2].BoundReferences() where !a.IsMissing select a).Count()); 1201Assert.Equal(1, (from a in asm2[2].BoundReferences() where object.ReferenceEquals(a, asm2[0]) select a).Count()); 1214Assert.Equal(2, (from a in asm3[1].BoundReferences() where !a.IsMissing select a).Count()); 1215Assert.Equal(1, (from a in asm3[1].BoundReferences() where object.ReferenceEquals(a, asm3[0]) select a).Count()); 1216Assert.Equal(1, (from a in asm3[1].BoundReferences() where object.ReferenceEquals(a, asm3[2]) select a).Count()); 1229Assert.Equal(1, (from a in asm3[2].BoundReferences() where !a.IsMissing select a).Count()); 1230Assert.Equal(1, (from a in asm3[2].BoundReferences() where object.ReferenceEquals(a, asm3[0]) select a).Count()); 1233Assert.Equal(3, (from a in asm3[3].BoundReferences() where !a.IsMissing select a).Count()); 1234Assert.Equal(1, (from a in asm3[3].BoundReferences() where object.ReferenceEquals(a, asm3[0]) select a).Count()); 1235Assert.Equal(1, (from a in asm3[3].BoundReferences() where object.ReferenceEquals(a, asm3[1]) select a).Count()); 1236Assert.Equal(1, (from a in asm3[3].BoundReferences() where object.ReferenceEquals(a, asm3[2]) select a).Count()); 1267Assert.Equal(2, (from a in asm4[1].BoundReferences() where !a.IsMissing select a).Count()); 1268Assert.Equal(1, (from a in asm4[1].BoundReferences() where object.ReferenceEquals(a, asm4[0]) select a).Count()); 1269Assert.Equal(1, (from a in asm4[1].BoundReferences() where object.ReferenceEquals(a, asm4[2]) select a).Count()); 1284Assert.Equal(1, (from a in asm4[2].BoundReferences() where !a.IsMissing select a).Count()); 1285Assert.Equal(1, (from a in asm4[2].BoundReferences() where object.ReferenceEquals(a, asm4[0]) select a).Count()); 1290Assert.Equal(3, (from a in asm4[3].BoundReferences() where !a.IsMissing select a).Count()); 1291Assert.Equal(1, (from a in asm4[3].BoundReferences() where object.ReferenceEquals(a, asm4[0]) select a).Count()); 1292Assert.Equal(1, (from a in asm4[3].BoundReferences() where object.ReferenceEquals(a, asm4[1]) select a).Count()); 1293Assert.Equal(1, (from a in asm4[3].BoundReferences() where object.ReferenceEquals(a, asm4[2]) select a).Count()); 1314Assert.Equal(4, (from a in asm4[4].BoundReferences() where !a.IsMissing select a).Count()); 1315Assert.Equal(1, (from a in asm4[4].BoundReferences() where object.ReferenceEquals(a, asm4[0]) select a).Count()); 1316Assert.Equal(1, (from a in asm4[4].BoundReferences() where object.ReferenceEquals(a, asm4[1]) select a).Count()); 1317Assert.Equal(1, (from a in asm4[4].BoundReferences() where object.ReferenceEquals(a, asm4[2]) select a).Count()); 1318Assert.Equal(1, (from a in asm4[4].BoundReferences() where object.ReferenceEquals(a, asm4[3]) select a).Count()); 1362Assert.Equal(2, (from a in asm7[2].BoundReferences() where !a.IsMissing select a).Count()); 1363Assert.Equal(1, (from a in asm7[2].BoundReferences() where object.ReferenceEquals(a, asm7[0]) select a).Count()); 1364Assert.Equal(1, (from a in asm7[2].BoundReferences() where object.ReferenceEquals(a, asm7[1]) select a).Count()); 1372Assert.Equal(0, (from a in asm7 where a != null && a.Name == "MTTestLib1" select a).Count()); 1385Assert.Equal(3, (from a in asm7[3].BoundReferences() where !a.IsMissing select a).Count()); 1386Assert.Equal(1, (from a in asm7[3].BoundReferences() where object.ReferenceEquals(a, asm7[0]) select a).Count()); 1387Assert.Equal(1, (from a in asm7[3].BoundReferences() where object.ReferenceEquals(a, asm7[1]) select a).Count()); 1388Assert.Equal(1, (from a in asm7[3].BoundReferences() where object.ReferenceEquals(a, asm7[2]) select a).Count()); 1446Assert.Equal(4, (from a in asm2[1].BoundReferences() where !a.IsMissing select a).Count()); 1447Assert.Equal(2, (from a in asm2[1].BoundReferences() where object.ReferenceEquals(a, asm2[0]) select a).Count()); 1448Assert.Equal(2, (from a in asm2[1].BoundReferences() where object.ReferenceEquals(a, asm2[2]) select a).Count()); 1463Assert.Equal(1, (from a in asm2[2].BoundReferences() where !a.IsMissing select a).Count()); 1464Assert.Equal(1, (from a in asm2[2].BoundReferences() where object.ReferenceEquals(a, asm2[0]) select a).Count()); 1505Assert.Equal(4, (from a in asm3[1].BoundReferences() where !a.IsMissing select a).Count()); 1506Assert.Equal(2, (from a in asm3[1].BoundReferences() where object.ReferenceEquals(a, asm3[0]) select a).Count()); 1507Assert.Equal(2, (from a in asm3[1].BoundReferences() where object.ReferenceEquals(a, asm3[2]) select a).Count()); 1525Assert.Equal(1, (from a in asm3[2].BoundReferences() where !a.IsMissing select a).Count()); 1526Assert.Equal(1, (from a in asm3[2].BoundReferences() where object.ReferenceEquals(a, asm3[0]) select a).Count()); 1529Assert.Equal(6, (from a in asm3[3].BoundReferences() where !a.IsMissing select a).Count()); 1530Assert.Equal(2, (from a in asm3[3].BoundReferences() where object.ReferenceEquals(a, asm3[0]) select a).Count()); 1531Assert.Equal(2, (from a in asm3[3].BoundReferences() where object.ReferenceEquals(a, asm3[1]) select a).Count()); 1532Assert.Equal(2, (from a in asm3[3].BoundReferences() where object.ReferenceEquals(a, asm3[2]) select a).Count()); 1597Assert.Equal(4, (from a in asm4[1].BoundReferences() where !a.IsMissing select a).Count()); 1598Assert.Equal(2, (from a in asm4[1].BoundReferences() where object.ReferenceEquals(a, asm4[0]) select a).Count()); 1599Assert.Equal(2, (from a in asm4[1].BoundReferences() where object.ReferenceEquals(a, asm4[2]) select a).Count()); 1614Assert.Equal(1, (from a in asm4[2].BoundReferences() where !a.IsMissing select a).Count()); 1615Assert.Equal(1, (from a in asm4[2].BoundReferences() where object.ReferenceEquals(a, asm4[0]) select a).Count()); 1620Assert.Equal(6, (from a in asm4[3].BoundReferences() where !a.IsMissing select a).Count()); 1621Assert.Equal(2, (from a in asm4[3].BoundReferences() where object.ReferenceEquals(a, asm4[0]) select a).Count()); 1622Assert.Equal(2, (from a in asm4[3].BoundReferences() where object.ReferenceEquals(a, asm4[1]) select a).Count()); 1623Assert.Equal(2, (from a in asm4[3].BoundReferences() where object.ReferenceEquals(a, asm4[2]) select a).Count()); 1644Assert.Equal(8, (from a in asm4[4].BoundReferences() where !a.IsMissing select a).Count()); 1645Assert.Equal(2, (from a in asm4[4].BoundReferences() where object.ReferenceEquals(a, asm4[0]) select a).Count()); 1646Assert.Equal(2, (from a in asm4[4].BoundReferences() where object.ReferenceEquals(a, asm4[1]) select a).Count()); 1647Assert.Equal(2, (from a in asm4[4].BoundReferences() where object.ReferenceEquals(a, asm4[2]) select a).Count()); 1648Assert.Equal(2, (from a in asm4[4].BoundReferences() where object.ReferenceEquals(a, asm4[3]) select a).Count()); 1721Assert.Equal(4, (from a in asm7[2].BoundReferences() where !a.IsMissing select a).Count()); 1722Assert.Equal(2, (from a in asm7[2].BoundReferences() where object.ReferenceEquals(a, asm7[0]) select a).Count()); 1723Assert.Equal(2, (from a in asm7[2].BoundReferences() where object.ReferenceEquals(a, asm7[1]) select a).Count()); 1748Assert.Equal(6, (from a in asm7[3].BoundReferences() where !a.IsMissing select a).Count()); 1749Assert.Equal(2, (from a in asm7[3].BoundReferences() where object.ReferenceEquals(a, asm7[0]) select a).Count()); 1750Assert.Equal(2, (from a in asm7[3].BoundReferences() where object.ReferenceEquals(a, asm7[1]) select a).Count()); 1751Assert.Equal(2, (from a in asm7[3].BoundReferences() where object.ReferenceEquals(a, asm7[2]) select a).Count()); 1833Assert.Equal(4, (from a in asm2[1].BoundReferences() where !a.IsMissing select a).Count()); 1834Assert.Equal(2, (from a in asm2[1].BoundReferences() where object.ReferenceEquals(a, asm2[0]) select a).Count()); 1835Assert.Equal(2, (from a in asm2[1].BoundReferences() where object.ReferenceEquals(a, asm2[2]) select a).Count()); 1846Assert.Equal(1, (from a in asm2[2].BoundReferences() where !a.IsMissing select a).Count()); 1847Assert.Equal(1, (from a in asm2[2].BoundReferences() where object.ReferenceEquals(a, asm2[0]) select a).Count()); 1860Assert.Equal(4, (from a in asm3[1].BoundReferences() where !a.IsMissing select a).Count()); 1861Assert.Equal(2, (from a in asm3[1].BoundReferences() where object.ReferenceEquals(a, asm3[0]) select a).Count()); 1862Assert.Equal(2, (from a in asm3[1].BoundReferences() where object.ReferenceEquals(a, asm3[2]) select a).Count()); 1875Assert.Equal(1, (from a in asm3[2].BoundReferences() where !a.IsMissing select a).Count()); 1876Assert.Equal(1, (from a in asm3[2].BoundReferences() where object.ReferenceEquals(a, asm3[0]) select a).Count()); 1879Assert.Equal(6, (from a in asm3[3].BoundReferences() where !a.IsMissing select a).Count()); 1880Assert.Equal(2, (from a in asm3[3].BoundReferences() where object.ReferenceEquals(a, asm3[0]) select a).Count()); 1881Assert.Equal(2, (from a in asm3[3].BoundReferences() where object.ReferenceEquals(a, asm3[1]) select a).Count()); 1882Assert.Equal(2, (from a in asm3[3].BoundReferences() where object.ReferenceEquals(a, asm3[2]) select a).Count()); 1913Assert.Equal(4, (from a in asm4[1].BoundReferences() where !a.IsMissing select a).Count()); 1914Assert.Equal(2, (from a in asm4[1].BoundReferences() where object.ReferenceEquals(a, asm4[0]) select a).Count()); 1915Assert.Equal(2, (from a in asm4[1].BoundReferences() where object.ReferenceEquals(a, asm4[2]) select a).Count()); 1930Assert.Equal(1, (from a in asm4[2].BoundReferences() where !a.IsMissing select a).Count()); 1931Assert.Equal(1, (from a in asm4[2].BoundReferences() where object.ReferenceEquals(a, asm4[0]) select a).Count()); 1936Assert.Equal(6, (from a in asm4[3].BoundReferences() where !a.IsMissing select a).Count()); 1937Assert.Equal(2, (from a in asm4[3].BoundReferences() where object.ReferenceEquals(a, asm4[0]) select a).Count()); 1938Assert.Equal(2, (from a in asm4[3].BoundReferences() where object.ReferenceEquals(a, asm4[1]) select a).Count()); 1939Assert.Equal(2, (from a in asm4[3].BoundReferences() where object.ReferenceEquals(a, asm4[2]) select a).Count()); 1960Assert.Equal(8, (from a in asm4[4].BoundReferences() where !a.IsMissing select a).Count()); 1961Assert.Equal(2, (from a in asm4[4].BoundReferences() where object.ReferenceEquals(a, asm4[0]) select a).Count()); 1962Assert.Equal(2, (from a in asm4[4].BoundReferences() where object.ReferenceEquals(a, asm4[1]) select a).Count()); 1963Assert.Equal(2, (from a in asm4[4].BoundReferences() where object.ReferenceEquals(a, asm4[2]) select a).Count()); 1964Assert.Equal(2, (from a in asm4[4].BoundReferences() where object.ReferenceEquals(a, asm4[3]) select a).Count()); 2008Assert.Equal(4, (from a in asm7[2].BoundReferences() where !a.IsMissing select a).Count()); 2009Assert.Equal(2, (from a in asm7[2].BoundReferences() where object.ReferenceEquals(a, asm7[0]) select a).Count()); 2010Assert.Equal(2, (from a in asm7[2].BoundReferences() where object.ReferenceEquals(a, asm7[1]) select a).Count()); 2033Assert.Equal(6, (from a in asm7[3].BoundReferences() where !a.IsMissing select a).Count()); 2034Assert.Equal(2, (from a in asm7[3].BoundReferences() where object.ReferenceEquals(a, asm7[0]) select a).Count()); 2035Assert.Equal(2, (from a in asm7[3].BoundReferences() where object.ReferenceEquals(a, asm7[1]) select a).Count()); 2036Assert.Equal(2, (from a in asm7[3].BoundReferences() where object.ReferenceEquals(a, asm7[2]) select a).Count());

2065Assert.Equal(2, conversionSymbols.Count());

2636Assert.Equal(7, receiverSyntaxes.Count());

132Assert.Equal(19, methods.Count()); //sanity check that we got as many as we were expecting - change as needed

1064Assert.Equal(foo.GetAttributes().Length, attrs.Count()); 1442Assert.Equal(2, parameters.Count()); 1469Assert.Equal(2, parameters.Count());

303Assert.Equal(2, classInterfacesConstructedFrom.Count()); 586Assert.Equal(2, events.Count());

150Assert.Equal(2, basicC1_M9.Count()); 588Assert.Equal(2, classInterfacesConstructedFrom.Count());

278Assert.Equal(0, collections.GetAttributes(dictionary).Count());

137Assert.Equal(2, classInterfacesConstructedFrom.Count());

1475Assert.Equal(0, assembly.GetAttributes(AttributeDescription.TypeForwardedToAttribute).Count()); 1651Assert.Equal(0, m.ContainingAssembly.GetAttributes(AttributeDescription.TypeForwardedToAttribute).Count()); 1703Assert.Equal(0, m.ContainingAssembly.GetAttributes(AttributeDescription.TypeForwardedToAttribute).Count()); 1745Assert.Equal(0, assembly.GetAttributes(AttributeDescription.TypeForwardedToAttribute).Count());

1862Assert.Equal(0, comp.GetDiagnostics().Count());

837Assert.Equal(0, metadataReader.FieldDefinitions.AsEnumerable().Count());

142Assert.Equal(1, attributes.Count());

33Assert.Equal(0, errs.Count()); 49Assert.Equal(0, errs.Count()); 75Assert.Equal(0, errs.Count()); 98Assert.Equal(6, errs.Count()); 146Assert.Equal(1, comp.GetDeclarationDiagnostics().Count()); 169Assert.Equal(0, comp.GetDeclarationDiagnostics().Count());

164Assert.Equal(0, diagnostics.Count()); 191Assert.Equal(2, diagnostics.Count()); 1427Assert.Equal(1, comp.GetDeclarationDiagnostics().Count()); 1618Assert.Equal(0, c1.GetDiagnostics().Count()); 1619Assert.Equal(0, c2.GetDiagnostics().Count()); 1624Assert.Equal(0, c2.GetDiagnostics().Count());

89Assert.Equal(1, diags.Count());

366Assert.Equal(1, e1.GetAttributes(AttributeDescription.DynamicAttribute).Count()); 367Assert.Equal(1, e2.GetAttributes(AttributeDescription.DynamicAttribute).Count()); 368Assert.Equal(1, p.GetAttributes(AttributeDescription.DynamicAttribute).Count());

510Assert.Equal(0, comp.GetDeclarationDiagnostics().Count()); 586Assert.Equal(0, comp.GetDiagnostics().Count()); 770Assert.Equal(0, comp1.GetDiagnostics().Count()); 771Assert.Equal(0, comp2.GetDiagnostics().Count()); 772Assert.Equal(0, comp.GetDiagnostics().Count()); 1059Assert.Equal(0, comp1.GetDiagnostics().Count()); 1060Assert.Equal(0, comp2.GetDiagnostics().Count()); 1061Assert.Equal(0, comp.GetDiagnostics().Count()); 1164Assert.Equal(0, comp.GetDiagnostics().Count()); 1258Assert.Equal(0, comp.GetDiagnostics().Count()); 1463Assert.Equal(0, comp.GetDeclarationDiagnostics().Count()); 1501Assert.Equal(0, comp.GetDeclarationDiagnostics().Count()); 1545Assert.Equal(0, comp.GetDeclarationDiagnostics().Count());

634Assert.Equal(2, type.GetMembers().OfType<MethodSymbol>().Count()); 639Assert.Equal(0, type.GetMembers().OfType<PropertySymbol>().Count()); 2511Assert.Equal(2, explicitOverrides.Count()); 2549Assert.Equal(1, explicitOverrides.Count());

16055Assert.Equal(1, c.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()).Count()); 16117Assert.Equal(1, c.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()).Count()); 16823Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().Where(m => m.Name.Contains("M01")).Count()); 16905Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().Where(m => m.Name.Contains("M01")).Count()); 16987Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().Where(m => m.Name.Contains("M01")).Count()); 17057Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().Where(m => m.Name.Contains("M01")).Count()); 17132Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().Where(m => m.Name.Contains("M01")).Count()); 17219Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().Where(m => m.Name.Contains("M01")).Count()); 17309Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().Where(m => m.Name.Contains("M01")).Count()); 17415Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().Where(m => m.Name.Contains("M01")).Count()); 19846Assert.Equal(isChecked ? 2 : 1, c.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()).Count()); 19927Assert.Equal(2, c.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()).Count()); 20019Assert.Equal(matchingOp is null ? 1 : 2, c.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()).Count()); 20117Assert.Equal(isChecked ? 2 : 1, c.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()).Count()); 20200Assert.Equal(2, c.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()).Count()); 20292Assert.Equal(matchingOp is null ? 1 : 2, c.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()).Count()); 20381Assert.Equal(matchingOp is null ? 1 : 2, c.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()).Count()); 22218Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().Where(m => m.Name.Contains(opName)).Count()); 22327Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().Where(m => m.Name.Contains(opName)).Count()); 22429Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().Where(m => m.Name.Contains(opName)).Count()); 23475Assert.Equal(1, c.GetMembers().OfType<PropertySymbol>().Count()); 23476Assert.Equal(2, c.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()).Count()); 23571Assert.Equal(1, c.GetMembers().OfType<PropertySymbol>().Count()); 23572Assert.Equal(2, c.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()).Count()); 23661Assert.Equal(1, c.GetMembers().OfType<PropertySymbol>().Count()); 23662Assert.Equal(2, c.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()).Count()); 24099Assert.Equal(1, c.GetMembers().OfType<PropertySymbol>().Count()); 24100Assert.Equal(2, c.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()).Count()); 24194Assert.Equal(1, c.GetMembers().OfType<PropertySymbol>().Count()); 24195Assert.Equal(1, c.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()).Count()); 24252Assert.Equal(1, c.GetMembers().OfType<PropertySymbol>().Count()); 24253Assert.Equal(2, c.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()).Count()); 24356Assert.Equal(1, c.GetMembers().OfType<PropertySymbol>().Count()); 24357Assert.Equal(1, c.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()).Count()); 24546Assert.Equal(1, c.GetMembers().OfType<PropertySymbol>().Count()); 24547Assert.Equal(1, c.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()).Count()); 24604Assert.Equal(1, c.GetMembers().OfType<PropertySymbol>().Count()); 24605Assert.Equal(2, c.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()).Count()); 24708Assert.Equal(1, c.GetMembers().OfType<PropertySymbol>().Count()); 24709Assert.Equal(1, c.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()).Count()); 25213Assert.Equal(2, c2.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()).Count()); 25253Assert.Equal(2, c3.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()).Count()); 25539Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().OfType<PropertySymbol>().Where(m => m.Name.Contains("M01")).Count()); 25609Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().OfType<PropertySymbol>().Where(m => m.Name.Contains("M01")).Count()); 26253Assert.Equal(1, c.GetMembers().OfType<EventSymbol>().Count()); 26254Assert.Equal(2, c.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()).Count()); 26348Assert.Equal(1, c.GetMembers().OfType<EventSymbol>().Count()); 26349Assert.Equal(2, c.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()).Count()); 26779Assert.Equal(1, c.GetMembers().OfType<EventSymbol>().Count()); 26780Assert.Equal(2, c.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()).Count()); 26896Assert.Equal(1, c.GetMembers().OfType<EventSymbol>().Count()); 26897Assert.Equal(2, c.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()).Count()); 27170Assert.Equal(1, c.GetMembers().OfType<EventSymbol>().Count()); 27171Assert.Equal(2, c.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()).Count()); 27770Assert.Equal(2, c2.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()).Count()); 27885Assert.Equal(2, c4.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()).Count()); 28205Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().OfType<EventSymbol>().Where(m => m.Name.Contains("M01")).Count()); 28275Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().OfType<EventSymbol>().Where(m => m.Name.Contains("M01")).Count()); 29201Assert.Equal(isChecked ? 4 : 2, c.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()).Count()); 29328Assert.Equal(isChecked ? 4 : 2, c.GetMembers().OfType<MethodSymbol>().Where(m => !m.IsConstructor()).Count()); 30153Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().Where(m => m.Name.Contains(opName)).Count()); 30259Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().Where(m => m.Name.Contains(opName)).Count());

200Assert.Equal(0, comp1.GetDiagnostics().Count()); 201Assert.Equal(0, comp2.GetDiagnostics().Count()); 202Assert.Equal(0, comp.GetDiagnostics().Count()); 382Assert.Equal(0, comp.GetDiagnostics().Count()); 401Assert.Equal(0, comp.GetDiagnostics().Count()); 420Assert.Equal(0, comp.GetDiagnostics().Count()); 443Assert.Equal(0, comp.GetDiagnostics().Count()); 1140Assert.Equal(0, comp.GetDeclarationDiagnostics().Count()); 1154Assert.Equal(0, comp.GetDeclarationDiagnostics().Count()); 1236Assert.Equal(4, comp.GetDiagnostics().Count());

88Assert.Equal(0, d1.AdditionalLocations.Count()); 102Assert.Equal(1, d3.AdditionalLocations.Count()); 149Assert.InRange(actualErrors.Count(), 1, int.MaxValue);

312Assert.Equal(1, diags.Count());

4178Assert.Equal(pd.Count(), id.Count()); 4179for (int i = 0; i < id.Count(); i++)

39Assert.Equal(arrayType.RankSpecifiers.Count(), numRanks); 66Assert.Equal(genericName.TypeArgumentList.Arguments.Count, typeNames.Count());

3307Assert.Equal(actual.Count(), expected.Count);

227Assert.Equal("202", actualErrors.Count().ToString()); 245Assert.Equal("202", actualErrors.Count().ToString());

9611Assert.Equal(1, tree.GetCompilationUnitRoot().ChildNodes().Count());

94Assert.Equal(1, resultList.Count());

356for (int i = 0; i < actualNodesOrTokens.Count(); i++) 369Assert.Equal(annotatedTrivia.Count(), actualTrivia.Count()); 371for (int i = 0; i < actualTrivia.Count(); i++) 404Assert.Equal(sourceNodeOrTokens.Count(), destNodeOrTokens.Count()); 418Assert.Equal(sourceTrivia.Count(), destTrivia.Count()); 618Assert.Equal(1, results.Count()); 632Assert.Equal(1, results.Count()); 646Assert.Equal(1, results.Count());

1824Assert.Equal(0, syntaxTree.GetDiagnostics().Count()); 1828Assert.Equal(0, syntaxTree.GetDiagnostics(nOrT).Count()); 2045Assert.Equal(expectedTokenKinds.Count(), actualTokens.Count()); //redundant but helps debug 2066Assert.Equal(expectedTokenKinds.Count(), actualTokens.Count()); //redundant but helps debug 3534Assert.Equal(1, node.DescendantTrivia().Count()); 3545Assert.Equal(1, node.DescendantTrivia().Count());

39Assert.Equal(1, currentAs.Count()); 59Assert.Equal(0, currentAs.Count()); 88Assert.Equal(1, latestAs.Count()); 115Assert.Equal(0, latestAs.Count());

127int n = reducedMethod.Parameters.Count(); 128Assert.Equal(reducedFrom.Parameters.Count(), n + 1);

1836if (resolvedReferences.Count() > used.Length)

102int actualLength = actualErrors.Count(); 160Assert.True(experr.Parameters.SequenceEqual(acterr.Parameters), String.Format("Param: {0}!={1}", experr.Parameters.Count(), acterr.Parameters.Count())); 179Assert.InRange(expectedErrorDesp.Length, 0, actualErrors.Count()); 192var actualGroupCount = actualGroup != null ? actualGroup.Count() : 0; 195Assert.InRange(expectedGroup.Count(), 0, actualGroupCount);

500if (!(expArgs.Count() == actArgs.Length)) 505for (var i = 0; i <= expArgs.Count() - 1; i++)

762if (relevantLocals.Count() != 1)

72return [.. triviaList.Skip(triviaInLeadingBlankLines.Count())];

278Debug.Assert(originalIdentifierNodes.Count() == replacedIdentifierNodes.Count());

44var clauses = SyntaxFactory.List(allClauses.Take(allClauses.Count() - 1).Cast<QueryClauseSyntax>());

260Debug.Assert(buffer.GetRelatedDocuments().Count() == 1);

248Debug.Assert(trackingSpansTouched.Count() == 1);

405var fileCount = renameLocations.GroupBy(s => s.Document.FilePath).Count(); 406var referenceCount = renameLocations.Select(loc => (loc.Document.FilePath, loc.TextSpan)).Distinct().Count();

26TotalFilesAffected += p.GetAddedDocuments().Count() + 27p.GetChangedDocuments().Count() + 28p.GetRemovedDocuments().Count() + 29p.GetAddedAdditionalDocuments().Count() + 30p.GetChangedAdditionalDocuments().Count() + 31p.GetRemovedAdditionalDocuments().Count() + 32p.GetAddedAnalyzerConfigDocuments().Count() + 33p.GetChangedAnalyzerConfigDocuments().Count() + 34p.GetRemovedAnalyzerConfigDocuments().Count(); 47var totalProjectsAddedOrRemoved = changes.GetAddedProjects().Count() + changes.GetRemovedProjects().Count();

150currentActionCount += set.Actions.Count();

83if (spans.Count() == 1) 88else if (spans.Count() > 1)

308Assert.Equal(matchingFilters.Count, matchingFilters.Distinct().Count());

168Assert.Equal(expecteditems.Count, items.Count());

67Assert.Equal(expected.Elements.Count(), actual.Elements.Count()); 83Assert.Equal(expected.Runs.Count(), actual.Runs.Count());

184Assert.True(expectedTestItems.Count() == actualSignatureHelpItems.Items.Count, $"Expected {expectedTestItems.Count()} items, but got {actualSignatureHelpItems.Items.Count}"); 186for (var i = 0; i < expectedTestItems.Count(); i++)

73if (namedGroup.Count() == 1)

20Assert.Equal(0, map.Keys.Count()); 21Assert.Equal(0, map.Values.Count()); 37Assert.Equal(3, map.Keys.Count()); 38Assert.Equal(3, map.Values.Count());

46Assert.Equal(5, map.Keys.Count()); 47Assert.Equal(5, map.Values.Count());

21Assert.Equal(listOfIDEDiagnosticIds.Count, listOfIDEDiagnosticIds.Distinct().Count());

105Assert.Equal(1, previewWorkspace.GetOpenDocumentIds().Count()); 109Assert.Equal(0, previewWorkspace.GetOpenDocumentIds().Count());

161Assert.Equal(0, tags.Count()); 185Assert.Equal(1, tags.Count());

461Assert.True(transitiveDerived.Count() > immediateDerived.Count()); 510Assert.True(transitiveDerived.Count() > immediateDerived.Count()); 562Assert.True(transitiveImpls.Count() > immediateImpls.Count());

92Assert.Equal(expectedCount, tags.Count()); 114Assert.Equal(0, tags.Count()); 140Assert.Equal(2, tags.Count()); 196Assert.Equal(1, tags.Count()); 243Assert.Equal(1, tags.Count());

41Assert.Equal(1, service.GetAssociatedTextViews(bufferMock.Object).Count()); 44Assert.Equal(0, service.GetAssociatedTextViews(bufferMock.Object).Count()); 48Assert.Equal(2, service.GetAssociatedTextViews(bufferMock.Object).Count()); 51Assert.Equal(1, service.GetAssociatedTextViews(bufferMock.Object).Count()); 54Assert.Equal(0, service.GetAssociatedTextViews(bufferMock.Object).Count());

284if (attributesData.Count() == 0)

647var count = data.First().Count(); 648Debug.Assert(data.All(d => d.Count() == count));

59Contract.ThrowIfTrue(projects.Select(p => p.Language).Distinct().Count() != 1);

56var roslynSpans = new MappedSpanResult[spans.Count()];

29InitialAssemblyCount = AssemblyLoadContext.GetLoadContext(this.GetType().Assembly)!.Assemblies.Count(); 37var count = AssemblyLoadContext.GetLoadContext(this.GetType().Assembly)!.Assemblies.Count();

310if (containedDecls.Count() == 1)

131var projectSourceGeneratedDocumentCount = sourceGeneratedDocuments.Count();

145Debug.Assert(diags.Length == CompilationWithAnalyzers.GetEffectiveDiagnostics(diags, compilation).Count()); 146Debug.Assert(diagnostics.Length == Extensions.ConvertToLocalDiagnostics(diags, textDocument, span).Count());

153Debug.Assert(lineEditsOpt.Select(edit => edit.FileName).Distinct().Count() == lineEditsOpt.Length);

61Contract.ThrowIfTrue(projects.Select(p => p.Language).Distinct().Count() != 1);

575.Take(statementsAfterIf.Count() - 1)

726.Count();

165=> node.AncestorsAndSelf().OfType<TNamespaceDeclarationSyntax>().Count() + node.DescendantNodes().OfType<TNamespaceDeclarationSyntax>().Count(); 168=> node.AncestorsAndSelf().OfType<TNamedTypeDeclarationSyntax>().Count() > 1;

73Contract.ThrowIfTrue(projects.Select(p => p.Language).Distinct().Count() != 1);

34Contract.ThrowIfTrue(projects.Select(p => p.Language).Distinct().Count() != 1);

159Contract.ThrowIfTrue(projects.Select(p => p.Language).Distinct().Count() != 1);

494Contract.ThrowIfFalse(orderedProjects.SelectMany(s => s).Count() == filteredProjects.SelectMany(s => s).Count());

216properties = properties.AddRange(tagIndices.Select(kvp => new KeyValuePair<string, string?>(kvp.Key, EncodeIndices(kvp.Value, additionalLocations.Count()))));

66if (declarationDeclarators.Count == fieldDeclarators.Count())

45Debug.Assert(diagnostics.Select(diagnostic => diagnostic.Properties[MatchFolderAndNamespaceConstants.TargetNamespace]).Distinct().Count() == 1);

925return referencedSymbols.Count() == 1 &&

272.Where(g => g.Count() > 1)

45Assert.True(results.Distinct().Count() == results.Count);

3373ExecuteImpl = context => context.AddSource("generated", $"class G {{ int X => {context.Compilation.SyntaxTrees.Count()}; }}")

647var count = data.First().Count(); 648Debug.Assert(data.All(d => d.Count() == count));

128context.TraceDebug($"Found {projects.Length} restorable projects from {solution.Projects.Count()} projects in solution");

455if (matchingActions.Count() == 1)

286Assert.Equal(9, textRuns.Count()); 427item => ((ClassifiedTextElement)item.Text).Runs.Where(run => run.MarkerTagType == ReferenceHighlightingConstants.DefinitionTagId)).Where(i => i.Any()).Count(); 429item => ((ClassifiedTextElement)item.Text).Runs.Where(run => run.MarkerTagType == ReferenceHighlightingConstants.WrittenReferenceTagId)).Where(i => i.Any()).Count(); 431item => ((ClassifiedTextElement)item.Text).Runs.Where(run => run.MarkerTagType == ReferenceHighlightingConstants.ReferenceTagId)).Where(i => i.Any()).Count();

132Assert.Equal(2, results.SelectMany(r => r.FilePaths!).Count());

69Assert.Equal(2, sourceGeneratorDocumentUris.Count());

167Assert.Equal(expectedCount, mefCompositions.Count());

647var count = data.First().Count(); 648Debug.Assert(data.All(d => d.Count() == count));

179=> $"Interval tree with '{System.Linq.Enumerable.Count(this)}' entries. Use '.ToList()' to visualize contents.";

403if (words.Count() == 1) // Only Split if words have not been split before

647var count = data.First().Count(); 648Debug.Assert(data.All(d => d.Count() == count));

179=> $"Interval tree with '{System.Linq.Enumerable.Count(this)}' entries. Use '.ToList()' to visualize contents.";

403if (words.Count() == 1) // Only Split if words have not been split before

647var count = data.First().Count(); 648Debug.Assert(data.All(d => d.Count() == count));

179=> $"Interval tree with '{System.Linq.Enumerable.Count(this)}' entries. Use '.ToList()' to visualize contents.";

403if (words.Count() == 1) // Only Split if words have not been split before

480var result = expected.Count() == actual.Count() && expectedSet.SetEquals(actual); 709if (expected.Count() > 10) 719if (TryGenerateExpectedSourceFileAndGetDiffLink(actualString, expected.Count(), expectedValueSourcePath, expectedValueSourceLine, out var link))

673Assert.Equal(0, originalSet.Intersect(clonedSet).Count());

63if (keys.Count() == 1) 68else if (keys.Count() > 1)

342var elementCount = logElementCount ? $"({list.Count()})" : string.Empty;

494errorCount = result.Count();

1833if (_treeCallbackSet.Count != endContext.Compilation.SyntaxTrees.Count())

327if (args1.Count() != args2.Count() || !args1.SetEquals(args2))

843if (declarationStatement.GetDeclaredVariables().Count() > 3)

647var count = data.First().Count(); 648Debug.Assert(data.All(d => d.Count() == count));

100Assert.Equal(2, analyzerTypeNameMap.Keys.Count());

183var count = BitVector.AllSet(capacity).Words().Count(); 226var count = BitVector.AllSet(capacity).Words().Count();

242Assert.Equal(0, empty.Count()); 243Assert.Equal(0, empty.Keys.Count()); 244Assert.Equal(0, empty.Values.Count());

210Assert.Equal(0, map.Keys.Count()); 211Assert.Equal(0, map.ToReadOnlyDictionary().Keys.Count()); 214Assert.Equal(1, nonEmpty.Keys.Count()); 215Assert.Equal(1, nonEmpty.ToReadOnlyDictionary().Keys.Count()); 221Assert.Equal(0, map.Values.Count()); 222Assert.Equal(0, map.ToReadOnlyDictionary().Values.Count()); 225Assert.Equal(1, nonEmpty.Values.Count()); 226Assert.Equal(1, nonEmpty.ToReadOnlyDictionary().Values.Count());

290Assert.Equal(0, emptySet.Count()); //, "Enumeration of an empty set yielded elements.");

34if (objectUnderTest.Count() < 2) 43var shorterSequence = equivalentSequence.Take(equivalentSequence.Count() - 1);

85Assert.Equal(e.Where(kv => kv.Key != null).ToDictionary(g => g.Key!, g => g.Count()), a.Where(kv => kv.Key != null).ToDictionary(g => g.Key!, g => g.Count())); 88Assert.Equal(e[null].Count(), a[null].Count()); 104Assert.Equal(e.Where(kv => kv.Key != null).ToDictionary(g => g.Key!, g => g.Count()), a.Where(kv => kv.Key != null).ToDictionary(g => g.Key!, g => g.Count())); 107Assert.Equal(e[null].Count(), a[null].Count());

98if (casted.Count() > 0) 111if (casted.Count() > 0)

82Assert.Equal(150, ht.Count()); 106for (int i = 0, l = ht.Count(); i < l; i++)

232Assert.Equal(1, RuleSet.GetEffectiveIncludesFromFile(ruleSet.FilePath).Count()); 257Assert.Equal(2, RuleSet.GetEffectiveIncludesFromFile(ruleSet.FilePath).Count()); 292Assert.Equal(3, RuleSet.GetEffectiveIncludesFromFile(ruleSet.FilePath).Count()); 451Assert.True(ruleSet.Includes.Count() == 1);

1371if (symbols.Count() > 1)

451Assert.False(nestedNamespaces.GroupBy(pair => pair.Key).Where(g => g.Count() > 1).Any()); 456Assert.Equal(2, array[0].Value.Count()); 458Assert.Equal(1, array[1].Value.Count()); 460Assert.Equal(1, array[2].Value.Count()); 493Assert.Equal(2, nestedNS.Value.Count()); 502Assert.Equal(2, nestedNamespaces.Count());

39If importsClauses.Count > 0 Then

1956If opSet.Count = 0 Then 1962conversionKinds.ZeroInit(opSet.Count) 1964Dim applicable = BitVector.Create(opSet.Count) 1973ElseIf opSet.Count = 0 Then 1983ElseIf opSet.Count = 0 Then 1991conversionKinds.ZeroInit(opSet.Count)

2120Debug.Assert(indexesOfApplicableCandidates.Count = applicableCandidates) 2136For i As Integer = 0 To indexesOfApplicableCandidates.Count - 2 2143For j As Integer = i + 1 To indexesOfApplicableCandidates.Count - 1 2553left.EquallyApplicableCandidatesBucket = buckets.Count + 1 3919ElseIf applicableCount = quickInfo.Count Then 3933For k As Integer = 0 To If(applicableCount > 0 OrElse Not includeEliminatedCandidates, applicableCount, quickInfo.Count) - 1 3948For l As Integer = k + 1 To quickInfo.Count - 1 4010For l As Integer = k + 1 To quickInfo.Count - 1

1976if (elements.Count() <= 1) 2004if (elementNames.Count() != elementTypes.Count())

87var count = _solution.Projects.SelectMany(p => p.DocumentIds).Count();

49var count = this.Locations.Count();

37var mode = values.GroupBy(i => i).OrderByDescending(g => g.Count()).First().Key;

349var renameDeclarationLocations = new RenameDeclarationLocationReference[symbols.Count()];

249if (definitionDocuments.Count() == 1)

48private readonly ConcurrentDictionary<string, IOptionsSerializationService> _lazyLanguageSerializationService = new(concurrencyLevel: 2, capacity: workspaceServices.SupportedLanguages.Count());

143namespaceSymbol = members.Count() == 1

52if (candidateConstructors.Count() <= 1)

647var count = data.First().Count(); 648Debug.Assert(data.All(d => d.Count() == count));

179=> $"Interval tree with '{System.Linq.Enumerable.Count(this)}' entries. Use '.ToList()' to visualize contents.";

403if (words.Count() == 1) // Only Split if words have not been split before

283var groups = emitResult.Diagnostics.GroupBy(d => d.Id).Select(g => $"{g.Key}:{g.Count()}");

647var count = data.First().Count(); 648Debug.Assert(data.All(d => d.Count() == count));

2289Assert.Equal(2, workspace.CurrentSolution.Projects.Count()); 2319Assert.Equal(2, workspace.CurrentSolution.Projects.Count()); 2507Assert.InRange(project.ProjectReferences.Count(), 0, 1);

36Assert.Equal(1, project.Documents.Count()); 64Assert.Equal(2, project.Documents.Count());

139Assert.True(csharpResult.Count() > 0); 142Assert.True(vbResult.Count() > 0); 665Assert.Equal(1, foundDeclarations.Count());

30var actualResultCount = declarations.Count(); 47var actualResultCount = declarations.Count();

110Assert.Equal(3, result[0].Locations.Count()); // 3 locations found 139Assert.Equal(1, typeSymbol.Locations.Count()); 195Assert.Equal(expected: 2, actual: references.ElementAt(0).Locations.Count()); 200Assert.Equal(expected: 2, actual: references.ElementAt(0).Locations.Count()); 234Assert.Equal(expected: 0, actual: references.ElementAt(0).Locations.Count()); 303Assert.Equal(2, references.ElementAt(0).Locations.Count()); 308Assert.Equal(2, references.ElementAt(0).Locations.Count()); 469Assert.Equal(5, references.Count()); 515Assert.Equal(2, refsFromVirtual.Count()); 519Assert.Equal(2, refsFromOverride.Count()); 581Assert.Equal(1, typeResult.Locations.Count()); 582Assert.Equal(1, constructorResult.Locations.Count()); 616Assert.Equal(1, typeResult.Locations.Count()); 617Assert.Equal(1, constructorResult.Locations.Count()); 660Assert.Equal(2, typeResult.Locations.Count()); 661Assert.Equal(1, constructorResult.Locations.Count());

208.Where(group => group.Count() > 1)

2586Assert.Equal(2, solution.GetProjectsByName("name").Count()); 2983Assert.Equal(1, foundSymbol.Count()); 3113Assert.Equal(2, sol.Projects.Count()); 3121Assert.Equal(1, sol2.Projects.Count()); 3139Assert.Equal(2, sol.Projects.Count()); 3146Assert.Equal(1, sol2.Projects.Count()); 3153Assert.Equal(2, sol3.Projects.Count()); 3514Assert.Equal(1, compilation.SyntaxTrees.Count()); 4346Assert.Equal(2, frozenDocument.Project.Documents.Count()); 4374Assert.Equal(2, frozenDocument.Project.Documents.Count());

147Assert.Equal(2, (await project.GetRequiredCompilationAsync(CancellationToken.None)).SyntaxTrees.Count()); 169Assert.Equal(2, (await project.GetRequiredCompilationAsync(CancellationToken.None)).SyntaxTrees.Count()); 194Assert.Equal(2, compilation.SyntaxTrees.Count()); 213Assert.Equal(2, compilation.SyntaxTrees.Count()); 238Assert.Equal(3, compilation.SyntaxTrees.Count()); 346Assert.Equal(2, fullCompilation.SyntaxTrees.Count()); 768Assert.Equal(2, compilation.SyntaxTrees.Count()); 797Assert.Equal(2, compilation.SyntaxTrees.Count());

256Assert.Equal(1, tree.Count()); 337Assert.Equal(spans.Count, tree.Count());

142Assert.Equal(1, project2.ProjectReferences.Count()); 167Assert.Equal(0, ws.CurrentSolution.Projects.Count()); 172Assert.Equal(1, ws.CurrentSolution.Projects.Count()); 178Assert.Equal(1, proj.Documents.Count()); 198Assert.Equal(1, ws.CurrentSolution.Projects.Count()); 201Assert.Equal(0, newSolution.Projects.Count()); 206Assert.Equal(0, ws.CurrentSolution.Projects.Count());

23Assert.Equal(2, lazy.Metadata.Extensions.Count());

143return f1.Metadata.Keys.Count() == f2.Metadata.Keys.Count() && 174return s1.Metadata.Keys.Count() == s2.Metadata.Keys.Count() &&

33Assert.Equal(columnResult.Length, verify.Count()); 46Assert.Equal(columnResult.Length, verify.Count()); 59Assert.Equal(columnResult.Length, verify.Count()); 72Assert.Equal(columnResult.Length, verify.Count()); 85Assert.Equal(columnResult.Length, verify.Count()); 98Assert.Equal(columnResult.Length, verify.Count()); 111Assert.Equal(columnResult.Length, verify.Count()); 124Assert.Equal(columnResult.Length, verify.Count()); 137Assert.Equal(columnResult.Length, verify.Count()); 150Assert.Equal(columnResult.Length, verify.Count()); 163Assert.Equal(columnResult.Length, verify.Count()); 175Assert.Equal(columnResult.Length, verify.Count()); 187Assert.Equal(columnResult.Length, verify.Count()); 199Assert.Equal(columnResult.Length, verify.Count()); 211Assert.Equal(columnResult.Length, verify.Count()); 223Assert.Equal(columnResult.Length, verify.Count()); 235Assert.Equal(columnResult.Length, verify.Count()); 247Assert.Equal(columnResult.Length, verify.Count()); 259Assert.Equal(columnResult.Length, verify.Count()); 271Assert.Equal(columnResult.Length, verify.Count()); 283Assert.Equal(columnResult.Length, verify.Count()); 295Assert.Equal(columnResult.Length, verify.Count()); 307Assert.Equal(columnResult.Length, verify.Count()); 319Assert.Equal(columnResult.Length, verify.Count()); 331Assert.Equal(columnResult.Length, verify.Count()); 343Assert.Equal(columnResult.Length, verify.Count()); 355Assert.Equal(columnResult.Length, verify.Count()); 367Assert.Equal(columnResult.Length, verify.Count()); 379Assert.Equal(columnResult.Length, verify.Count()); 391Assert.Equal(columnResult.Length, verify.Count()); 403Assert.Equal(columnResult.Length, verify.Count()); 415Assert.Equal(columnResult.Length, verify.Count()); 427Assert.Equal(columnResult.Length, verify.Count()); 440Assert.Equal(columnResult.Length, verify.Count()); 453Assert.Equal(columnResult.Length, verify.Count()); 466Assert.Equal(columnResult.Length, verify.Count()); 479Assert.Equal(columnResult.Length, verify.Count()); 492Assert.Equal(columnResult.Length, verify.Count()); 505Assert.Equal(columnResult.Length, verify.Count()); 518Assert.Equal(columnResult.Length, verify.Count()); 531Assert.Equal(columnResult.Length, verify.Count()); 544Assert.Equal(columnResult.Length, verify.Count()); 557Assert.Equal(columnResult.Length, verify.Count()); 570Assert.Equal(columnResult.Length, verify.Count()); 582Assert.Equal(columnResult.Length, verify.Count()); 594Assert.Equal(columnResult.Length, verify.Count()); 606Assert.Equal(columnResult.Length, verify.Count()); 618Assert.Equal(columnResult.Length, verify.Count()); 630Assert.Equal(columnResult.Length, verify.Count()); 642Assert.Equal(columnResult.Length, verify.Count()); 654Assert.Equal(columnResult.Length, verify.Count()); 666Assert.Equal(columnResult.Length, verify.Count()); 678Assert.Equal(columnResult.Length, verify.Count()); 690Assert.Equal(columnResult.Length, verify.Count()); 702Assert.Equal(columnResult.Length, verify.Count()); 714Assert.Equal(columnResult.Length, verify.Count()); 726Assert.Equal(columnResult.Length, verify.Count()); 738Assert.Equal(columnResult.Length, verify.Count()); 750Assert.Equal(columnResult.Length, verify.Count()); 762Assert.Equal(columnResult.Length, verify.Count()); 774Assert.Equal(columnResult.Length, verify.Count()); 786Assert.Equal(columnResult.Length, verify.Count()); 798Assert.Equal(columnResult.Length, verify.Count()); 810Assert.Equal(columnResult.Length, verify.Count()); 822Assert.Equal(columnResult.Length, verify.Count()); 834Assert.Equal(columnResult.Length, verify.Count()); 847Assert.Equal(columnResult.Length, verify.Count()); 860Assert.Equal(columnResult.Length, verify.Count()); 873Assert.Equal(columnResult.Length, verify.Count()); 886Assert.Equal(columnResult.Length, verify.Count()); 899Assert.Equal(columnResult.Length, verify.Count()); 912Assert.Equal(columnResult.Length, verify.Count()); 925Assert.Equal(columnResult.Length, verify.Count()); 938Assert.Equal(columnResult.Length, verify.Count()); 951Assert.Equal(columnResult.Length, verify.Count()); 964Assert.Equal(columnResult.Length, verify.Count()); 977Assert.Equal(columnResult.Length, verify.Count()); 989Assert.Equal(columnResult.Length, verify.Count()); 1001Assert.Equal(columnResult.Length, verify.Count()); 1013Assert.Equal(columnResult.Length, verify.Count()); 1025Assert.Equal(columnResult.Length, verify.Count()); 1037Assert.Equal(columnResult.Length, verify.Count()); 1049Assert.Equal(columnResult.Length, verify.Count()); 1061Assert.Equal(columnResult.Length, verify.Count()); 1073Assert.Equal(columnResult.Length, verify.Count()); 1085Assert.Equal(columnResult.Length, verify.Count()); 1097Assert.Equal(columnResult.Length, verify.Count()); 1109Assert.Equal(columnResult.Length, verify.Count()); 1121Assert.Equal(columnResult.Length, verify.Count()); 1133Assert.Equal(columnResult.Length, verify.Count()); 1145Assert.Equal(columnResult.Length, verify.Count()); 1157Assert.Equal(columnResult.Length, verify.Count()); 1169Assert.Equal(columnResult.Length, verify.Count()); 1181Assert.Equal(columnResult.Length, verify.Count()); 1193Assert.Equal(columnResult.Length, verify.Count()); 1205Assert.Equal(columnResult.Length, verify.Count()); 1217Assert.Equal(columnResult.Length, verify.Count()); 1229Assert.Equal(columnResult.Length, verify.Count()); 1241Assert.Equal(columnResult.Length, verify.Count()); 1254Assert.Equal(columnResult.Length, verify.Count()); 1267Assert.Equal(columnResult.Length, verify.Count()); 1280Assert.Equal(columnResult.Length, verify.Count()); 1293Assert.Equal(columnResult.Length, verify.Count()); 1306Assert.Equal(columnResult.Length, verify.Count()); 1319Assert.Equal(columnResult.Length, verify.Count()); 1332Assert.Equal(columnResult.Length, verify.Count()); 1345Assert.Equal(columnResult.Length, verify.Count()); 1358Assert.Equal(columnResult.Length, verify.Count()); 1371Assert.Equal(columnResult.Length, verify.Count()); 1384Assert.Equal(columnResult.Length, verify.Count()); 1396Assert.Equal(columnResult.Length, verify.Count()); 1408Assert.Equal(columnResult.Length, verify.Count()); 1420Assert.Equal(columnResult.Length, verify.Count()); 1432Assert.Equal(columnResult.Length, verify.Count()); 1444Assert.Equal(columnResult.Length, verify.Count()); 1456Assert.Equal(columnResult.Length, verify.Count()); 1468Assert.Equal(columnResult.Length, verify.Count()); 1480Assert.Equal(columnResult.Length, verify.Count()); 1492Assert.Equal(columnResult.Length, verify.Count()); 1504Assert.Equal(columnResult.Length, verify.Count()); 1516Assert.Equal(columnResult.Length, verify.Count()); 1528Assert.Equal(columnResult.Length, verify.Count()); 1540Assert.Equal(columnResult.Length, verify.Count()); 1552Assert.Equal(columnResult.Length, verify.Count()); 1564Assert.Equal(columnResult.Length, verify.Count()); 1576Assert.Equal(columnResult.Length, verify.Count()); 1588Assert.Equal(columnResult.Length, verify.Count()); 1600Assert.Equal(columnResult.Length, verify.Count()); 1612Assert.Equal(columnResult.Length, verify.Count()); 1624Assert.Equal(columnResult.Length, verify.Count()); 1636Assert.Equal(columnResult.Length, verify.Count()); 1648Assert.Equal(columnResult.Length, verify.Count()); 1661Assert.Equal(columnResult.Length, verify.Count()); 1674Assert.Equal(columnResult.Length, verify.Count()); 1687Assert.Equal(columnResult.Length, verify.Count()); 1700Assert.Equal(columnResult.Length, verify.Count()); 1713Assert.Equal(columnResult.Length, verify.Count()); 1726Assert.Equal(columnResult.Length, verify.Count()); 1739Assert.Equal(columnResult.Length, verify.Count()); 1752Assert.Equal(columnResult.Length, verify.Count()); 1765Assert.Equal(columnResult.Length, verify.Count()); 1778Assert.Equal(columnResult.Length, verify.Count()); 1791Assert.Equal(columnResult.Length, verify.Count()); 1803Assert.Equal(columnResult.Length, verify.Count()); 1815Assert.Equal(columnResult.Length, verify.Count()); 1827Assert.Equal(columnResult.Length, verify.Count()); 1839Assert.Equal(columnResult.Length, verify.Count()); 1851Assert.Equal(columnResult.Length, verify.Count()); 1863Assert.Equal(columnResult.Length, verify.Count()); 1875Assert.Equal(columnResult.Length, verify.Count()); 1887Assert.Equal(columnResult.Length, verify.Count()); 1899Assert.Equal(columnResult.Length, verify.Count()); 1911Assert.Equal(columnResult.Length, verify.Count()); 1923Assert.Equal(columnResult.Length, verify.Count()); 1935Assert.Equal(columnResult.Length, verify.Count()); 1947Assert.Equal(columnResult.Length, verify.Count()); 1959Assert.Equal(columnResult.Length, verify.Count()); 1971Assert.Equal(columnResult.Length, verify.Count()); 1983Assert.Equal(columnResult.Length, verify.Count()); 1995Assert.Equal(columnResult.Length, verify.Count()); 2007Assert.Equal(columnResult.Length, verify.Count()); 2019Assert.Equal(columnResult.Length, verify.Count()); 2031Assert.Equal(columnResult.Length, verify.Count()); 2043Assert.Equal(columnResult.Length, verify.Count()); 2055Assert.Equal(columnResult.Length, verify.Count()); 2068Assert.Equal(columnResult.Length, verify.Count()); 2083Assert.Equal(columnResult.Length, verify.Count()); 2098Assert.Equal(columnResult.Length, verify.Count()); 2113Assert.Equal(columnResult.Length, verify.Count()); 2128Assert.Equal(columnResult.Length, verify.Count()); 2143Assert.Equal(columnResult.Length, verify.Count()); 2158Assert.Equal(columnResult.Length, verify.Count()); 2173Assert.Equal(columnResult.Length, verify.Count()); 2188Assert.Equal(columnResult.Length, verify.Count()); 2203Assert.Equal(columnResult.Length, verify.Count()); 2218Assert.Equal(columnResult.Length, verify.Count()); 2232Assert.Equal(columnResult.Length, verify.Count()); 2244Assert.Equal(columnResult.Length, verify.Count()); 2256Assert.Equal(columnResult.Length, verify.Count()); 2268Assert.Equal(columnResult.Length, verify.Count()); 2280Assert.Equal(columnResult.Length, verify.Count()); 2292Assert.Equal(columnResult.Length, verify.Count()); 2304Assert.Equal(columnResult.Length, verify.Count()); 2316Assert.Equal(columnResult.Length, verify.Count()); 2328Assert.Equal(columnResult.Length, verify.Count()); 2340Assert.Equal(columnResult.Length, verify.Count()); 2352Assert.Equal(columnResult.Length, verify.Count()); 2365Assert.Equal(columnResult.Length, verify.Count()); 2380Assert.Equal(columnResult.Length, verify.Count()); 2395Assert.Equal(columnResult.Length, verify.Count()); 2410Assert.Equal(columnResult.Length, verify.Count()); 2425Assert.Equal(columnResult.Length, verify.Count()); 2440Assert.Equal(columnResult.Length, verify.Count()); 2455Assert.Equal(columnResult.Length, verify.Count()); 2470Assert.Equal(columnResult.Length, verify.Count()); 2485Assert.Equal(columnResult.Length, verify.Count()); 2500Assert.Equal(columnResult.Length, verify.Count()); 2515Assert.Equal(columnResult.Length, verify.Count()); 2529Assert.Equal(columnResult.Length, verify.Count()); 2541Assert.Equal(columnResult.Length, verify.Count()); 2553Assert.Equal(columnResult.Length, verify.Count()); 2565Assert.Equal(columnResult.Length, verify.Count()); 2577Assert.Equal(columnResult.Length, verify.Count()); 2589Assert.Equal(columnResult.Length, verify.Count()); 2601Assert.Equal(columnResult.Length, verify.Count()); 2613Assert.Equal(columnResult.Length, verify.Count()); 2625Assert.Equal(columnResult.Length, verify.Count()); 2637Assert.Equal(columnResult.Length, verify.Count()); 2649Assert.Equal(columnResult.Length, verify.Count());

32Assert.Equal(2, grouping.Count()); 37Assert.Equal(length / 2, oddGroup.Count()); 41Assert.Equal(length / 2 + length % 2, evenGroup.Count()); 79Assert.Equal(10, groupings[i].Count()); 94Assert.Equal(length % 10, groupings[length / 10].Count());

67if (string.IsNullOrWhiteSpace(Uri) && (Uris == null || Uris.Count() == 0)) {

102if (Attributes.Count() != other.Attributes.Count())

35.OrderBy(pair => keySortOrder.TakeWhile(o => pair.Key != o).Count())

543if (symbolPackagesToPublish.Count == 0 && looseFiles.Count() == 0) 574$"\tLoose symbol files ({looseFiles.Count()}): {Environment.NewLine}\t\t{string.Join($"{Environment.NewLine}\t\t", looseFiles)}");

172Assert.Equal(2, buildEngine.BuildMessageEvents.Where(x => x.Message.Contains("Adding directory")).Count()); 175Assert.Equal(symbolPackages.Keys.Count, buildEngine.BuildMessageEvents.Where(x => x.Message.Contains($"Extracting symbol package")).Count()); 176Assert.Equal(symbolPackages.Keys.Count, buildEngine.BuildMessageEvents.Where(x => x.Message.Contains($"Adding package")).Count());

422if (expectedItems.Count() != actualItems.Count()) 424Output.WriteLine($"The expected items list has {expectedItems.Count()} item(s) but the list of actual items has {actualItems.Count()}.");

374if (expectedItems.Count() != actualItems.Count()) 376Output.WriteLine($"The expected items list has {expectedItems.Count()} item(s) but the list of actual items has {actualItems.Count()}.");

246if (iels != null && iels.Count() > 0) 252if (fields == null || fields.Count() == 0)

164if (value == null || value.Count() == 0)

269if (referenceAssemblies.Count() > 1)

162_log.LogMessage(MessageImportance.High, $"Creating/Updating {links.Count()} aka.ms links."); 176_log.LogMessage(MessageImportance.High, $"Completed creating/updating {links.Count()} aka.ms links."); 265_log.LogMessage(MessageImportance.High, $"{(update ? "Updating" : "Creating")} batch of {links.Count()} aka.ms links."); 282_log.LogMessage(MessageImportance.High, $"Sending {(update ? "update" : "create")} request for batch of {links.Count()} aka.ms links."); 285_log.LogMessage(MessageImportance.High, $"Processing {(update ? "update" : "create")} response for batch of {links.Count()} aka.ms links."); 356_log.LogMessage(MessageImportance.High, $"Completed aka.ms create/update for batch {links.Count()} links.");

40if (distinctSeeds.Count() != seedNames.Distinct(StringComparer.InvariantCultureIgnoreCase).Count()) 43.Where(g => g.Count() > 1)

28Log.LogMessage($"Attempting to cancel {Jobs.Count()} Helix jobs"); 78Log.LogMessage(MessageImportance.High, $"Successfully cancelled {Jobs.Count()} Helix jobs");

57if (jd.Errors.Count() > 0)

309It.Is<IEnumerable<string>>(args => args.Count() == _expectedArgs.Count() && args.All(y => _expectedArgs.Contains(y)))),

261var result = expected.Count() == actual.Count() && expectedSet.SetEquals(actual);

130return (doNotSignExclusions.Count() > 0) && (IsExcluded(path, parent, virtualPath, containerPath, DoNotSign, doNotSignExclusions)); 138return (noStrongNameExclusions.Count() > 0) && (IsExcluded(path, parent, virtualPath, containerPath, IgnoreStrongName, noStrongNameExclusions));

25return _errors.Count() > 0;

145if (signatureFilesFailedVerifyDigestManifest.Count() > 0)

106if (ManifestHashDigestAttributes.Count() > 0)

128if (signatureManager.Signatures.Count() != 1) 133if (signatureManager.Signatures[0].SignedParts.Count != vsixPackage.GetParts().Count() - 1)

58if (signedXml.Signature.KeyInfo.OfType<KeyInfoX509Data>().Count() == 0)

140if (Options.FileStatus.Count() > 0) 348((result.NestedResults.Count() > 0) && (Options.Recursive)) || 404if (InputFiles != null && InputFiles.Count() > 0)

227repackCount = repackList.Count();

801string extractPathRoot = _useHashInExtractionPath ? fileUniqueKey.StringHash : _filesByContentKey.Count().ToString();

175_log.LogMessage($"Locally strong naming {filesToLocallyStrongNameSign.Count()} files.");

198if (!AllowEmptySignList && ItemsToSign.Count() == 0)

46if (itemGroupNode.Count() == 0) 51else if (itemGroupNode.Count() > 1)

362actualXmlElementsPerSigningRound.Count().Should().Be(expectedXmlElementsPerSigningRound.Length);

69.Where(dir => Directory.GetDirectories(dir).Count() > 0)

67Debug.Assert(ctorArgs.Count() >= 2);

40Debug.Assert(conditionArguments.Count() == 2);

41List<string> falseConditions = new List<string>(conditionMemberNames.Count()); 199if (conditionMemberNames == null || conditionMemberNames.Count() == 0) return true;

26if (ctorArgs.Count() < 2)

67Debug.Assert(ctorArgs.Count() >= 2);

41List<string> falseConditions = new List<string>(conditionMemberNames.Count()); 199if (conditionMemberNames == null || conditionMemberNames.Count() == 0) return true;

83int hypLength = hypothesis.Count(); 95hypLength = hypothesis.Count(); 105hypLength = hypothesis.Count(); 115hypLength = hypothesis.Count(); 125hypLength = hypothesis.Count(); 135hypLength = hypothesis.Count(); 148double score = SentenceBLEU(references, hypothesis, EqualWeights(hypothesis.Count())); 158double score = SentenceBLEU(references, hypothesis, EqualWeights(hypothesis.Count()));

32Assert.Equal(2, messages.Count());

194.ToDictionary(g => g.Key, g => g.Count());

722ChatMessage message = chatContents.Count() is 1 or 3 ? 723new(ChatRole.Assistant, [new FunctionCallContent($"callId{chatContents.Count()}", "Func1")]) : 1030var message = new ChatMessage(ChatRole.Assistant, [.. plan[contents.Count()].Contents]) 1124ChatMessage message = new(ChatRole.Assistant, [.. plan[contents.Count()].Contents])

100Assert.Equal(innerCallCount == 1 ? 4 : 6, values.Count());

39Assert.Equal(3, hostedServices.Count()); 83Assert.Equal(3, hostedServices.Count()); 111Assert.Equal(3, hostedServices.Count());

52Assert.Equal(2, publishersArray.Count());

144private int GetCount() => this.Count();

141element.Nodes().Count() == 1 &&

48var fileList = new List<string>(files.Count());

178Assert.Equal(2, Requests.Distinct().Count());

33Assert.Equal(2, validationResult.Failures.Count());

71if (options.RequiredUniqueChars >= 1 && password.Distinct().Count() < options.RequiredUniqueChars)

770LiteralExpression(SyntaxKind.NumericLiteralExpression, Literal(interfaceMethods.InheritedMethods.Count() + 3))))))));

275 if (gesture is PinchGestureRecognizer && _gestureRecognizers.GetGesturesFor<PinchGestureRecognizer>().Count() > 1)

488 if (existCustomTriggers.Count() > 1)

176 if (splashElements.Count() == 0)

646Contracts.Check(outputColumnNames.Count() == inputColumnNames.Count() && outputColumnNames.Count() > 0, "outputColumnNames and inputColumnNames must have the same length and greater than 0"); 667Contracts.Check(outputColumnNames.Count() == inputColumnNames.Count() && outputColumnNames.Count() > 0, "outputColumnNames and inputColumnNames must have the same length and greater than 0"); 686Contracts.Check(outputColumnNames.Count() == inputColumnNames.Count() && outputColumnNames.Count() > 0, "outputColumnNames and inputColumnNames must have the same length and greater than 0"); 758Contracts.Assert(overallColumns.Count() == overallColumns.Distinct().Count(), "detect overlapping among catalogColumns, numericColumns, textColumns and excludedColumns");

190_channel?.Trace($"load trial history from {filePath} successfully with {res.Count()} pieces of data");

74string name = (hasHeader && g.Count() == 1)

385if (args.LabelColumnIndex >= cols.Count()) 387throw new ArgumentOutOfRangeException(nameof(args.LabelColumnIndex), $"Label column index ({args.LabelColumnIndex}) is >= than # of inferred columns ({cols.Count()}).");

155else if (cardinalityRatio >= 0.85 && (avgLength > 30 || avgSpaces >= 1 || columns.Count() == 1))

110var mostCommon = columnCounts.GroupBy(x => x).OrderByDescending(x => x.Count()).First(); 111if (mostCommon.Count() < UniformColumnCountThreshold * columnCounts.Count)

74_experimentSettings.MaxExperimentTimeInSeconds, _history.Count()); 189if (_history.Count() == 3 && _history.All(r => !r.RunSucceeded))

73if (newScores.Count() == 0)

175double[] arr = new double[results.ElementAt(0).Count()]; 187if (newResults.Count() == 0) 213for (var i = 0; i < values.Count(); i++)

44if (history.Count() < availableTrainers.Count()) 98history = history.Take(availableTrainers.Count()).Where(x => x.RunSucceeded); 116.OrderBy(x => x.Count()) 127var trainer = availableTrainers.ElementAt(history.Count()); 133var results = new IValueGenerator[hps.Count()]; 135for (int i = 0; i < hps.Count(); i++)

197var count = estimators.Count();

80for (int i = 0; i != _estimators.Count(); ++i)

257var count = estimators.Count();

88int numRuns = previousRuns == null ? 0 : previousRuns.Count(); 109Single[] targets = new Single[previousRuns.Count()]; 110Single[][] features = new Single[previousRuns.Count()][];

308if (newColumns.Count() > 0) 463if (concatColNames.Count() == 1 &&

122Single[] losses = new Single[history.Count()]; 123Single[][] features = new Single[history.Count()][];

127for (var i = 0; i < scores.Count(); i++) 142for (var i = 0; i < scores.Count(); i++)

271if (allowedTypes.Count() == 1) 304return groups.FirstOrDefault(g => g.Count() > 1)?.Key;

32Console.WriteLine($"Total models produced: {experimentResult.RunDetails.Count()}");

33Console.WriteLine($"Total models produced: {experimentResult.RunDetails.Count()}");

41Console.WriteLine($"Total models produced: {experimentResult.RunDetails.Count()}");

45Console.WriteLine($"Total models produced: {experimentResult.RunDetails.Count()}");

33Console.WriteLine($"Total models produced: {experimentResult.RunDetails.Count()}");

457Assert.True(experimentResults[i].RunDetails.Count() > 0); 501Assert.True(experimentResults[i].RunDetails.Count() > 0); 541Assert.True(experimentResult.RunDetails.Count() > 1); 660if (experiment.RunDetails.Select(r => r.Exception == null).Count() > 1 && experiment.RunDetails.Last().Exception != null)

40Assert.True(columnInferenceWithGrouping.TextLoaderOptions.Columns.Count() < columnInferenceWithoutGrouping.TextLoaderOptions.Columns.Count()); 90Assert.Equal(2, result.TextLoaderOptions.Columns.Count()); 117Assert.Equal(6, result.TextLoaderOptions.Columns.Count()); 137Assert.Equal(2, result.TextLoaderOptions.Columns.Count()); 167Assert.Equal(3, result.ColumnInformation.NumericColumnNames.Count());

65Assert.Equal(8, columnNames.Count());

55parameters.Distinct().Count().Should().Be(steps);

63messages.Count().Should().Be(4);

53Assert.True(splits.trainDatasets.Count() < requestedNumSplits); 54Assert.Equal(splits.trainDatasets.Count(), splits.validationDatasets.Count()); 72Assert.Equal(requestedNumSplits, splits.trainDatasets.Count()); 73Assert.Equal(requestedNumSplits, splits.validationDatasets.Count());

359Assert.Equal(publicNames.Distinct().Count(), internalNames.Distinct().Count()); 367Assert.Equal(publicNames.Distinct().Count(), internalNames.Distinct().Count()); 375Assert.Equal(publicNames.Distinct().Count(), internalNames.Distinct().Count()); 383Assert.Equal(publicNames.Distinct().Count(), internalNames.Distinct().Count()); 391Assert.Equal(publicNames.Distinct().Count(), internalNames.Distinct().Count());

57csvTrialResultManager.GetAllTrialResults().Count().Should().Be(0); 64csvTrialResultManager.GetAllTrialResults().Count().Should().Be(10); 71csvTrialResultManager.GetAllTrialResults().Count().Should().Be(10); 78csvTrialResultManager.GetAllTrialResults().Count().Should().Be(10);

28var editor = VBufferEditor.Create(ref dst, colNames.Count()); 29for (int i = 0; i < colNames.Count(); i++)

23string inputColumn = InputColumns.Count() > 0 ? InputColumns[0] : "\"Features\""; 24string outputColumn = OutputColumns.Count() > 0 ? OutputColumns[0] : throw new Exception($"output columns for the suggested transform: {MethodName} are null"); 81string inputColumn = InputColumns.Count() > 0 ? InputColumns[0] : "\"Features\""; 82string outputColumn = OutputColumns.Count() > 0 ? OutputColumns[0] : throw new Exception($"output columns for the suggested transform: {MethodName} are null"); 111string inputColumn = InputColumns.Count() > 0 ? InputColumns[0] : "\"Features\""; 112string outputColumn = OutputColumns.Count() > 0 ? OutputColumns[0] : throw new Exception($"output columns for the suggested transform: {MethodName} are null"); 134string inputColumn = InputColumns.Count() > 0 ? InputColumns[0] : "\"Features\""; 135string outputColumn = OutputColumns.Count() > 0 ? OutputColumns[0] : throw new Exception($"output columns for the suggested transform: {MethodName} are null"); 157string inputColumn = InputColumns.Count() > 0 ? InputColumns[0] : "\"Features\""; 158string outputColumn = OutputColumns.Count() > 0 ? OutputColumns[0] : throw new Exception($"output columns for the suggested transform: {MethodName} are null"); 182string inputColumn = InputColumns.Count() > 0 ? InputColumns[0] : "\"Features\""; 183string outputColumn = OutputColumns.Count() > 0 ? OutputColumns[0] : throw new Exception($"output columns for the suggested transform: {MethodName} are null"); 286string inputColumn = InputColumns.Count() > 0 ? InputColumns[0] : "\"Features\""; 287string outputColumn = OutputColumns.Count() > 0 ? OutputColumns[0] : throw new Exception($"output columns for the suggested transform: {MethodName} are null"); 344string inputColumn = InputColumns.Count() > 0 ? InputColumns[0] : "\"Features\""; 345string outputColumn = OutputColumns.Count() > 0 ? OutputColumns[0] : throw new Exception($"output columns for the suggested transform: {MethodName} are null"); 366string inputColumn = InputColumns.Count() == 1 ? InputColumns[0] : throw new Exception($"input columns for the suggested transform: {MethodName} is not exactly one."); 367string outputColumn = OutputColumns.Count() == 1 ? OutputColumns[0] : throw new Exception($"output columns for the suggested transform: {MethodName} it not exactly one."); 384string inputColumn = InputColumns.Count() == 1 ? InputColumns[0] : throw new Exception($"input columns for the suggested transform: {MethodName} is not exactly one."); 385string outputColumn = OutputColumns.Count() == 1 ? OutputColumns[0] : throw new Exception($"output columns for the suggested transform: {MethodName} it not exactly one."); 421string inputColumn = InputColumns.Count() == 1 ? InputColumns[0] : throw new Exception($"input columns for the suggested transform: {MethodName} is not exactly one."); 422string outputColumn = OutputColumns.Count() == 1 ? OutputColumns[0] : throw new Exception($"output columns for the suggested transform: {MethodName} it not exactly one.");

74for (int i = 0; i < featureColumns.Count(); i++)

198for (int i = 0; i != expectedStrArray.Count(); ++i)

1206Contracts.Assert(Args.Where(a => a.Index == argument.Index).Count() == 1);

24public int Count => _columns.Count();

23Contract.Assert(candidatesType.Count() == 1, "multiple candidates type detected"); 34Contract.Assert(candidatesType.Count() == 1, "multiple candidates type detected");

61if (typeAttributes.Count() > 1) 66else if (typeAttributes.Count() == 1) 96if (typeAttributes.Count() > 1) 101else if (typeAttributes.Count() == 1) 150if (typeAttributes.Count() > 1) 154else if (typeAttributes.Count() == 1)

392if (customTypeAttributes.Count() > 1) 395else if (customTypeAttributes.Count() == 1)

678if (dependingColumns.Count() > 0) 691var predictorRow = _predictor.GetRow(input, activeColumns.Count() > 0 ? OutputSchema : Enumerable.Empty<DataViewSchema.Column>());

358if (dependingColumns.Count() == 0)

222if (!InputRoleMappedSchema.Feature.HasValue || dependingColumns.Count() == 0) 542if (dependingColumns.Count() == 0 || !InputRoleMappedSchema.Feature.HasValue)

465return missing.Count() == 0;

904if (slots.Count() > 0) 907var slotsVar = ctx.AddInitializer(slots, new long[] { 1, slots.Count() }, "PreservedSlots");

320uint[] indices = new uint[values.Count()]; 323for (int i = 0; i < values.Count(); ++i) 336dataViewBuilder.AddColumn(valueColumnName, GetKeyValueGetter(metaKeys), (ulong)metaKeys.Count(), indices);

97if (dependingColumns.Count() == 0)

81Contracts.Assert(truths.Count() == predicted.Count()); 82Contracts.Assert(truths.Count() == scores.Count()); 83Contracts.Assert(GroupIds.Count() == truths.Count());

150long dataSetLength = Tags.Rows.Count();

684else if (FastTreeTrainerOptions.BaggingSize > 0 && Ensemble.Trees.Count() > 0)

367if (dependingColumns.Count() == 0)

31if (stateDict.Count() == 0)

268stopTokenIds = stopTokenIds.Where(ids => ids.Count() > 0).ToList();

32if (inputs.Count() != outputs.Count()) 53if (inputs.Count() != outputs.Count()) 62outputIds = outputIds.Skip(inputIds.Count()).ToArray(); 73if (inputIds.Count() != labelIds.Count())

70dataset.Count().Should().Be(10);

30if (messages.Where(m => m.GetRole() == Role.System).Count() > 1) 115if (toolCalls.Count() == 0) 138if (toolCallResults.Count() == 0)

47responses.Count().Should().Be(1); 50response.Items.Count().Should().Be(1);

106Assert.Equal(schema1.Count(), schema2.Count()); 129Assert.Equal(data1.Count(), data2.Count());

347_host.Check(dims.Aggregate((x, y) => x * y) == values.Count(), "Number of elements doesn't match tensor size"); 358_host.Check(dims.Aggregate((x, y) => x * y) == values.Count(), "Number of elements doesn't match tensor size"); 369_host.Check(dims.Aggregate((x, y) => x * y) == values.Count(), "Number of elements doesn't match tensor size"); 380_host.Check(dims.Aggregate((x, y) => x * y) == values.Count(), "Number of elements doesn't match tensor size"); 391_host.Check(dims.Aggregate((x, y) => x * y) == values.Count(), "Number of elements doesn't match tensor size"); 402_host.Check(dims.Aggregate((x, y) => x * y) == values.Count(), "Number of elements doesn't match tensor size"); 413_host.Check(dims.Aggregate((x, y) => x * y) == values.Count(), "Number of elements doesn't match tensor size");

409tensor.Dims.Add(values.Count()); 433tensor.Dims.Add(values.Count()); 457tensor.Dims.Add(values.Count()); 481tensor.Dims.Add(values.Count()); 505tensor.Dims.Add(values.Count()); 529tensor.Dims.Add(values.Count());

289Inputs = (options.InputColumns.Count() == 0) ? Model.ModelInfo.InputNames.ToArray() : options.InputColumns; 290Outputs = (options.OutputColumns.Count() == 0) ? Model.ModelInfo.OutputNames.ToArray() : options.OutputColumns; 525if (inputShape.Where(x => x == 0).Count() > 1) 594int count = slotsAttr.Strings.Count(); 1065if (Transformer.Model.ModelInfo.InputsInfo[i].Shape.Where(x => x == 0).Count() > 1)

237else if (shape.Count() != 0 && shape.Aggregate((x, y) => x * y) > 0)

366if (left.Count() != right.Count())

710Assert.Equal(3, dictionary.Count()); 725Assert.Equal(3, dictionary.Count()); 763Assert.Equal(3, dictionary.Count()); 778Assert.Equal(3, dictionary.Count()); 866for (int i = 0; i < dataPoints.Count(); ++i) 868Assert.Equal(dataPoints[i].Input.Count(), transformedDataPoints[i].Output.Count()); 933Assert.Equal(dataPoints.Count(), transformedDataPoints.Count); 1097Assert.Equal(dataPoints.Count(), transformedDataPoints.Count);

703segments = segments.Skip(segments.Count() - dirCount - 1); 705if (segments.Count() < dirCount - 1) 776return PartitionedPathUtils.SplitDirectories(path).Count() - 1;

179if (col.Source < 0 || col.Source >= values.Count()) 193return dirs.Take(dirs.Count() - 1); // Ignore last directory which is the file name. 340dirs = dirs.Take(dirs.Count() - 1); // Ignore last directory which is the file name. 342names = new List<string>(dirs.Count()); 343values = new List<string>(dirs.Count());

367if (dependingColumns.Count() == 0)

30Contract.Assert(distinctChoices.Count() == choices.Length, "choices must not contain repeated values");

206Contract.Assert(attributes.Count() <= 1, $"{field.Name} can only define one of the choice|range|option attribute"); 207if (attributes.Count() == 0) 253Contract.Assert(attributes.Count() <= 1, $"{property.Name} can only define one of the choice|range|option attribute"); 254if (attributes.Count() == 0)

33if (arrays.Count() == 1)

145if (columns.Count() == 0)

93int numRuns = previousRuns == null ? 0 : previousRuns.Count(); 114Single[] targets = new Single[previousRuns.Count()]; 115Single[][] features = new Single[previousRuns.Count()][];

1123Assert.Equal(2, cross.Count());

262datetimes.Count().Should().Be(2);

1196for (int i = 0; i < dataObjects.Count(); i++)

28var cnt = data1.GetColumn<float>(data1.Schema["Floats"]).Count(); 33cnt = data2.GetColumn<float>(data.Schema["Floats"]).Count();

361for (int i = 0; i < featureImportance.Count(); i++)

385Assert.True(Enumerable.Intersect(uniqueTrain, uniqueTest).Count() == 0); 398Assert.True(Enumerable.Intersect(uniqueSeedTrain, uniqueSeedTest).Count() == 0); 503Assert.True(Enumerable.Intersect(idsTest1, idsTest2).Count() == 0); 504Assert.True(idsTest1.Count() > 0, $"CV Split 0 for Column {colname} was empty"); 505Assert.True(idsTest2.Count() > 0, $"CV Split 1 for Column {colname} was empty");

1341Assert.Equal(numRows, ids.Count()); 1342Assert.Equal(numRows, descriptions.Count()); 1343Assert.Equal(numRows, animals.Count());

844for (int i = 0; i < predictions.Count(); ++i)

831if (tree.GetCategoricalSplitFeaturesAt(nodeId).Count() > 0) 835if (tree.GetCategoricalCategoricalSplitFeatureRangeAt(nodeId).Count() > 0) 860if (tree.GetLeafSamplesAt(nodeId).Count() > 0) 864if (tree.GetLeafSampleWeightsAt(nodeId).Count() > 0) 883for (int i = 0; i < trees.Count(); i++)

1081int numberCount = numbers.Count(); 1082int halfIndex = numbers.Count() / 2;

282double meanGain = sumGain / aggDim.Count();

604if (dependingColumns.Count() == 0)

429mask.AddRange(Enumerable.Repeat(0, tokenIds.Count())); 433mask.AddRange(Enumerable.Repeat(0, additionalTokenIds.Count())); 612int capacity = tokenIds.Count() + 2 + (additionalTokenIds is null ? 0 : additionalTokenIds.Count() + 1);

814Assert.Equal(ids.Count(), tokenizer.CountTokens(text));

120int gt = groundTruthBoxes.Where(k => k.Value != 0).Count(); 138int gt = groundTruthBoxes.Where(k => k.Value != 0).Count();

146long[,] targetArray = new long[targets.Count(), maxLength]; 148for (int i = 0; i < targets.Count(); i++)

342if (inputTensors.Count() == 0)

251if (inputTensors.Count() == 0) 325if (inputTensors.Count() == 0)

102Assert.Equal(2, prev.RowView.Count());

161Assert.Equal(8, a.Count()); 257Assert.Equal(8, transformedData.RowView.Count()); 340Assert.Equal(8, predictedLabel.Count());

265Host.CheckDecode(slotMap[j].Distinct().Count() == slotMap[j].Length); 323Host.Assert(ex.SlotMap[i].Distinct().Count() == ex.SlotMap[i].Length); 363if (slots.Distinct().Count() < slots.Length)

114Host.CheckUserArg(options.Columns.Distinct().Count() == options.Columns.Length, nameof(options.Columns),

884Contracts.Assert(examples == featurizedImages.Count()); 964runnerOutputTensorNames.Count() > 0 ? runnerOutputTensorNames.ToArray() : null,

87if (projectsWithHierarchy.Count() <= 1)

175var distinctLanguageCount = targetsWithSameName.Select(t => t.LanguageGlyph).Distinct().Count();

144var count = GetUndoUnits(undoManager).SkipWhile(u => u != markerPrimitive).Count() + (undoConflictResolution ? 0 : -1);

163var orderedChangedDocuments = changedDocuments.GroupBy(d => d.ProjectId).OrderByDescending(g => g.Count()).Flatten();

107if (SelectedItems == _tableControl.SelectedEntries.Count())

120pcMembers = membersAndIds.Count(); 181pcMembers = membersAndIds.Count(); 242var current = Marshal.AllocCoTaskMem(source.Count() * IntPtr.Size);

140return (VSConstants.S_OK, entryPoints.Count());

67Assert.Equal(1, bases.Cast<CodeElement>().Count()); 86Assert.Equal(2, interfaces.Cast<CodeElement>().Count());

597var hashAttributeCount = hashAttributes.Count();

647var count = data.First().Count(); 648Debug.Assert(data.All(d => d.Count() == count));

179=> $"Interval tree with '{System.Linq.Enumerable.Count(this)}' entries. Use '.ToList()' to visualize contents.";

403if (words.Count() == 1) // Only Split if words have not been split before

72return [.. triviaList.Skip(triviaInLeadingBlankLines.Count())];

278Debug.Assert(originalIdentifierNodes.Count() == replacedIdentifierNodes.Count());

44var clauses = SyntaxFactory.List(allClauses.Take(allClauses.Count() - 1).Cast<QueryClauseSyntax>());

187where g.Count() > 1

1855var result = expected.Count() == actual.Count() && expectedSet.SetEquals(actual);

557Assert.Equal(2, syncedFullSolution.Projects.Count()); 563Assert.Equal(2, project1SyncedSolution.Projects.Count()); 569Assert.Equal(2, project2SyncedSolution.Projects.Count()); 595Assert.Equal(1, project1SyncedSolution.Projects.Count()); 602Assert.Equal(1, project2SyncedSolution.Projects.Count()); 610Assert.Equal(2, syncedFullSolution.Projects.Count()); 636Assert.Equal(1, project2SyncedSolution.Projects.Count()); 643Assert.Equal(2, project3SyncedSolution.Projects.Count()); 670Assert.Equal(2, project3SyncedSolution.Projects.Count()); 676Assert.Equal(1, project2SyncedSolution.Projects.Count()); 683Assert.Equal(1, project1SyncedSolution.Projects.Count()); 712Assert.Equal(3, project3SyncedSolution.Projects.Count()); 718Assert.Equal(2, project2SyncedSolution.Projects.Count()); 724Assert.Equal(1, project1SyncedSolution.Projects.Count()); 752Assert.Equal(3, project3SyncedSolution.Projects.Count()); 758Assert.Equal(1, project2SyncedSolution.Projects.Count()); 764Assert.Equal(1, project1SyncedSolution.Projects.Count()); 790Assert.Equal(1, project1SyncedSolution.Projects.Count()); 797Assert.Equal(1, project2SyncedSolution.Projects.Count()); 823Assert.Equal(2, fullSyncedSolution.Projects.Count()); 835Assert.Equal(2, project1SyncedSolution.Projects.Count()); 847Assert.Equal(2, project2SyncedSolution.Projects.Count()); 878Assert.Equal(2, fullSyncedSolution.Projects.Count()); 891Assert.Equal(2, project1SyncedSolution.Projects.Count()); 947Assert.Equal(2, fullSyncedSolution.Projects.Count());

154ConsoleUtil.WriteLine($"{unmatchedLocalTests.Count} tests were missing historical data. {unmatchedRemoteTests.Count()} tests were missing in local assemblies. Estimate of total execution time for tests is {totalExpectedRunTime}.");

27schemas.MapPost("/ienumerable-of-ints", (IEnumerable<int> values) => values.Count());

237ilGenerator.LoadInt(enumerable.Cast<object>().Count());

367int count = PartsInternal.Count();

140int constructorsCount = genericPartTypeInfo.DeclaredConstructors.Count();

130return !onlyIfCheap || _source is ICollection<TSource> ? _source.Count() + 1 : -1; 283return !onlyIfCheap || _source is ICollection<TSource> ? _source.Count() + _appendCount + _prependCount : -1;

23firstCount = _first.Count(); 33secondCount = _second.Count(); 178int sourceCount = collection?.Count ?? source.Count();

35count = _source.Count();

61return !onlyIfCheap || _source is ICollection<TElement> || _source is ICollection ? _source.Count() : -1;

27!onlyIfCheap ? _source.Count() :

25count += _selector(element).Count();

29!onlyIfCheap ? _source.Count() : 155!onlyIfCheap ? _source.Take(_takeCount).Count() :

273return Math.Max(_source.Count() - _minIndexInclusive, 0);

17public int Count => _data.Count(); 35public int Count => _data.Count();

45int numUnderstoodHeaders = requestMessage.Headers.UnderstoodHeaders.Count<MessageHeaderInfo>(); 73numUnderstoodHeaders = requestMessage.Headers.UnderstoodHeaders.Count<MessageHeaderInfo>();

1403sizeToAllocate += sizeof(TASKDIALOG_BUTTON) * customButtonElements.Count(); 1418sizeToAllocate += sizeof(TASKDIALOG_BUTTON) * radioButtonElements.Count(); 1474int customButtonCount = customButtonElements.Count(); 1499int radioButtonCount = radioButtonElements.Count();

56Debug.Assert(s_validKeys.Distinct().Count() == s_validKeys.Length);

91glyphs.OfType<ContainerSelectorGlyph>().Count().Should().Be(1);

117if (page.Links?.Count() > 0) 162Assert.True(html.Links.Length == page.Links.Count(), $"Expected {page.Url} to have {page.Links.Count()} links but it had {html.Links.Length}");

117if (page.Links?.Count() > 0) 162Assert.True(html.Links.Length == page.Links.Count(), $"Expected {page.Url} to have {page.Links.Count()} links but it had {html.Links.Length}");

117if (page.Links?.Count() > 0) 162Assert.True(html.Links.Length == page.Links.Count(), $"Expected {page.Url} to have {page.Links.Count()} links but it had {html.Links.Length}");