127double documentCount = documentPerformance.Where(x => x.Key.ProjectId == projectId).Count();

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

412var totalItemCount = results.Count();

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

93if (packages.Count() > 1)

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

30Assert.Equal(2, endpoints.Count()); 92Assert.Equal(2, endpoints.Count());

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

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

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

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

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

123Assert.Equal(2, annotations.Count()); 141Assert.Equal(3, annotations.Count());

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

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

242logger.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));

595var 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;

131return options?.Errors.Count() == 0; 144if (cmdOptions.Errors.Count() == 0 && cmdOptions.Inputs.Count == 1) 147TryFromFile(fileUri.LocalPath, out var fileOptions) && fileOptions.GetOptions().Count() > 0) 163if (disallowedSwitchesOnParamsFilesProvided.Count() > 0) 199if (this.Help != true && this.Errors.Count() == 0) 501if (paramsFiles.Count() == 1) 505else if (paramsFiles.Count() == 0) 511if (paramsFiles.Count() > 1) 659if (invalidNamespaces.Count() > 0) 723await safeLogger.WriteMessageAsync($"resolved inputs: {inputFiles.Count()}", logToUI: false).ConfigureAwait(false);

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

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

79if (refItems == null || refItems.Count() == 0) 102if (refItems == null || refItems.Count() == 0) 126if (refItems == null || refItems.Count() == 0) 139if (this.TargetFrameworks.Count() > 1 && this.TargetFrameworks.Any(t => TargetFrameworkHelper.IsSupportedFramework(t, out netfxInfo) && !netfxInfo.IsDnx)) 199if (targetFrameworkElements.Count() > 0) 221if (targetFrameworksElements.Count() > 0) 255if (runtimeIdentifierElements.Count() > 0) 450if (createOnMissing && groups.Count() == 0) 547if (this.TargetFrameworks.Count() > 1 && dependency.Name.Equals(TargetFrameworkHelper.FullFrameworkReferences.FirstOrDefault().Name) 618if (existingElements.Count() > 0) 675if (targetFrameworkElements.Count() > 0) 683if (targetFrameworksElements.Count() > 0) 794await safeLogger.WriteMessageAsync($"Resolved project reference count: {dependencies.Count()}", logToUI: false).ConfigureAwait(false); 991if (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; 289if (project.TargetFrameworks.Count() > 1 && project.TargetFrameworks.Any(t => TargetFrameworkHelper.IsSupportedFramework(t, out FrameworkInfo fxInfo) && !fxInfo.IsDnx)) 337if (options.Errors.Count() > 0)

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

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

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

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

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

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

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

1295Assert.Equal(2, error.Count()); 2464Assert.Equal(2, LogMessages.Where(message => message.LogLevel == LogLevel.Error).Count()); 2524Assert.Equal(2, LogMessages.Where(message => message.LogLevel == LogLevel.Error).Count()); 2664Assert.Equal(2, LogMessages.Where(message => message.LogLevel == LogLevel.Error).Count());

1381Logger.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));

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

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

106var actual = serviceDescriptors.Count(); 133else if (implementationTypes.Length != implementationTypes.Distinct().Count())

109int actualCount = actualResults.Count();

797Assert.Equal(2, services.Count()); 812Assert.Equal(2, services.Count()); 827Assert.Equal(2, services.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());

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

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

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)

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

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

836Assert.True(expectedHeaderNames.Count() == expectedHeaderValues.Count(), $"{nameof(expectedHeaderNames)} and {nameof(expectedHeaderValues)} sizes must match"); 847Assert.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 => $@"

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

71if (configCacheToSerialize.Count() > 1)

61if (paths.Count() > 1)

2337yield return new KeyValuePair<string, S>(Convert.ToString(itemsOfType.Count(), CultureInfo.InvariantCulture), null /* no base item */);

1098int length = items.Count();

92configs!.Keys.Count().ShouldBe(3);

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

1864var childrenCount = projectElement.AllChildren.Count(); 1881Assert.NotEqual(childrenCount, projectElement.AllChildren.Count()); 1885Assert.Equal(childrenCount, projectElement.AllChildren.Count());

2228Assert.Equal(2, project.Xml.AllChildren.OfType<ProjectItemElement>().Count()); 2288Assert.Equal(2, project.Xml.AllChildren.OfType<ProjectItemElement>().Count()); 2657items.Count().ShouldBe(3);

705assemblyNameOriginal.RemappedFromEnumerator.Count().ShouldBe(1); 720assemblyNameDeserialized.RemappedFromEnumerator.Count().ShouldBe(1);

210.Count() 213.Count() 217.Count() 220.Count() 3530Assert.Equal(3, resultsFiles.Count()); 3967Assert.True(_logger.AllBuildEvents.OfType<ProjectEvaluationStartedEventArgs>().GroupBy(args => args.BuildEventContext.EvaluationId).All(g => g.Count() == 1));

178Assert.Equal(2, group.Where(item => item.EvaluatedInclude == "a1").Count()); 190Assert.Equal(2, group.Where(item => item.EvaluatedInclude == "a1").Count()); 230Assert.Equal(4, group.Where(item => item.EvaluatedInclude == "a1").Count()); 243Assert.Equal(4, group.Where(item => item.EvaluatedInclude == "a1").Count());

2873Assert.Equal(count, itemGroup.Count());

882Assert.Equal(3, items.Count()); 914Assert.Equal(4, items.Count());

1930Assert.Equal(allEvaluatedPropertiesWithNoBackingXmlAndNoDuplicates.Count, nonImportedProperties.Count()); 1951Assert.Equal(4, restOfAllEvaluatedProperties.Count()); 1962Assert.Equal(4, restOfAllEvaluatedProperties.Count()); 2094Assert.Equal(allEvaluatedPropertiesWithNoBackingXmlAndNoDuplicates.Count, nonImportedProperties.Count()); 2115Assert.Equal(3, restOfAllEvaluatedProperties.Count()); 2226Assert.Equal(nonImportedProperties.Count(), allProjectPropertiesNoDuplicateNames.Count); 4728.Count() 4796.Count()

170Assert.Equal(2, composite.Globs.Count());

690graph.ProjectNodes.Count.ShouldBe(graph.ProjectNodes.Select(GetProjectPath).Distinct().Count());

238logger.AllBuildEvents.OfType<ProjectStartedEventArgs>().Count().ShouldBe(3); 260logger.AllBuildEvents.OfType<ProjectStartedEventArgs>().Count().ShouldBe(3); 355rootLogger.AllBuildEvents.OfType<ProjectStartedEventArgs>().Count().ShouldBe(2); 356declaredReferenceLogger.AllBuildEvents.OfType<ProjectStartedEventArgs>().Count().ShouldBe(2); 387logger.AllBuildEvents.OfType<ProjectStartedEventArgs>().Count().ShouldBe(2);

2233GetNodesWithProjectNumber(graph, 2).Count().ShouldBe(2);

64writer.Write(EntryProjectsFullPath.Count()); 70writer.Write(TargetNames.Count());

388var propertyCount = validProperties.Count();

595var hashAttributeCount = hashAttributes.Count();

705assemblyNameOriginal.RemappedFromEnumerator.Count().ShouldBe(1); 720assemblyNameDeserialized.RemappedFromEnumerator.Count().ShouldBe(1);

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

763logLines.Where(l => l.Contains(dotnetPath)).Count().ShouldBe(1, log);

1310a.Count().ShouldBe(b.Count());

4012myPlatforms.Count().ShouldBe(3); 4093ToolLocationHelper.GetFoldersInVSInstalls(null, null, "relativePath").Count().ShouldBe(0);

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)

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

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

708var count = data.First().Count(); 709Debug.Assert(data.All(d => d.Count() == 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

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

708var count = data.First().Count(); 709Debug.Assert(data.All(d => d.Count() == count));

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

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

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

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

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

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

72return new SyntaxTriviaList(triviaList.Skip(triviaInLeadingBlankLines.Count()));

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

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

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

757Assert.Equal(1, errors.Count()); 769Assert.Equal(1, errors.Count()); 780Assert.Equal(1, errors.Count()); 791Assert.Equal(1, errors.Count()); 802Assert.Equal(1, errors.Count()); 813Assert.Equal(1, errors.Count()); 882Assert.Equal(1, errors.Count()); 1902Assert.Equal(0, parsedArgs.ParseOptions.PreprocessorSymbolNames.Count()); 1906Assert.Equal(1, parsedArgs.ParseOptions.PreprocessorSymbolNames.Count()); 1911Assert.Equal(3, parsedArgs.ParseOptions.PreprocessorSymbolNames.Count()); 1918Assert.Equal(1, parsedArgs.ParseOptions.PreprocessorSymbolNames.Count()); 4499Assert.Equal(1, Directory.EnumerateFiles(dir.Path, exeName).Count()); 7087Assert.Equal(1, Directory.EnumerateFiles(dir.Path, "*" + PathUtilities.GetExtension(expectedOutputName)).Count()); 7088Assert.Equal(1, Directory.EnumerateFiles(dir.Path, expectedOutputName).Count());

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

209Assert.Equal(1, diagnosticsFromAnalyzer.Count());

178Assert.Equal(0, items.Count()); 644Assert.Equal(expecteditems.Count(), items.Count());

262Assert.Equal(0, items.Count()); 1033Assert.Equal(expecteditems.Count(), items.Count());

87Assert.Equal(0, solution.Projects.Count()); 94Assert.Equal(1, solution.Projects.Count()); 109Assert.Equal(0, solution.Projects.Count()); 125Assert.Equal(0, solution.Projects.Count()); 328Assert.Equal(0, snapshot.GetProject(id1).ProjectReferences.Count()); 766Assert.Equal(2, workspace.CurrentSolution.GetProject(project1.Id).Documents.Count()); 787Assert.Equal(0, workspace.CurrentSolution.GetProject(project1.Id).Documents.Count()); 1055Assert.Equal(1, project.Documents.Count()); 1056Assert.Equal(1, project.AdditionalDocuments.Count()); 1079Assert.Equal(1, project.Documents.Count()); 1080Assert.Equal(1, project.AnalyzerConfigDocuments.Count()); 1243Assert.Equal(1, workspace.CurrentSolution.GetProject(project1.Id).Documents.Count()); 1244Assert.Equal(2, workspace.CurrentSolution.GetProject(project1.Id).AdditionalDocuments.Count()); 1253Assert.Equal(1, workspace.CurrentSolution.GetProject(project1.Id).Documents.Count()); 1254Assert.Equal(1, workspace.CurrentSolution.GetProject(project1.Id).AdditionalDocuments.Count()); 1279Assert.Equal(1, workspace.CurrentSolution.GetProject(project1.Id).Documents.Count()); 1280Assert.Equal(2, workspace.CurrentSolution.GetProject(project1.Id).AnalyzerConfigDocuments.Count()); 1289Assert.Equal(1, workspace.CurrentSolution.GetProject(project1.Id).Documents.Count()); 1290Assert.Equal(1, workspace.CurrentSolution.GetProject(project1.Id).AnalyzerConfigDocuments.Count()); 1312Assert.Equal(1, workspace.CurrentSolution.GetProject(project1.Id).Documents.Count()); 1313Assert.Equal(2, workspace.CurrentSolution.GetProject(project1.Id).AdditionalDocuments.Count()); 1319Assert.Equal(1, workspace.CurrentSolution.GetProject(project1.Id).Documents.Count()); 1320Assert.Equal(1, workspace.CurrentSolution.GetProject(project1.Id).AdditionalDocuments.Count()); 1340Assert.Equal(1, workspace.CurrentSolution.GetProject(project1.Id).Documents.Count()); 1341Assert.Equal(2, workspace.CurrentSolution.GetProject(project1.Id).AnalyzerConfigDocuments.Count()); 1347Assert.Equal(1, workspace.CurrentSolution.GetProject(project1.Id).Documents.Count()); 1348Assert.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());

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

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

3169Assert.Equal(0, comp2.GetDiagnostics().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());

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

3125Assert.Equal(2, syntax.ArgumentList.Arguments.Count()); 3127Assert.Equal(0, syntax.ArgumentList.Arguments.Count()); 7538Assert.Equal(3, attrArgSyntaxes.Count()); 8855Assert.Equal(0, type.GetAttributes()[0].ConstructorArguments.Count());

1025Assert.Equal(expectedSrcAttrCount, sourceAttributes.Count());

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

2810Assert.Equal(0, metadataReader.FieldDefinitions.AsEnumerable().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);

255Assert.True(symbols.Count() > 1); 308Assert.True(symbols.Count() > 1);

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

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

243var groupCount = group.Count();

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

49var identifiersCount = identifiers.Count();

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

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

37if (statements.Count() != 1)

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

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

670Assert.Equal(2, newProject.Documents.Count()); 671Assert.Equal(0, changes.GetChangedDocuments().Count()); 672Assert.Equal(1, changes.GetAddedDocuments().Count()); 716Assert.Equal(2, newProject.Documents.Count()); 717Assert.Equal(0, changes.GetChangedDocuments().Count()); 718Assert.Equal(1, changes.GetAddedDocuments().Count());

211Assert.Equal(0, SyntaxUtilities.GetSuspensionPoints(m0.ExpressionBody).Count()); 212Assert.Equal(1, SyntaxUtilities.GetSuspensionPoints(m1.ExpressionBody).Count()); 213Assert.Equal(1, SyntaxUtilities.GetSuspensionPoints(m2.Body).Count()); 214Assert.Equal(0, SyntaxUtilities.GetSuspensionPoints(m3.Body).Count()); 215Assert.Equal(1, SyntaxUtilities.GetSuspensionPoints(f1.ExpressionBody).Count()); 216Assert.Equal(1, SyntaxUtilities.GetSuspensionPoints(f2.Body).Count()); 217Assert.Equal(1, SyntaxUtilities.GetSuspensionPoints(l1.Body).Count()); 218Assert.Equal(1, SyntaxUtilities.GetSuspensionPoints(l2.Body).Count()); 219Assert.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());

387Assert.Equal(0, comp2.GetDiagnostics().Count()); 476Assert.True(0 < errs.Count(), "Diagnostics not empty"); 532Assert.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());

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()); 1628Assert.Equal(2, outputCompilation.SyntaxTrees.Count()); 4562Assert.Equal(2, result.HostOutputs.Keys.Count());

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

835Assert.InRange(comp.GetDiagnostics().Count(), 0, int.MaxValue); 836Assert.InRange(comp.GetDeclarationDiagnostics().Count(), 0, int.MaxValue); 889Assert.InRange(comp.GetDiagnostics().Count(), 0, int.MaxValue); 894Assert.Equal(0, comp.GetDiagnostics(cancellationToken: default(CancellationToken)).Count()); 899Assert.InRange(comp.GetDiagnostics().Count(), 0, int.MaxValue); 902Assert.Equal(0, comp.GetDiagnostics().Count()); 907Assert.InRange(error.Count(), 1, int.MaxValue); 910Assert.Equal(0, comp.GetDiagnostics().Count()); 1903Assert.Equal(2, comp.References.Count()); 2611Assert.Equal(1, type.GetMembers().OfType<IPropertySymbol>().Count()); 2632Assert.Equal(2, type.GetMembers().OfType<IPropertySymbol>().Count()); 2647Assert.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());

5883Assert.Equal(2, comp.GetMethodBodyDiagnostics().Count()); 5884Assert.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());

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

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

1862Assert.Equal(0, comp.GetDiagnostics().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());

163Assert.Equal(0, diagnostics.Count()); 190Assert.Equal(2, diagnostics.Count()); 1426Assert.Equal(1, comp.GetDeclarationDiagnostics().Count()); 1617Assert.Equal(0, c1.GetDiagnostics().Count()); 1618Assert.Equal(0, c2.GetDiagnostics().Count()); 1623Assert.Equal(0, c2.GetDiagnostics().Count());

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

509Assert.Equal(0, comp.GetDeclarationDiagnostics().Count()); 585Assert.Equal(0, comp.GetDiagnostics().Count()); 769Assert.Equal(0, comp1.GetDiagnostics().Count()); 770Assert.Equal(0, comp2.GetDiagnostics().Count()); 771Assert.Equal(0, comp.GetDiagnostics().Count()); 1058Assert.Equal(0, comp1.GetDiagnostics().Count()); 1059Assert.Equal(0, comp2.GetDiagnostics().Count()); 1060Assert.Equal(0, comp.GetDiagnostics().Count()); 1163Assert.Equal(0, comp.GetDiagnostics().Count()); 1257Assert.Equal(0, comp.GetDiagnostics().Count()); 1462Assert.Equal(0, comp.GetDeclarationDiagnostics().Count()); 1500Assert.Equal(0, comp.GetDeclarationDiagnostics().Count()); 1544Assert.Equal(0, comp.GetDeclarationDiagnostics().Count());

633Assert.Equal(2, type.GetMembers().OfType<MethodSymbol>().Count()); 638Assert.Equal(0, type.GetMembers().OfType<PropertySymbol>().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());

3711Assert.Equal(pd.Count(), id.Count()); 3712for (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 3496Assert.Equal(1, node.DescendantTrivia().Count()); 3507Assert.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);

1368if (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()); 195Assert.InRange(expectedGroup.Count(), 0, actualGroupCount);

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

72return new SyntaxTriviaList(triviaList.Skip(triviaInLeadingBlankLines.Count()));

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

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

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

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

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

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

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

114Assert.Equal(1, testState.TestExtractInterfaceOptionsService.AllExtractableMembers.Count());

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

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

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

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

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

162Assert.Equal(0, tags.Count()); 186Assert.Equal(1, tags.Count());

456Assert.True(transitiveDerived.Count() > immediateDerived.Count()); 505Assert.True(transitiveDerived.Count() > immediateDerived.Count()); 557Assert.True(transitiveImpls.Count() > immediateImpls.Count());

114Assert.Equal(0, tags.Count()); 140Assert.Equal(2, tags.Count());

87Assert.Equal(50, GetIntersectingSpans(tree, new SnapshotSpan(buffer.CurrentSnapshot, 150, 50)).Count()); 90Assert.Equal(26, GetIntersectingSpans(tree, new SnapshotSpan(buffer.CurrentSnapshot, 175, 25)).Count()); 101Assert.Equal(1, GetIntersectingSpans(tree, new SnapshotSpan(buffer.CurrentSnapshot, 0, 1)).Count()); 102Assert.Equal(1, GetIntersectingSpans(tree, new SnapshotSpan(buffer.CurrentSnapshot, 50, 1)).Count()); 105Assert.Equal(2, GetIntersectingSpans(tree, new SnapshotSpan(buffer.CurrentSnapshot, 100, 1)).Count()); 119Assert.Equal(51, GetIntersectingSpans(tree, new SnapshotSpan(buffer.CurrentSnapshot, 0, 1)).Count()); 133Assert.Equal(51, GetIntersectingSpans(tree, new SnapshotSpan(buffer.CurrentSnapshot, 99, 1)).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());

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

175Debug.Assert(diags.Length == CompilationWithAnalyzers.GetEffectiveDiagnostics(diags, compilation).Count()); 176Debug.Assert(diagnostics.Length == ConvertToLocalDiagnostics(diags, textDocument, span).Count());

721return currentActionCount + actionSets.Sum(a => a.Actions.Count()) > 3

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

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

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

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

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

402errorCount = result.Count();

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

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

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

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)

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)

1761Debug.Assert(indexesOfApplicableCandidates.Count = applicableCandidates) 1777For i As Integer = 0 To indexesOfApplicableCandidates.Count - 2 1784For j As Integer = i + 1 To indexesOfApplicableCandidates.Count - 1 2194left.EquallyApplicableCandidatesBucket = buckets.Count + 1 3558ElseIf applicableCount = quickInfo.Count Then 3572For k As Integer = 0 To If(applicableCount > 0 OrElse Not includeEliminatedCandidates, applicableCount, quickInfo.Count) - 1 3587For l As Integer = k + 1 To quickInfo.Count - 1 3647For l As Integer = k + 1 To quickInfo.Count - 1

2855Assert.Equal(3, nodes.Count)

81Debug.Assert(program.<file>.Count = 1, "Only one file can be in the compilation.") 99Debug.Assert(spans.Count = 1 AndAlso spans(0).Count = 1, "Exactly one region must be selected")

41Assert.Equal(0, controlFlowAnalysis.ExitPoints.Count()) 42Assert.Equal(0, controlFlowAnalysis.EntryPoints.Count()) 63Assert.Equal(0, controlFlowAnalysis.ExitPoints.Count()) 64Assert.Equal(0, controlFlowAnalysis.EntryPoints.Count()) 91Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()) 92Assert.Equal(1, controlFlowAnalysisResults.ExitPoints.Count()) 127Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()) 128Assert.Equal(1, controlFlowAnalysisResults.ExitPoints.Count()) 158Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()) 159Assert.Equal(0, controlFlowAnalysisResults.ExitPoints.Count()) 188Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()) 189Assert.Equal(0, controlFlowAnalysisResults.ExitPoints.Count()) 219Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()) 220Assert.Equal(0, controlFlowAnalysisResults.ExitPoints.Count()) 251Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()) 252Assert.Equal(0, controlFlowAnalysisResults.ExitPoints.Count()) 283Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()) 284Assert.Equal(0, controlFlowAnalysisResults.ExitPoints.Count()) 334Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()) 335Assert.Equal(0, controlFlowAnalysisResults.ExitPoints.Count()) 365Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()) 366Assert.Equal(0, controlFlowAnalysisResults.ExitPoints.Count()) 396Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()) 397Assert.Equal(0, controlFlowAnalysisResults.ExitPoints.Count()) 429Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()) 430Assert.Equal(0, controlFlowAnalysisResults.ExitPoints.Count()) 460Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()) 461Assert.Equal(0, controlFlowAnalysisResults.ExitPoints.Count()) 483Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()) 484Assert.Equal(0, controlFlowAnalysisResults.ExitPoints.Count()) 506Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()) 507Assert.Equal(0, controlFlowAnalysisResults.ExitPoints.Count()) 529Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()) 530Assert.Equal(0, controlFlowAnalysisResults.ExitPoints.Count()) 550Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()) 551Assert.Equal(0, controlFlowAnalysisResults.ExitPoints.Count()) 574Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()) 575Assert.Equal(0, controlFlowAnalysisResults.ExitPoints.Count()) 613Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()) 614Assert.Equal(0, controlFlowAnalysisResults.ExitPoints.Count()) 655Assert.Equal(1, controlFlowAnalysisResults.EntryPoints.Count()) 656Assert.Equal(0, controlFlowAnalysisResults.ExitPoints.Count()) 786Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count) 787Assert.Equal(3, controlFlowAnalysisResults.ExitPoints.Count) 794Assert.Equal(1, dataFlowAnalysisResults.DataFlowsIn.Count) 797Assert.Equal(1, dataFlowAnalysisResults.ReadInside.Count) 799Assert.Equal(1, dataFlowAnalysisResults.ReadOutside.Count) 803Assert.Equal(1, dataFlowAnalysisResults.WrittenOutside.Count) 836Assert.Equal(2, dataFlowAnalysisResults.ReadInside.Count) 839Assert.Equal(2, dataFlowAnalysisResults.WrittenInside.Count) 874Assert.Equal(0, dataFlowAnalysisResults.WrittenInside.Count) 1347Assert.Equal(2, flow.VariablesDeclared.Count) 1405Assert.Equal(2, controlFlowAnalysis.ExitPoints.Count()) 1406Assert.Equal(1, controlFlowAnalysis.EntryPoints.Count()) 1443Assert.Equal(1, controlFlowAnalysis.ExitPoints.Count()) 1444Assert.Equal(1, controlFlowAnalysis.EntryPoints.Count()) 1492Assert.Equal(1, analysis.ExitPoints.Count()) 1511Assert.Equal(1, analysis.ExitPoints.Count()) 1531Assert.Equal(1, analysis.ExitPoints.Count()) 1532Assert.Equal(0, analysis.EntryPoints.Count()) 1554Assert.Equal(1, analysis.ExitPoints.Count()) 1555Assert.Equal(0, analysis.EntryPoints.Count()) 1577Assert.Equal(1, analysis.ExitPoints.Count()) 1578Assert.Equal(0, analysis.EntryPoints.Count()) 1600Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()) 1601Assert.Equal(1, controlFlowAnalysisResults.ExitPoints.Count()) 1630Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()) 1631Assert.Equal(1, controlFlowAnalysisResults.ExitPoints.Count()) 1661Assert.Equal(0, controlFlowAnalysisResults.EntryPoints.Count()) 1662Assert.Equal(1, controlFlowAnalysisResults.ExitPoints.Count())

55Assert.Equal(0, controlFlowAnalysis.EntryPoints.Count()) 56Assert.Equal(2, controlFlowAnalysis.ExitPoints.Count()) 105Assert.Equal(1, analysis.EntryPoints.Count()) 106Assert.Equal(0, analysis.ExitPoints.Count()) 142Assert.Equal(1, controlFlowAnalysis.EntryPoints.Count()) 143Assert.Equal(1, controlFlowAnalysis.ExitPoints.Count()) 193Assert.Equal(2, controlFlowAnalysis.ExitPoints.Count()) 240Assert.Equal(2, controlFlowAnalysis.ExitPoints.Count()) 297Assert.Equal(2, controlFlowAnalysis.ExitPoints.Count()) 356Assert.Equal(1, controlFlowAnalysis.ExitPoints.Count()) 413Assert.Equal(0, controlFlowAnalysis.ExitPoints.Count()) 469Assert.Equal(3, controlFlowAnalysis.ExitPoints.Count()) 525Assert.Equal(2, controlFlowAnalysis.ExitPoints.Count()) 1031Assert.Equal(1, controlFlowAnalysis.ExitPoints.Count) 1739Assert.Equal(0, dataFlowAnalysisResults.AlwaysAssigned.Count) 1740Assert.Equal(0, dataFlowAnalysisResults.Captured.Count) 1742Assert.Equal(2, dataFlowAnalysisResults.DataFlowsIn.Count) 1746Assert.Equal(0, dataFlowAnalysisResults.DataFlowsOut.Count) 1748Assert.Equal(2, dataFlowAnalysisResults.ReadInside.Count) 1752Assert.Equal(0, dataFlowAnalysisResults.ReadOutside.Count) 1753Assert.Equal(0, dataFlowAnalysisResults.VariablesDeclared.Count) 1754Assert.Equal(0, dataFlowAnalysisResults.WrittenInside.Count) 1756Assert.Equal(2, dataFlowAnalysisResults.WrittenOutside.Count) 1788Assert.Equal(0, dataFlowAnalysisResults.AlwaysAssigned.Count) 1789Assert.Equal(0, dataFlowAnalysisResults.Captured.Count) 1791Assert.Equal(1, dataFlowAnalysisResults.DataFlowsIn.Count) 1794Assert.Equal(0, dataFlowAnalysisResults.DataFlowsOut.Count) 1796Assert.Equal(1, dataFlowAnalysisResults.ReadInside.Count) 1799Assert.Equal(1, dataFlowAnalysisResults.ReadOutside.Count) 1802Assert.Equal(0, dataFlowAnalysisResults.VariablesDeclared.Count) 1803Assert.Equal(0, dataFlowAnalysisResults.WrittenInside.Count) 1805Assert.Equal(2, dataFlowAnalysisResults.WrittenOutside.Count) 1839Assert.Equal(0, dataFlowAnalysisResults.AlwaysAssigned.Count) 1840Assert.Equal(0, dataFlowAnalysisResults.Captured.Count) 1842Assert.Equal(2, dataFlowAnalysisResults.DataFlowsIn.Count) 1846Assert.Equal(0, dataFlowAnalysisResults.DataFlowsOut.Count) 1848Assert.Equal(2, dataFlowAnalysisResults.ReadInside.Count) 1852Assert.Equal(0, dataFlowAnalysisResults.ReadOutside.Count) 1853Assert.Equal(0, dataFlowAnalysisResults.VariablesDeclared.Count) 1854Assert.Equal(0, dataFlowAnalysisResults.WrittenInside.Count) 1856Assert.Equal(2, dataFlowAnalysisResults.WrittenOutside.Count) 2120Assert.Equal(0, controlflowAnalysis.EntryPoints.Count) 2121Assert.Equal(1, controlflowAnalysis.ExitPoints.Count) 2164Assert.Equal(0, controlflowAnalysis.EntryPoints.Count) 2165Assert.Equal(1, controlflowAnalysis.ExitPoints.Count) 2203Assert.Equal(2, dataFlowAnalysisResults.AlwaysAssigned.Count) 2207Assert.Equal(0, dataFlowAnalysisResults.Captured.Count) 2209Assert.Equal(1, dataFlowAnalysisResults.DataFlowsIn.Count) 2212Assert.Equal(0, dataFlowAnalysisResults.DataFlowsOut.Count) 2214Assert.Equal(3, dataFlowAnalysisResults.ReadInside.Count) 2219Assert.Equal(0, dataFlowAnalysisResults.ReadOutside.Count) 2221Assert.Equal(2, dataFlowAnalysisResults.VariablesDeclared.Count) 2225Assert.Equal(2, dataFlowAnalysisResults.WrittenInside.Count) 2229Assert.Equal(1, dataFlowAnalysisResults.WrittenOutside.Count) 2270Assert.Equal(0, dataFlowAnalysisResults.AlwaysAssigned.Count) 2271Assert.Equal(0, dataFlowAnalysisResults.Captured.Count) 2273Assert.Equal(1, dataFlowAnalysisResults.DataFlowsIn.Count) 2276Assert.Equal(0, dataFlowAnalysisResults.DataFlowsOut.Count) 2278Assert.Equal(1, dataFlowAnalysisResults.ReadInside.Count) 2281Assert.Equal(0, dataFlowAnalysisResults.ReadOutside.Count) 2283Assert.Equal(0, dataFlowAnalysisResults.VariablesDeclared.Count) 2285Assert.Equal(0, dataFlowAnalysisResults.WrittenInside.Count) 2287Assert.Equal(1, dataFlowAnalysisResults.WrittenOutside.Count) 2328Assert.Equal(0, dataFlowAnalysisResults.AlwaysAssigned.Count) 2329Assert.Equal(0, dataFlowAnalysisResults.Captured.Count) 2331Assert.Equal(1, dataFlowAnalysisResults.DataFlowsIn.Count) 2334Assert.Equal(0, dataFlowAnalysisResults.DataFlowsOut.Count) 2336Assert.Equal(1, dataFlowAnalysisResults.ReadInside.Count) 2339Assert.Equal(2, dataFlowAnalysisResults.ReadOutside.Count) 2343Assert.Equal(0, dataFlowAnalysisResults.VariablesDeclared.Count) 2345Assert.Equal(0, dataFlowAnalysisResults.WrittenInside.Count) 2347Assert.Equal(2, dataFlowAnalysisResults.WrittenOutside.Count) 2386Assert.Equal(0, dataFlowAnalysisResults.AlwaysAssigned.Count) 2387Assert.Equal(0, dataFlowAnalysisResults.Captured.Count) 2389Assert.Equal(1, dataFlowAnalysisResults.DataFlowsIn.Count) 2392Assert.Equal(0, dataFlowAnalysisResults.DataFlowsOut.Count) 2394Assert.Equal(3, dataFlowAnalysisResults.ReadInside.Count) 2399Assert.Equal(0, dataFlowAnalysisResults.ReadOutside.Count) 2401Assert.Equal(2, dataFlowAnalysisResults.VariablesDeclared.Count) 2405Assert.Equal(2, dataFlowAnalysisResults.WrittenInside.Count) 2409Assert.Equal(1, dataFlowAnalysisResults.WrittenOutside.Count)

329Assert.Equal(annotatedNodesOrTokens.Count(), actualNodesOrTokens.Count()) 331For index = 0 To actualNodesOrTokens.Count() - 1 343Assert.Equal(annotatedTrivia.Count(), actualTrivia.Count()) 345For index = 0 To actualTrivia.Count - 1 375Assert.Equal(sourceNodeOrTokens.Count(), destNodeOrTokens.Count()) 388Assert.Equal(sourceTrivia.Count(), destTrivia.Count()) 560Assert.Equal(1, results.Count()) 573Assert.Equal(1, results.Count()) 586Assert.Equal(1, results.Count())

273Debug.Assert(diagnostics.Length == CompilationWithAnalyzers.GetEffectiveDiagnostics(diagnostics, compilation).Count());

1973if (elements.Count() <= 1) 2001if (elementNames.Count() != elementTypes.Count())

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

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

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

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

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

42Debug.Assert(locations.Distinct().Count() == locations.Length, "Locations should be unique");

143namespaceSymbol = members.Count() == 1

708var count = data.First().Count(); 709Debug.Assert(data.All(d => d.Count() == count));

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

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

654if (documentFileNamesAdded.Count() > 0)

509if (projectsForOutputPath.Count() == 1) 650for (var i = 0; i < referenceInfo.ConvertedProjectReferences.Count(); i++) 700if (projectUpdateState.ProjectsByOutputPath.TryGetValue(path, out var ids) && ids.Distinct().Count() == 1)

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

708var count = data.First().Count(); 709Debug.Assert(data.All(d => d.Count() == count));

2304Assert.Equal(2, workspace.CurrentSolution.Projects.Count()); 2334Assert.Equal(2, workspace.CurrentSolution.Projects.Count()); 2522Assert.InRange(project.ProjectReferences.Count(), 0, 1);

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

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

145Assert.True(csharpResult.Count() > 0); 148Assert.True(vbResult.Count() > 0); 708Assert.Equal(1, foundDeclarations.Count());

32var actualResultCount = declarations.Count(); 49var actualResultCount = declarations.Count();

108Assert.Equal(3, result[0].Locations.Count()); // 3 locations found 135Assert.Equal(1, typeSymbol.Locations.Count()); 189Assert.Equal(expected: 2, actual: references.ElementAt(0).Locations.Count()); 194Assert.Equal(expected: 2, actual: references.ElementAt(0).Locations.Count()); 226Assert.Equal(expected: 0, actual: references.ElementAt(0).Locations.Count()); 293Assert.Equal(2, references.ElementAt(0).Locations.Count()); 298Assert.Equal(2, references.ElementAt(0).Locations.Count()); 447Assert.Equal(5, references.Count()); 489Assert.Equal(2, refsFromVirtual.Count()); 493Assert.Equal(2, refsFromOverride.Count()); 551Assert.Equal(1, typeResult.Locations.Count()); 552Assert.Equal(1, constructorResult.Locations.Count()); 584Assert.Equal(1, typeResult.Locations.Count()); 585Assert.Equal(1, constructorResult.Locations.Count()); 626Assert.Equal(2, typeResult.Locations.Count()); 627Assert.Equal(1, constructorResult.Locations.Count());

2559Assert.Equal(2, solution.GetProjectsByName("name").Count()); 3084Assert.Equal(2, sol.Projects.Count()); 3092Assert.Equal(1, sol2.Projects.Count()); 3110Assert.Equal(2, sol.Projects.Count()); 3117Assert.Equal(1, sol2.Projects.Count()); 3124Assert.Equal(2, sol3.Projects.Count()); 3485Assert.Equal(1, compilation.SyntaxTrees.Count()); 4297Assert.Equal(2, frozenDocument.Project.Documents.Count()); 4325Assert.Equal(2, frozenDocument.Project.Documents.Count()); 4614Assert.Equal(documentIds.Count(), syntaxTrees.Count());

333Assert.Equal(5, symbols.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());

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

28Assert.Equal(columnResult.Length, verify.Count()); 41Assert.Equal(columnResult.Length, verify.Count()); 54Assert.Equal(columnResult.Length, verify.Count()); 67Assert.Equal(columnResult.Length, verify.Count()); 80Assert.Equal(columnResult.Length, verify.Count()); 93Assert.Equal(columnResult.Length, verify.Count()); 106Assert.Equal(columnResult.Length, verify.Count()); 119Assert.Equal(columnResult.Length, verify.Count()); 132Assert.Equal(columnResult.Length, verify.Count()); 145Assert.Equal(columnResult.Length, verify.Count()); 158Assert.Equal(columnResult.Length, verify.Count()); 170Assert.Equal(columnResult.Length, verify.Count()); 182Assert.Equal(columnResult.Length, verify.Count()); 194Assert.Equal(columnResult.Length, verify.Count()); 206Assert.Equal(columnResult.Length, verify.Count()); 218Assert.Equal(columnResult.Length, verify.Count()); 230Assert.Equal(columnResult.Length, verify.Count()); 242Assert.Equal(columnResult.Length, verify.Count()); 254Assert.Equal(columnResult.Length, verify.Count()); 266Assert.Equal(columnResult.Length, verify.Count()); 278Assert.Equal(columnResult.Length, verify.Count()); 290Assert.Equal(columnResult.Length, verify.Count()); 302Assert.Equal(columnResult.Length, verify.Count()); 314Assert.Equal(columnResult.Length, verify.Count()); 326Assert.Equal(columnResult.Length, verify.Count()); 338Assert.Equal(columnResult.Length, verify.Count()); 350Assert.Equal(columnResult.Length, verify.Count()); 362Assert.Equal(columnResult.Length, verify.Count()); 374Assert.Equal(columnResult.Length, verify.Count()); 386Assert.Equal(columnResult.Length, verify.Count()); 398Assert.Equal(columnResult.Length, verify.Count()); 410Assert.Equal(columnResult.Length, verify.Count()); 422Assert.Equal(columnResult.Length, verify.Count()); 435Assert.Equal(columnResult.Length, verify.Count()); 448Assert.Equal(columnResult.Length, verify.Count()); 461Assert.Equal(columnResult.Length, verify.Count()); 474Assert.Equal(columnResult.Length, verify.Count()); 487Assert.Equal(columnResult.Length, verify.Count()); 500Assert.Equal(columnResult.Length, verify.Count()); 513Assert.Equal(columnResult.Length, verify.Count()); 526Assert.Equal(columnResult.Length, verify.Count()); 539Assert.Equal(columnResult.Length, verify.Count()); 552Assert.Equal(columnResult.Length, verify.Count()); 565Assert.Equal(columnResult.Length, verify.Count()); 577Assert.Equal(columnResult.Length, verify.Count()); 589Assert.Equal(columnResult.Length, verify.Count()); 601Assert.Equal(columnResult.Length, verify.Count()); 613Assert.Equal(columnResult.Length, verify.Count()); 625Assert.Equal(columnResult.Length, verify.Count()); 637Assert.Equal(columnResult.Length, verify.Count()); 649Assert.Equal(columnResult.Length, verify.Count()); 661Assert.Equal(columnResult.Length, verify.Count()); 673Assert.Equal(columnResult.Length, verify.Count()); 685Assert.Equal(columnResult.Length, verify.Count()); 697Assert.Equal(columnResult.Length, verify.Count()); 709Assert.Equal(columnResult.Length, verify.Count()); 721Assert.Equal(columnResult.Length, verify.Count()); 733Assert.Equal(columnResult.Length, verify.Count()); 745Assert.Equal(columnResult.Length, verify.Count()); 757Assert.Equal(columnResult.Length, verify.Count()); 769Assert.Equal(columnResult.Length, verify.Count()); 781Assert.Equal(columnResult.Length, verify.Count()); 793Assert.Equal(columnResult.Length, verify.Count()); 805Assert.Equal(columnResult.Length, verify.Count()); 817Assert.Equal(columnResult.Length, verify.Count()); 829Assert.Equal(columnResult.Length, verify.Count()); 842Assert.Equal(columnResult.Length, verify.Count()); 855Assert.Equal(columnResult.Length, verify.Count()); 868Assert.Equal(columnResult.Length, verify.Count()); 881Assert.Equal(columnResult.Length, verify.Count()); 894Assert.Equal(columnResult.Length, verify.Count()); 907Assert.Equal(columnResult.Length, verify.Count()); 920Assert.Equal(columnResult.Length, verify.Count()); 933Assert.Equal(columnResult.Length, verify.Count()); 946Assert.Equal(columnResult.Length, verify.Count()); 959Assert.Equal(columnResult.Length, verify.Count()); 972Assert.Equal(columnResult.Length, verify.Count()); 984Assert.Equal(columnResult.Length, verify.Count()); 996Assert.Equal(columnResult.Length, verify.Count()); 1008Assert.Equal(columnResult.Length, verify.Count()); 1020Assert.Equal(columnResult.Length, verify.Count()); 1032Assert.Equal(columnResult.Length, verify.Count()); 1044Assert.Equal(columnResult.Length, verify.Count()); 1056Assert.Equal(columnResult.Length, verify.Count()); 1068Assert.Equal(columnResult.Length, verify.Count()); 1080Assert.Equal(columnResult.Length, verify.Count()); 1092Assert.Equal(columnResult.Length, verify.Count()); 1104Assert.Equal(columnResult.Length, verify.Count()); 1116Assert.Equal(columnResult.Length, verify.Count()); 1128Assert.Equal(columnResult.Length, verify.Count()); 1140Assert.Equal(columnResult.Length, verify.Count()); 1152Assert.Equal(columnResult.Length, verify.Count()); 1164Assert.Equal(columnResult.Length, verify.Count()); 1176Assert.Equal(columnResult.Length, verify.Count()); 1188Assert.Equal(columnResult.Length, verify.Count()); 1200Assert.Equal(columnResult.Length, verify.Count()); 1212Assert.Equal(columnResult.Length, verify.Count()); 1224Assert.Equal(columnResult.Length, verify.Count()); 1236Assert.Equal(columnResult.Length, verify.Count()); 1249Assert.Equal(columnResult.Length, verify.Count()); 1262Assert.Equal(columnResult.Length, verify.Count()); 1275Assert.Equal(columnResult.Length, verify.Count()); 1288Assert.Equal(columnResult.Length, verify.Count()); 1301Assert.Equal(columnResult.Length, verify.Count()); 1314Assert.Equal(columnResult.Length, verify.Count()); 1327Assert.Equal(columnResult.Length, verify.Count()); 1340Assert.Equal(columnResult.Length, verify.Count()); 1353Assert.Equal(columnResult.Length, verify.Count()); 1366Assert.Equal(columnResult.Length, verify.Count()); 1379Assert.Equal(columnResult.Length, verify.Count()); 1391Assert.Equal(columnResult.Length, verify.Count()); 1403Assert.Equal(columnResult.Length, verify.Count()); 1415Assert.Equal(columnResult.Length, verify.Count()); 1427Assert.Equal(columnResult.Length, verify.Count()); 1439Assert.Equal(columnResult.Length, verify.Count()); 1451Assert.Equal(columnResult.Length, verify.Count()); 1463Assert.Equal(columnResult.Length, verify.Count()); 1475Assert.Equal(columnResult.Length, verify.Count()); 1487Assert.Equal(columnResult.Length, verify.Count()); 1499Assert.Equal(columnResult.Length, verify.Count()); 1511Assert.Equal(columnResult.Length, verify.Count()); 1523Assert.Equal(columnResult.Length, verify.Count()); 1535Assert.Equal(columnResult.Length, verify.Count()); 1547Assert.Equal(columnResult.Length, verify.Count()); 1559Assert.Equal(columnResult.Length, verify.Count()); 1571Assert.Equal(columnResult.Length, verify.Count()); 1583Assert.Equal(columnResult.Length, verify.Count()); 1595Assert.Equal(columnResult.Length, verify.Count()); 1607Assert.Equal(columnResult.Length, verify.Count()); 1619Assert.Equal(columnResult.Length, verify.Count()); 1631Assert.Equal(columnResult.Length, verify.Count()); 1643Assert.Equal(columnResult.Length, verify.Count()); 1656Assert.Equal(columnResult.Length, verify.Count()); 1669Assert.Equal(columnResult.Length, verify.Count()); 1682Assert.Equal(columnResult.Length, verify.Count()); 1695Assert.Equal(columnResult.Length, verify.Count()); 1708Assert.Equal(columnResult.Length, verify.Count()); 1721Assert.Equal(columnResult.Length, verify.Count()); 1734Assert.Equal(columnResult.Length, verify.Count()); 1747Assert.Equal(columnResult.Length, verify.Count()); 1760Assert.Equal(columnResult.Length, verify.Count()); 1773Assert.Equal(columnResult.Length, verify.Count()); 1786Assert.Equal(columnResult.Length, verify.Count()); 1798Assert.Equal(columnResult.Length, verify.Count()); 1810Assert.Equal(columnResult.Length, verify.Count()); 1822Assert.Equal(columnResult.Length, verify.Count()); 1834Assert.Equal(columnResult.Length, verify.Count()); 1846Assert.Equal(columnResult.Length, verify.Count()); 1858Assert.Equal(columnResult.Length, verify.Count()); 1870Assert.Equal(columnResult.Length, verify.Count()); 1882Assert.Equal(columnResult.Length, verify.Count()); 1894Assert.Equal(columnResult.Length, verify.Count()); 1906Assert.Equal(columnResult.Length, verify.Count()); 1918Assert.Equal(columnResult.Length, verify.Count()); 1930Assert.Equal(columnResult.Length, verify.Count()); 1942Assert.Equal(columnResult.Length, verify.Count()); 1954Assert.Equal(columnResult.Length, verify.Count()); 1966Assert.Equal(columnResult.Length, verify.Count()); 1978Assert.Equal(columnResult.Length, verify.Count()); 1990Assert.Equal(columnResult.Length, verify.Count()); 2002Assert.Equal(columnResult.Length, verify.Count()); 2014Assert.Equal(columnResult.Length, verify.Count()); 2026Assert.Equal(columnResult.Length, verify.Count()); 2038Assert.Equal(columnResult.Length, verify.Count()); 2050Assert.Equal(columnResult.Length, verify.Count()); 2063Assert.Equal(columnResult.Length, verify.Count()); 2078Assert.Equal(columnResult.Length, verify.Count()); 2093Assert.Equal(columnResult.Length, verify.Count()); 2108Assert.Equal(columnResult.Length, verify.Count()); 2123Assert.Equal(columnResult.Length, verify.Count()); 2138Assert.Equal(columnResult.Length, verify.Count()); 2153Assert.Equal(columnResult.Length, verify.Count()); 2168Assert.Equal(columnResult.Length, verify.Count()); 2183Assert.Equal(columnResult.Length, verify.Count()); 2198Assert.Equal(columnResult.Length, verify.Count()); 2213Assert.Equal(columnResult.Length, verify.Count()); 2227Assert.Equal(columnResult.Length, verify.Count()); 2239Assert.Equal(columnResult.Length, verify.Count()); 2251Assert.Equal(columnResult.Length, verify.Count()); 2263Assert.Equal(columnResult.Length, verify.Count()); 2275Assert.Equal(columnResult.Length, verify.Count()); 2287Assert.Equal(columnResult.Length, verify.Count()); 2299Assert.Equal(columnResult.Length, verify.Count()); 2311Assert.Equal(columnResult.Length, verify.Count()); 2323Assert.Equal(columnResult.Length, verify.Count()); 2335Assert.Equal(columnResult.Length, verify.Count()); 2347Assert.Equal(columnResult.Length, verify.Count()); 2360Assert.Equal(columnResult.Length, verify.Count()); 2375Assert.Equal(columnResult.Length, verify.Count()); 2390Assert.Equal(columnResult.Length, verify.Count()); 2405Assert.Equal(columnResult.Length, verify.Count()); 2420Assert.Equal(columnResult.Length, verify.Count()); 2435Assert.Equal(columnResult.Length, verify.Count()); 2450Assert.Equal(columnResult.Length, verify.Count()); 2465Assert.Equal(columnResult.Length, verify.Count()); 2480Assert.Equal(columnResult.Length, verify.Count()); 2495Assert.Equal(columnResult.Length, verify.Count()); 2510Assert.Equal(columnResult.Length, verify.Count()); 2524Assert.Equal(columnResult.Length, verify.Count()); 2536Assert.Equal(columnResult.Length, verify.Count()); 2548Assert.Equal(columnResult.Length, verify.Count()); 2560Assert.Equal(columnResult.Length, verify.Count()); 2572Assert.Equal(columnResult.Length, verify.Count()); 2584Assert.Equal(columnResult.Length, verify.Count()); 2596Assert.Equal(columnResult.Length, verify.Count()); 2608Assert.Equal(columnResult.Length, verify.Count()); 2620Assert.Equal(columnResult.Length, verify.Count()); 2632Assert.Equal(columnResult.Length, verify.Count()); 2644Assert.Equal(columnResult.Length, verify.Count());

26Assert.Equal(2, grouping.Count()); 31Assert.Equal(length / 2, oddGroup.Count()); 35Assert.Equal(length / 2 + length % 2, evenGroup.Count()); 73Assert.Equal(10, groupings[i].Count()); 88Assert.Equal(length % 10, groupings[length / 10].Count());

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

539int looseFileCount = Directory.EnumerateFiles(looseSymbolFilesDirectory, "*", SearchOption.AllDirectories).Count();

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

414if (expectedItems.Count() != actualItems.Count()) 416Output.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)

59if (group.Count() == 1)

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

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

124return (doNotSignExclusions.Count() > 0) && (IsExcluded(path, parent, virtualPath, containerPath, doNotSignExclusions));

25return _errors.Count() > 0;

145if (signatureFilesFailedVerifyDigestManifest.Count() > 0)

106if (ManifestHashDigestAttributes.Count() > 0)

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

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

224repackCount = repackList.Count();

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

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

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

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

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

32if (UsedInfos.Count() > 1)

195.Select(g => $"{g.Count()}{g.Key}")

278if (remainingSemaphores.Length == joinGroup.ParallelSemaphorePaths.Count())

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

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

55var conflicts = extensionToCertMapping.Where(kv => kv.Value.Count() > 1); 57if (conflicts.Count() > 0) 113var conflicts = keyToCertMapping.Where(kv => kv.Value.Count() > 1); 115if (conflicts.Count() > 0) 171var conflicts = extensionToCertMapping.Where(kv => kv.Value.Count() > 1); 173if (conflicts.Count() > 0) 218var conflicts = pktMapping.Where(kv => kv.Value.Count() > 1); 220if (conflicts.Count() > 0)

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

53int allSubmoduleInfoCount = dependencyInfos.OfType<SubmoduleDependencyInfo>().Count();

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

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

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

25if (ctorArgs.Count() < 2)

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

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

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

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

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)

1205Contracts.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)

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

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)

829if (tree.GetCategoricalSplitFeaturesAt(nodeId).Count() > 0) 833if (tree.GetCategoricalCategoricalSplitFeatureRangeAt(nodeId).Count() > 0) 858if (tree.GetLeafSamplesAt(nodeId).Count() > 0) 862if (tree.GetLeafSampleWeightsAt(nodeId).Count() > 0) 881for (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);

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,

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

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

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

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

595var hashAttributeCount = hashAttributes.Count();

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

74ConsoleUtil.WriteLine($"Found {orderedTypeInfos.Values.SelectMany(t => t).SelectMany(t => t.Tests).Count()} tests to run in {orderedTypeInfos.Keys.Count()} assemblies"); 178ConsoleUtil.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}.");

111schemas.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; 279return !onlyIfCheap || _source is ICollection<TSource> ? _source.Count() + _appendCount + _prependCount : -1;

23firstCount = _first.Count(); 33secondCount = _second.Count(); 174int 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();

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

595var hashAttributeCount = hashAttributes.Count();

595var hashAttributeCount = hashAttributes.Count();