All

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\SymbolUsageAnalysis\SymbolUsageAnalysis.DataFlowAnalyzer.FlowGraphAnalysisData.cs (1)

101Debug.Assert(LValueFlowCapturesInGraph.Values.All(kind => kind is FlowCaptureKind.LValueCapture or FlowCaptureKind.LValueAndRValueCapture));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AbstractSpeculationAnalyzer.cs (1)

483methodSymbol.Parameters.Zip(newMethodSymbol.Parameters, (p1, p2) => (p1, p2)).All(

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\EnumValueUtilities.cs (1)

119existingConstants.All(GreaterThanOrEqualsZero))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\PathMetadataUtilities.cs (1)

32!rootNamespace.Split(NamespaceSeparatorArray).All(syntaxFacts.IsValidIdentifier))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\INamedTypeSymbolExtensions.cs (2)

350if (!interfacesOrAbstractClasses.All(i => i.TypeKind == TypeKind.Interface) && 351!interfacesOrAbstractClasses.All(i => i.IsAbstractClass()))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ISymbolExtensions.cs (1)

795(symbol.Name.Length == 1 || uint.TryParse(symbol.Name[1..], out _) || symbol.Name.All(n => n.Equals('_')));

Identity.ExternalClaims (1)

Pages\Account\Manage\ExternalLogins.cshtml.cs (1)

48.Where(auth => CurrentLogins.All(ul => auth.Name != ul.LoginProvider))

IdentitySample.Mvc (1)

Controllers\ManageController.cs (1)

308var otherLogins = schemes.Where(auth => userLogins.All(ul => auth.Name != ul.LoginProvider)).ToList();

illink (3)

Linker.Steps\MarkStep.cs (1)

2543if (ifaces.All(Annotations.IsMarked))

Linker.Steps\SweepStep.cs (1)

391if (!provider.HasCustomAttributes || provider.CustomAttributes.All(attr =>

Linker\TypeMapInfo.cs (1)

146Debug.Assert(firstImplementationChain.All(kvp => context.Resolve(kvp.Item1) == context.Resolve(kvp.Item2.Last().InterfaceType)));

installer.tasks (1)

StaticFileRegeneration\TpnSectionHeader.cs (1)

18return line.Length > 2 && line.All(c => SectionSeparatorChars.Contains(c));

Metrics (10)

src\Dependencies\Collections\Extensions\IEnumerableExtensions.cs (1)

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

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\ComputationalComplexityMetrics.cs (1)

329return !operation.DescendantsAndSelf().All(o => o.IsImplicit || (!o.ConstantValue.HasValue && o.Type == null && o.Kind is not (OperationKind.Branch or OperationKind.Attribute)));

src\RoslynAnalyzers\Utilities\Compiler\Extensions\IDictionaryExtensions.cs (1)

15dictionary.Keys.All(key => other.ContainsKey(key) && dictionary[key]?.Equals(other[key]) == true);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\SymbolUsageAnalysis\SymbolUsageAnalysis.DataFlowAnalyzer.FlowGraphAnalysisData.cs (1)

101Debug.Assert(LValueFlowCapturesInGraph.Values.All(kind => kind is FlowCaptureKind.LValueCapture or FlowCaptureKind.LValueAndRValueCapture));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AbstractSpeculationAnalyzer.cs (1)

483methodSymbol.Parameters.Zip(newMethodSymbol.Parameters, (p1, p2) => (p1, p2)).All(

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\EnumValueUtilities.cs (1)

119existingConstants.All(GreaterThanOrEqualsZero))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\PathMetadataUtilities.cs (1)

32!rootNamespace.Split(NamespaceSeparatorArray).All(syntaxFacts.IsValidIdentifier))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\INamedTypeSymbolExtensions.cs (2)

350if (!interfacesOrAbstractClasses.All(i => i.TypeKind == TypeKind.Interface) && 351!interfacesOrAbstractClasses.All(i => i.IsAbstractClass()))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ISymbolExtensions.cs (1)

795(symbol.Name.Length == 1 || uint.TryParse(symbol.Name[1..], out _) || symbol.Name.All(n => n.Equals('_')));

Metrics.Legacy (10)

src\Dependencies\Collections\Extensions\IEnumerableExtensions.cs (1)

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

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\ComputationalComplexityMetrics.cs (1)

329return !operation.DescendantsAndSelf().All(o => o.IsImplicit || (!o.ConstantValue.HasValue && o.Type == null && o.Kind is not (OperationKind.Branch or OperationKind.Attribute)));

src\RoslynAnalyzers\Utilities\Compiler\Extensions\IDictionaryExtensions.cs (1)

15dictionary.Keys.All(key => other.ContainsKey(key) && dictionary[key]?.Equals(other[key]) == true);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\SymbolUsageAnalysis\SymbolUsageAnalysis.DataFlowAnalyzer.FlowGraphAnalysisData.cs (1)

101Debug.Assert(LValueFlowCapturesInGraph.Values.All(kind => kind is FlowCaptureKind.LValueCapture or FlowCaptureKind.LValueAndRValueCapture));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AbstractSpeculationAnalyzer.cs (1)

483methodSymbol.Parameters.Zip(newMethodSymbol.Parameters, (p1, p2) => (p1, p2)).All(

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\EnumValueUtilities.cs (1)

119existingConstants.All(GreaterThanOrEqualsZero))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\PathMetadataUtilities.cs (1)

32!rootNamespace.Split(NamespaceSeparatorArray).All(syntaxFacts.IsValidIdentifier))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\INamedTypeSymbolExtensions.cs (2)

350if (!interfacesOrAbstractClasses.All(i => i.TypeKind == TypeKind.Interface) && 351!interfacesOrAbstractClasses.All(i => i.IsAbstractClass()))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ISymbolExtensions.cs (1)

795(symbol.Name.Length == 1 || uint.TryParse(symbol.Name[1..], out _) || symbol.Name.All(n => n.Equals('_')));

Microsoft.Arcade.Test.Common (1)

AssertEx.cs (1)

283var all = actual.All(predicate);

Microsoft.AspNetCore.App.Analyzers (1)

Authorization\AddAuthorizationBuilderAnalyzer.cs (1)

78.All(operation => DoesOperationInvolveAuthorizationOptions(operation, authorizationOptionsTypes));

Microsoft.AspNetCore.DataProtection (2)

Repositories\FileSystemXmlRepository.cs (1)

99return (!String.IsNullOrEmpty(filename) && filename.All(c =>

Repositories\RegistryXmlRepository.cs (1)

119return (!String.IsNullOrEmpty(filename) && filename.All(c =>

Microsoft.AspNetCore.HostFiltering.Tests (3)

MiddlewareConfigurationManagerTests.cs (3)

41Assert.True(options.AllowedHosts.All(x => configurationBeforeChange.AllowedHosts.Contains(x))); 64Assert.True(newOption.AllowedHosts.All(x => configurationAfterChange.AllowedHosts.Contains(x))); 88Assert.True(options.AllowedHosts.All(x => result1.AllowedHosts.Contains(x)) && options.AllowedHosts.Count.Equals(result1.AllowedHosts.Count));

Microsoft.AspNetCore.Hosting.Tests (10)

WebHostTests.cs (10)

446Assert.True(started.All(s => s)); 447Assert.True(started2.All(s => s)); 449Assert.True(stopping.All(s => s)); 450Assert.True(stopping2.All(s => s)); 451Assert.True(stopped.All(s => s)); 452Assert.True(stopped2.All(s => s)); 694Assert.False(started.All(s => s)); // Server doesn't start if hosted services throw 695Assert.False(started2.All(s => s)); 699Assert.True(stopping.All(s => s)); 700Assert.True(stopping2.All(s => s));

Microsoft.AspNetCore.Http.RequestDelegateGenerator (1)

StaticRouteHandlerModel\Endpoint.cs (1)

89EmitterContext.RequiresLoggingHelper = !Parameters.All(parameter =>

Microsoft.AspNetCore.Identity.UI (2)

Areas\Identity\Pages\V4\Account\Manage\ExternalLogins.cshtml.cs (1)

94.Where(auth => CurrentLogins.All(ul => auth.Name != ul.LoginProvider))

Areas\Identity\Pages\V5\Account\Manage\ExternalLogins.cshtml.cs (1)

94.Where(auth => CurrentLogins.All(ul => auth.Name != ul.LoginProvider))

Microsoft.AspNetCore.Mvc.Core (1)

ModelBinding\Metadata\HasValidatorsValidationMetadataProvider.cs (1)

18if (modelValidatorProviders.Count > 0 && modelValidatorProviders.All(p => p is IMetadataBasedModelValidatorProvider))

Microsoft.AspNetCore.OpenApi (1)

Services\OpenApiDocumentService.cs (1)

564if (parameter.All(parameter => parameter.ModelMetadata.ContainerType is null))

Microsoft.AspNetCore.Routing (1)

Matching\ILEmitTrieFactory.cs (1)

273if (entries.All(e => IsUInt64KeyAsciiLettersOnly(e.text, index)))

Microsoft.AspNetCore.Server.HttpSys.FunctionalTests (1)

ResponseBodyTests.cs (1)

160Assert.True(bytes.All(b => b == 0));

Microsoft.Build (13)

BackEnd\BuildManager\BuildManager.cs (2)

2090.Where(node => node.ProjectReferences.All(projectReference => finishedNodes.Contains(projectReference))) 2522catch (AggregateException ex) when (ex.InnerExceptions.All(inner => inner is OperationCanceledException))

BackEnd\Components\Logging\LoggingService.cs (1)

598bool allSinksIncludeEvalData = sinks.Any() && sinks.All(sink => sink.IncludeEvaluationPropertiesAndItems);

BackEnd\Components\RequestBuilder\IntrinsicTasks\ItemGroupIntrinsicTask.cs (1)

654itemSpec.Fragments.All(f => f is ItemSpec<ProjectPropertyInstance, ProjectItemInstance>.ItemExpressionFragment),

BackEnd\Components\RequestBuilder\RequestBuilder.cs (1)

316return e.Flatten().InnerExceptions.All(ex => ex is TaskCanceledException || ex is OperationCanceledException);

BackEnd\Shared\BuildRequestConfiguration.cs (1)

838if (items.Count == 0 || items.All(i => string.IsNullOrWhiteSpace(i.EvaluatedInclude)))

BuildCheck\Infrastructure\BuildCheckCentralContext.cs (1)

237if (configPerRule.All(c => !c.IsEnabled))

BuildCheck\Infrastructure\BuildCheckManagerProvider.cs (1)

260if (userEditorConfigs.All(c => !(c.IsEnabled ?? checkFactoryContext.IsEnabledByDefault)))

BuildCheck\Infrastructure\CheckWrapper.cs (1)

114if (CommonConfig == null || !effectiveConfigs.All(t => t.IsSameConfigurationAs(CommonConfig)))

Construction\ProjectElementContainer.cs (1)

628if (XmlElement.ChildNodes.Cast<XmlNode>().All(c => c.NodeType == XmlNodeType.Whitespace))

Evaluation\LazyItemEvaluator.RemoveOperation.cs (1)

28_matchOnMetadata.IsEmpty || _itemSpec.Fragments.All(f => f is ItemSpec<P, I>.ItemExpressionFragment),

FileMatcher.cs (2)

2611if (ex.Flatten().InnerExceptions.All(ExceptionHandling.IsIoRelatedException)) 2644return ex.Flatten().InnerExceptions.All(ExceptionHandling.IsIoRelatedException);

Microsoft.Build.Engine.UnitTests (5)

BackEnd\BuildManager_Tests.cs (1)

3966Assert.True(_logger.AllBuildEvents.OfType<ProjectEvaluationStartedEventArgs>().GroupBy(args => args.BuildEventContext.EvaluationId).All(g => g.Count() == 1));

Evaluation\Expander_Tests.cs (1)

4027intermediate.Trim('=').All(c => char.IsLetterOrDigit(c) || c == '+' || c == '/').ShouldBeTrue();

EvaluationProfiler_Tests.cs (2)

224.All(e => e.ParentId == totalEvaluation.Id)); 258Assert.True(profiledElements.All(e => e.ParentId == null || allUniqueIds.Contains(e.ParentId.Value)));

Graph\GraphLoadedFromSolution_tests.cs (1)

695if (projectConfigurations == null || graphFromSolution.ProjectNodes.All(n => n.ProjectReferences.Count == 0))

Microsoft.Build.Framework (1)

Sdk\SdkResultItem.cs (1)

45return Metadata.All(m => item.Metadata.TryGetValue(m.Key, out var itemValue) && itemValue == m.Value);

Microsoft.Build.Tasks.Core (5)

FileMatcher.cs (2)

2611if (ex.Flatten().InnerExceptions.All(ExceptionHandling.IsIoRelatedException)) 2644return ex.Flatten().InnerExceptions.All(ExceptionHandling.IsIoRelatedException);

ManifestUtil\PathUtil.cs (1)

246str.All(c => c <= 127);

Unzip.cs (1)

289result = _includePatterns.All(pattern => !FileMatcher.IsMatch(FileMatcher.Normalize(zipArchiveEntry.FullName), pattern));

WriteCodeFragment.cs (1)

504var allStringParameters = candidates.FirstOrDefault(c => c.All(t => t == typeof(string)));

Microsoft.Build.Utilities.Core (2)

FileMatcher.cs (2)

2611if (ex.Flatten().InnerExceptions.All(ExceptionHandling.IsIoRelatedException)) 2644return ex.Flatten().InnerExceptions.All(ExceptionHandling.IsIoRelatedException);

Microsoft.Cci.Extensions (5)

Filters\IntersectionFilter.cs (4)

36return Filters.All(filter => filter.Include(member)); 41return Filters.All(filter => filter.Include(attribute)); 46return Filters.All(filter => filter.Include(type)); 51return Filters.All(filter => filter.Include(ns));

Filters\NotImplementedFilter.cs (1)

24var hasOnlyExcludedMembers = type.Members.Any() && type.Members.All(m => !Include(m));

Microsoft.CodeAnalysis (7)

CodeGen\LocalScopeManager.cs (1)

777Debug.Assert(_handlers.All(h => (h.LeaderBlock.Reachability == reachability)));

Emit\EditAndContinue\EmitBaseline.cs (1)

422Debug.Assert(customAttributesAdded.All(entry => !entry.Value.IsDefaultOrEmpty && entry.Value.IsSorted()));

PEWriter\TypeNameSerializer.cs (1)

215Debug.Assert(needsEscaping.All(c => !fileIdentifier.Contains(c)));

src\Dependencies\Collections\Extensions\IEnumerableExtensions.cs (1)

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

Text\CompositeText.cs (1)

533Debug.Assert(resultLine.ToString().All(static c => !TextUtilities.IsAnyLineBreakCharacter(c)));

Text\SubText.cs (1)

192Debug.Assert(resultLine.ToString().All(static c => !TextUtilities.IsAnyLineBreakCharacter(c)));

TreeDumper.cs (1)

145if (node.Children.All(child => child == null))

Microsoft.CodeAnalysis.Analyzers (14)

FixAnalyzers\FixerWithFixAllAnalyzer.cs (1)

306return objectCreation.Constructor != null && objectCreation.Constructor.ContainingType.GetBaseTypesAndThis().All(namedType => !IsCodeActionWithOverriddenEquivalenceKey(namedType));

MetaAnalyzers\DiagnosticDescriptorCreationAnalyzer.cs (1)

1306if (!ruleId[2..].All(char.IsDigit))

MetaAnalyzers\DiagnosticDescriptorCreationAnalyzer_IdRangeAndCategoryValidation.cs (1)

293else if (range.All(char.IsLetter))

MetaAnalyzers\Fixers\CompareSymbolsCorrectlyFix.cs (1)

183=> c1.Zip(c2, (x, y) => x.ParameterTypesAreSame(y)).All(x => x);

src\Dependencies\Collections\Extensions\IEnumerableExtensions.cs (1)

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

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\ComputationalComplexityMetrics.cs (1)

329return !operation.DescendantsAndSelf().All(o => o.IsImplicit || (!o.ConstantValue.HasValue && o.Type == null && o.Kind is not (OperationKind.Branch or OperationKind.Attribute)));

src\RoslynAnalyzers\Utilities\Compiler\Extensions\IDictionaryExtensions.cs (1)

15dictionary.Keys.All(key => other.ContainsKey(key) && dictionary[key]?.Equals(other[key]) == true);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\SymbolUsageAnalysis\SymbolUsageAnalysis.DataFlowAnalyzer.FlowGraphAnalysisData.cs (1)

101Debug.Assert(LValueFlowCapturesInGraph.Values.All(kind => kind is FlowCaptureKind.LValueCapture or FlowCaptureKind.LValueAndRValueCapture));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AbstractSpeculationAnalyzer.cs (1)

483methodSymbol.Parameters.Zip(newMethodSymbol.Parameters, (p1, p2) => (p1, p2)).All(

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\EnumValueUtilities.cs (1)

119existingConstants.All(GreaterThanOrEqualsZero))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\PathMetadataUtilities.cs (1)

32!rootNamespace.Split(NamespaceSeparatorArray).All(syntaxFacts.IsValidIdentifier))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\INamedTypeSymbolExtensions.cs (2)

350if (!interfacesOrAbstractClasses.All(i => i.TypeKind == TypeKind.Interface) && 351!interfacesOrAbstractClasses.All(i => i.IsAbstractClass()))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ISymbolExtensions.cs (1)

795(symbol.Name.Length == 1 || uint.TryParse(symbol.Name[1..], out _) || symbol.Name.All(n => n.Equals('_')));

Microsoft.CodeAnalysis.AnalyzerUtilities (25)

src\Dependencies\Collections\Extensions\IEnumerableExtensions.cs (1)

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

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\ComputationalComplexityMetrics.cs (1)

329return !operation.DescendantsAndSelf().All(o => o.IsImplicit || (!o.ConstantValue.HasValue && o.Type == null && o.Kind is not (OperationKind.Branch or OperationKind.Attribute)));

src\RoslynAnalyzers\Utilities\Compiler\Extensions\IDictionaryExtensions.cs (1)

15dictionary.Keys.All(key => other.ContainsKey(key) && dictionary[key]?.Equals(other[key]) == true);

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\CopyAnalysis\CopyAbstractValue.cs (2)

25Debug.Assert(kind != CopyAbstractValueKind.KnownReferenceCopy || analysisEntities.All(a => !a.Type.IsValueType)); 68Debug.Assert(entitiesToRemove.All(AnalysisEntities.Contains));

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\CopyAnalysis\CopyAnalysis.CopyDataFlowOperationVisitor.cs (1)

546Debug.Assert(predicate == null || copyValue.AnalysisEntities.All(predicate));

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\CopyAnalysis\CopyAnalysisData.cs (1)

180Debug.Assert(predicatedData.All(kvp => kvp.Value.AnalysisEntities.IsSubsetOf(coreAnalysisData[kvp.Key].AnalysisEntities)));

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\DisposeAnalysis\DisposeAnalysis.DisposeDataFlowOperationVisitor.cs (1)

37Debug.Assert(CollectionNamedTypes.All(ct => ct.TypeKind == TypeKind.Interface));

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\GlobalFlowStateAnalysis\GlobalFlowStateAnalysisValueSet.cs (2)

34Debug.Assert(analysisValues.All(value => value != null)); 35Debug.Assert(parents.All(parent => parent != null));

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\PointsToAnalysis\PointsToAbstractValue.cs (2)

34Debug.Assert(locations.All(location => !location.IsNull) || nullState != NullAbstractValue.NotNull); 177Debug.Assert(Locations.All(location => !location.IsNull));

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\PropertySetAnalysis\PropertyMapperCollection.cs (1)

31if (!propertyMappers.All(p => p.PropertyIndex >= 0))

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Framework\DataFlow\AddressSharedEntitiesProvider.cs (1)

85Debug.Assert(builder.All(e => !e.HasUnknownInstanceLocation));

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Framework\DataFlow\DataFlowOperationVisitor.cs (3)

1310pointsToValue.Locations.All(location => location.IsNull || 1331pointsToValue.Locations.All(location => location.IsNoLocation || !location.IsNull && location.LocationType.DerivesFrom(targetType))) 2094dict1.Keys.All(key => dict2.TryGetValue(key, out TValue value2) && EqualityComparer<TValue>.Default.Equals(dict1[key], value2));

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Framework\DataFlow\PredicatedAnalysisData.cs (1)

420return dict1.Keys.All(key => dict2.TryGetValue(key, out var value2) &&

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\SymbolUsageAnalysis\SymbolUsageAnalysis.DataFlowAnalyzer.FlowGraphAnalysisData.cs (1)

101Debug.Assert(LValueFlowCapturesInGraph.Values.All(kind => kind is FlowCaptureKind.LValueCapture or FlowCaptureKind.LValueAndRValueCapture));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AbstractSpeculationAnalyzer.cs (1)

483methodSymbol.Parameters.Zip(newMethodSymbol.Parameters, (p1, p2) => (p1, p2)).All(

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\EnumValueUtilities.cs (1)

119existingConstants.All(GreaterThanOrEqualsZero))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\PathMetadataUtilities.cs (1)

32!rootNamespace.Split(NamespaceSeparatorArray).All(syntaxFacts.IsValidIdentifier))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\INamedTypeSymbolExtensions.cs (2)

350if (!interfacesOrAbstractClasses.All(i => i.TypeKind == TypeKind.Interface) && 351!interfacesOrAbstractClasses.All(i => i.IsAbstractClass()))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ISymbolExtensions.cs (1)

795(symbol.Name.Length == 1 || uint.TryParse(symbol.Name[1..], out _) || symbol.Name.All(n => n.Equals('_')));

Microsoft.CodeAnalysis.BannedApiAnalyzers (10)

src\Dependencies\Collections\Extensions\IEnumerableExtensions.cs (1)

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

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\ComputationalComplexityMetrics.cs (1)

329return !operation.DescendantsAndSelf().All(o => o.IsImplicit || (!o.ConstantValue.HasValue && o.Type == null && o.Kind is not (OperationKind.Branch or OperationKind.Attribute)));

src\RoslynAnalyzers\Utilities\Compiler\Extensions\IDictionaryExtensions.cs (1)

15dictionary.Keys.All(key => other.ContainsKey(key) && dictionary[key]?.Equals(other[key]) == true);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\SymbolUsageAnalysis\SymbolUsageAnalysis.DataFlowAnalyzer.FlowGraphAnalysisData.cs (1)

101Debug.Assert(LValueFlowCapturesInGraph.Values.All(kind => kind is FlowCaptureKind.LValueCapture or FlowCaptureKind.LValueAndRValueCapture));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AbstractSpeculationAnalyzer.cs (1)

483methodSymbol.Parameters.Zip(newMethodSymbol.Parameters, (p1, p2) => (p1, p2)).All(

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\EnumValueUtilities.cs (1)

119existingConstants.All(GreaterThanOrEqualsZero))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\PathMetadataUtilities.cs (1)

32!rootNamespace.Split(NamespaceSeparatorArray).All(syntaxFacts.IsValidIdentifier))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\INamedTypeSymbolExtensions.cs (2)

350if (!interfacesOrAbstractClasses.All(i => i.TypeKind == TypeKind.Interface) && 351!interfacesOrAbstractClasses.All(i => i.IsAbstractClass()))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ISymbolExtensions.cs (1)

795(symbol.Name.Length == 1 || uint.TryParse(symbol.Name[1..], out _) || symbol.Name.All(n => n.Equals('_')));

Microsoft.CodeAnalysis.CodeStyle (12)

src\Analyzers\Core\Analyzers\Helpers\DiagnosticHelper.cs (1)

223Contract.ThrowIfFalse(indices.All(idx => idx >= 0 && idx < additionalLocationsLength));

src\Analyzers\Core\Analyzers\IDEDiagnosticIdToOptionMappingHelper.cs (1)

88Debug.Assert(options.All(option => option.Definition.IsEditorConfigOption));

src\Analyzers\Core\Analyzers\UseAutoProperty\AbstractUseAutoPropertyAnalyzer.cs (1)

551if (!ineligibleFieldUsages.All(loc => loc.Ancestors().Contains(result.PropertyDeclaration)))

src\Analyzers\Core\Analyzers\UseCompoundAssignment\UseCompoundAssignmentUtilities.cs (1)

37Debug.Assert(binaryToAssignmentMap.Values.All(assignmentToTokenMap.ContainsKey));

src\Dependencies\Collections\Extensions\IEnumerableExtensions.cs (1)

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

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\SymbolUsageAnalysis\SymbolUsageAnalysis.DataFlowAnalyzer.FlowGraphAnalysisData.cs (1)

101Debug.Assert(LValueFlowCapturesInGraph.Values.All(kind => kind is FlowCaptureKind.LValueCapture or FlowCaptureKind.LValueAndRValueCapture));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AbstractSpeculationAnalyzer.cs (1)

483methodSymbol.Parameters.Zip(newMethodSymbol.Parameters, (p1, p2) => (p1, p2)).All(

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\EnumValueUtilities.cs (1)

119existingConstants.All(GreaterThanOrEqualsZero))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\PathMetadataUtilities.cs (1)

32!rootNamespace.Split(NamespaceSeparatorArray).All(syntaxFacts.IsValidIdentifier))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\INamedTypeSymbolExtensions.cs (2)

350if (!interfacesOrAbstractClasses.All(i => i.TypeKind == TypeKind.Interface) && 351!interfacesOrAbstractClasses.All(i => i.IsAbstractClass()))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ISymbolExtensions.cs (1)

795(symbol.Name.Length == 1 || uint.TryParse(symbol.Name[1..], out _) || symbol.Name.All(n => n.Equals('_')));

Microsoft.CodeAnalysis.CodeStyle.Fixes (1)

src\Analyzers\Core\CodeFixes\RemoveUnusedMembers\AbstractRemoveUnusedMembersCodeFixProvider.cs (1)

99Debug.Assert(childDeclarators.All(c => !declarators.Contains(c)));

Microsoft.CodeAnalysis.Collections.Package (1)

Extensions\IEnumerableExtensions.cs (1)

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

Microsoft.CodeAnalysis.CSharp (10)

Binder\Binder_Attributes.cs (1)

741Debug.Assert(hasErrors || reorderedArguments.All(arg => arg.Kind != TypedConstantKind.Error));

Binder\DecisionDagBuilder.cs (1)

854!existingState.RemainingValues.All(kv => newRemainingValues.TryGetValue(kv.Key, out IValueSet? values) && kv.Value.Equals(values)))

Binder\Semantics\OverloadResolution\MethodTypeInference.cs (1)

352Debug.Assert(_nullableAnnotationLowerBounds.All(annotation => annotation.IsNotAnnotated()));

Lowering\LocalRewriter\LocalRewriter_Call.cs (1)

1143Debug.Assert(actualArguments.All(static arg => arg is not null));

Lowering\LocalRewriter\LocalRewriter_CompoundAssignmentOperator.cs (1)

448Debug.Assert(actualArguments.All(static arg => arg is not null));

Lowering\LocalRewriter\LocalRewriter_ObjectOrCollectionInitializerExpression.cs (1)

186.All(p => p.RefKind is RefKind.None or RefKind.In or RefKind.RefReadOnlyParameter));

Parser\Lexer.cs (1)

1622if ((valueText.Length == 0) || !valueText.All(SyntaxFacts.IsHexDigit))

Symbols\Source\SourceMemberContainerSymbol.cs (1)

495return name is { Length: > 0 } && name.All(c => c >= 'a' && c <= 'z');

Symbols\Tuples\TupleTypeSymbol.cs (2)

837Debug.Assert(fields.All(f => f is object)); 1038Debug.Assert(builder.All(f => f is object));

Microsoft.CodeAnalysis.CSharp.Analyzers (1)

MetaAnalyzers\CSharpSemanticModelGetDeclaredSymbolAlwaysReturnsNullAnalyzer.cs (1)

93else if (allowedTypes.All(type => !syntaxNodeDerivingType.DerivesFrom(type, baseTypesOnly: true, checkTypeParameterConstraints: false)

Microsoft.CodeAnalysis.CSharp.CodeStyle (9)

src\Analyzers\CSharp\Analyzers\ConvertSwitchStatementToExpression\ConvertSwitchStatementToExpressionDiagnosticAnalyzer.Analyzer.cs (1)

117if (!sections.All(s => CanConvertLabelsToArms(s.Labels)))

src\Analyzers\CSharp\Analyzers\RemoveUnnecessaryLambdaExpression\CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs (1)

285return !expression.DescendantNodesAndSelf().All(

src\Analyzers\CSharp\Analyzers\UseCollectionExpression\CSharpUseCollectionExpressionForArrayDiagnosticAnalyzer.cs (1)

95expression.Initializer.Expressions.All(e => e is CollectionExpressionSyntax))

src\Analyzers\CSharp\Analyzers\UseCollectionExpression\CSharpUseCollectionExpressionForFluentDiagnosticAnalyzer.cs (1)

306.All(static t => t.IsWhitespaceOrEndOfLine()))

src\Analyzers\CSharp\Analyzers\UseCollectionExpression\UseCollectionExpressionHelpers.cs (1)

399if (initializer.Expressions.All(IsPrimitiveConstant))

src\Analyzers\CSharp\Analyzers\UsePrimaryConstructor\CSharpUsePrimaryConstructorDiagnosticAnalyzer.cs (1)

412if (!block.Statements.All(static s => s is ExpressionStatementSyntax { Expression: AssignmentExpressionSyntax }))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Formatting\Rules\ElasticTriviaFormattingRule.cs (3)

44basePropertyDeclaration.AccessorList.Accessors.All(a => a.Body == null) && 228if (previousProperty?.AccessorList?.Accessors.All(a => a.Body == null) == true && 229nextProperty?.AccessorList?.Accessors.All(a => a.Body == null) == true)

Microsoft.CodeAnalysis.CSharp.CodeStyle.Fixes (5)

src\Analyzers\CSharp\CodeFixes\ConvertToRecord\ConvertToRecordHelpers.cs (2)

483return operation.ChildOperations.All(IsSafeAssignment); 860additionalConditions.All(otherCondition => TryAddEqualizedFieldsForCondition(

src\Analyzers\CSharp\CodeFixes\NewLines\ConstructorInitializerPlacement\ConstructorInitializerPlacementCodeFixProvider.cs (1)

106return previousToken.TrailingTrivia.All(t => t.Kind() == SyntaxKind.WhitespaceTrivia)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\CodeGeneration\EnumMemberGenerator.cs (1)

108destination.Members.All(m => m.EqualsValue == null))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\LanguageServices\CSharpTypeInferenceService.TypeInferrer.cs (1)

2246parenthesizedVariableDesignation.Variables.All(v => v is SingleVariableDesignationSyntax { Identifier.ValueText: not "" }))

Microsoft.CodeAnalysis.CSharp.EditorFeatures.UnitTests (1)

SplitStringLiteral\SplitStringLiteralCommandHandlerTests.cs (1)

82if (originalSelections.All(selection => selection.IsEmpty))

Microsoft.CodeAnalysis.CSharp.Emit3.UnitTests (2)

Semantics\ExtensionTests.cs (2)

47Assert.True(expected.All(new HashSet<string>().Add), $"Duplicates were found in '{nameof(expected)}'"); 48Assert.True(actual.All(new HashSet<string>().Add), $"Duplicates were found in '{nameof(actual)}'");

Microsoft.CodeAnalysis.CSharp.Features (13)

ChangeSignature\CSharpChangeSignatureService.cs (1)

697var oldOnlyHasWhitespaceTrivia = oldTrivia.All(t => t.IsKind(SyntaxKind.WhitespaceTrivia));

ConvertLinq\ConvertForEachToLinqQuery\CSharpConvertForEachToLinqQueryProvider.cs (1)

181if (localDeclarationStatement.Declaration.Variables.All(variable => variable.Initializer != null))

ConvertPrimaryToRegularConstructor\ConvertPrimaryToRegularConstructorCodeRefactoringProvider_DocumentationComments.cs (1)

56if (content.All(c => c is XmlTextSyntax xmlText && xmlText.TextTokens.All(

Snippets\CSharpConstructorSnippetProvider.cs (1)

45if (!(precedingModifiers.All(SyntaxFacts.IsAccessibilityModifier) ||

src\Analyzers\CSharp\Analyzers\ConvertSwitchStatementToExpression\ConvertSwitchStatementToExpressionDiagnosticAnalyzer.Analyzer.cs (1)

117if (!sections.All(s => CanConvertLabelsToArms(s.Labels)))

src\Analyzers\CSharp\Analyzers\RemoveUnnecessaryLambdaExpression\CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs (1)

285return !expression.DescendantNodesAndSelf().All(

src\Analyzers\CSharp\Analyzers\UseCollectionExpression\CSharpUseCollectionExpressionForArrayDiagnosticAnalyzer.cs (1)

95expression.Initializer.Expressions.All(e => e is CollectionExpressionSyntax))

src\Analyzers\CSharp\Analyzers\UseCollectionExpression\UseCollectionExpressionHelpers.cs (1)

399if (initializer.Expressions.All(IsPrimitiveConstant))

src\Analyzers\CSharp\Analyzers\UsePrimaryConstructor\CSharpUsePrimaryConstructorDiagnosticAnalyzer.cs (1)

412if (!block.Statements.All(static s => s is ExpressionStatementSyntax { Expression: AssignmentExpressionSyntax }))

src\Analyzers\CSharp\CodeFixes\ConvertToRecord\ConvertToRecordHelpers.cs (2)

483return operation.ChildOperations.All(IsSafeAssignment); 860additionalConditions.All(otherCondition => TryAddEqualizedFieldsForCondition(

src\Analyzers\CSharp\CodeFixes\NewLines\ConstructorInitializerPlacement\ConstructorInitializerPlacementCodeFixProvider.cs (1)

106return previousToken.TrailingTrivia.All(t => t.Kind() == SyntaxKind.WhitespaceTrivia)

UseAutoProperty\CSharpUseAutoPropertyCodeFixProvider.cs (1)

225accessors.All(a => a is { ExpressionBody: null, Body: null }))

Microsoft.CodeAnalysis.CSharp.Semantic.UnitTests (1)

Semantics\QueryTests.cs (1)

2360Assert.True(symbols.All(s => ReferenceEquals(s, null)));

Microsoft.CodeAnalysis.CSharp.Symbol.UnitTests (3)

Symbols\MethodEqualityTests.cs (1)

223Assert.True(invokedMethods.All(m => m.Equals(m)));

Symbols\Source\ExternAliasTests.cs (2)

420Assert.True(targets.All(target => ReferenceEquals(firstTarget, target))); 445Assert.True(targets.All(target => ReferenceEquals(firstTarget, target)));

Microsoft.CodeAnalysis.CSharp.Workspaces (6)

FindSymbols\CSharpDeclaredSymbolInfoFactoryService.cs (1)

218typeDeclaration.Members.All(m => m is BaseTypeDeclarationSyntax))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Formatting\Rules\ElasticTriviaFormattingRule.cs (3)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\CodeGeneration\EnumMemberGenerator.cs (1)

108destination.Members.All(m => m.EqualsValue == null))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\LanguageServices\CSharpTypeInferenceService.TypeInferrer.cs (1)

2246parenthesizedVariableDesignation.Variables.All(v => v is SingleVariableDesignationSyntax { Identifier.ValueText: not "" }))

Microsoft.CodeAnalysis.EditorFeatures (4)

InlineRename\InlineRenameSession.OpenTextBufferManager.cs (2)

130if (editableSpans.All(s => s.Start > 0)) 135if (editableSpans.All(s => s.End < _subjectBuffer.CurrentSnapshot.Length))

IntelliSense\ModelComputation.cs (1)

129if (tasks.All(t => t.Status == TaskStatus.RanToCompletion))

Shared\Utilities\LinkedEditsTracker.cs (1)

89where intersection.All(intersectionSpan => mappedSpan.IntersectsWith(intersectionSpan))

Microsoft.CodeAnalysis.EditorFeatures.UnitTests (5)

SymbolFinder\SymbolFinderTests.cs (5)

452Assert.True(immediateDerived.All(d => d.BaseType.Equals(rootType))); 499Assert.True(immediateDerived.All(d => d.Interfaces.Contains(rootType))); 507Assert.True(transitiveDerived.All(d => d.AllInterfaces.Contains(rootType)), "All results must transitively derive from the type"); 549Assert.True(immediateImpls.All(d => d.Interfaces.Contains(rootType))); 559Assert.True(transitiveImpls.All(d => d.AllInterfaces.Contains(rootType)), "All results must transitively derive from the type");

Microsoft.CodeAnalysis.Extensions.Package (4)

src\Dependencies\Collections\Extensions\IEnumerableExtensions.cs (1)

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

Symbols\INamedTypeSymbolExtensions.cs (2)

350if (!interfacesOrAbstractClasses.All(i => i.TypeKind == TypeKind.Interface) && 351!interfacesOrAbstractClasses.All(i => i.IsAbstractClass()))

Symbols\ISymbolExtensions.cs (1)

795(symbol.Name.Length == 1 || uint.TryParse(symbol.Name[1..], out _) || symbol.Name.All(n => n.Equals('_')));

Microsoft.CodeAnalysis.Features (11)

EditAndContinue\AbstractEditAndContinueAnalyzer.cs (1)

656Debug.Assert(newActiveStatements.All(a => a != null));

ExternalAccess\UnitTesting\SolutionCrawler\UnitTestingWorkCoordinator.UnitTestingIncrementalAnalyzerProcessor.cs (1)

236if (flattened.InnerExceptions.All(e => e is OperationCanceledException))

ExtractMethod\MethodExtractor.TriviaResult.cs (1)

86if (currentLine.All(t => t.RawKind == _endOfLineKind || t.RawKind == _whitespaceKind))

GoToDefinition\GoToDefinitionFeatureHelpers.cs (1)

42if (sourceLocations.All(l => solution.GetDocument(l.SourceTree) == null))

IntroduceVariable\AbstractIntroduceVariableService.cs (1)

155if (blocks.All(b => !BlockOverlapsHiddenPosition(b, cancellationToken)))

InvertIf\AbstractInvertIfCodeRefactoringProvider.cs (2)

381return statementRange.FirstStatement.DescendantNodesAndSelf().All(IsNoOpSyntaxNode); 389if (!statements[i].DescendantNodesAndSelf().All(IsNoOpSyntaxNode))

src\Analyzers\Core\Analyzers\Helpers\DiagnosticHelper.cs (1)

223Contract.ThrowIfFalse(indices.All(idx => idx >= 0 && idx < additionalLocationsLength));

src\Analyzers\Core\Analyzers\UseCompoundAssignment\UseCompoundAssignmentUtilities.cs (1)

37Debug.Assert(binaryToAssignmentMap.Values.All(assignmentToTokenMap.ContainsKey));

src\Analyzers\Core\CodeFixes\RemoveUnusedMembers\AbstractRemoveUnusedMembersCodeFixProvider.cs (1)

99Debug.Assert(childDeclarators.All(c => !declarators.Contains(c)));

SyncNamespaces\AbstractSyncNamespacesService.cs (1)

45if (diagnosticsByProject.Values.All(diagnostics => diagnostics.IsEmpty))

Microsoft.CodeAnalysis.InteractiveHost (1)

src\Dependencies\Collections\Extensions\IEnumerableExtensions.cs (1)

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

Microsoft.CodeAnalysis.LanguageServer.Protocol (3)

src\LanguageServer\Microsoft.CommonLanguageServerProtocol.Framework\AbstractLanguageServer.cs (2)

150if (typeRefs.All(r => r is null) || typeRefs.All(r => r is not null))

src\LanguageServer\Microsoft.CommonLanguageServerProtocol.Framework\HandlerProvider.cs (1)

129var missingMethods = requestHandlerKeys.Where(meta => RequiredMethods.All(method => method == meta.MethodName));

Microsoft.CodeAnalysis.PerformanceSensitiveAnalyzers (10)

src\Dependencies\Collections\Extensions\IEnumerableExtensions.cs (1)

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

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\ComputationalComplexityMetrics.cs (1)

329return !operation.DescendantsAndSelf().All(o => o.IsImplicit || (!o.ConstantValue.HasValue && o.Type == null && o.Kind is not (OperationKind.Branch or OperationKind.Attribute)));

src\RoslynAnalyzers\Utilities\Compiler\Extensions\IDictionaryExtensions.cs (1)

15dictionary.Keys.All(key => other.ContainsKey(key) && dictionary[key]?.Equals(other[key]) == true);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\SymbolUsageAnalysis\SymbolUsageAnalysis.DataFlowAnalyzer.FlowGraphAnalysisData.cs (1)

101Debug.Assert(LValueFlowCapturesInGraph.Values.All(kind => kind is FlowCaptureKind.LValueCapture or FlowCaptureKind.LValueAndRValueCapture));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AbstractSpeculationAnalyzer.cs (1)

483methodSymbol.Parameters.Zip(newMethodSymbol.Parameters, (p1, p2) => (p1, p2)).All(

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\EnumValueUtilities.cs (1)

119existingConstants.All(GreaterThanOrEqualsZero))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\PathMetadataUtilities.cs (1)

32!rootNamespace.Split(NamespaceSeparatorArray).All(syntaxFacts.IsValidIdentifier))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\INamedTypeSymbolExtensions.cs (2)

350if (!interfacesOrAbstractClasses.All(i => i.TypeKind == TypeKind.Interface) && 351!interfacesOrAbstractClasses.All(i => i.IsAbstractClass()))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ISymbolExtensions.cs (1)

795(symbol.Name.Length == 1 || uint.TryParse(symbol.Name[1..], out _) || symbol.Name.All(n => n.Equals('_')));

Microsoft.CodeAnalysis.PublicApiAnalyzers (10)

src\Dependencies\Collections\Extensions\IEnumerableExtensions.cs (1)

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

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\ComputationalComplexityMetrics.cs (1)

329return !operation.DescendantsAndSelf().All(o => o.IsImplicit || (!o.ConstantValue.HasValue && o.Type == null && o.Kind is not (OperationKind.Branch or OperationKind.Attribute)));

src\RoslynAnalyzers\Utilities\Compiler\Extensions\IDictionaryExtensions.cs (1)

15dictionary.Keys.All(key => other.ContainsKey(key) && dictionary[key]?.Equals(other[key]) == true);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\SymbolUsageAnalysis\SymbolUsageAnalysis.DataFlowAnalyzer.FlowGraphAnalysisData.cs (1)

101Debug.Assert(LValueFlowCapturesInGraph.Values.All(kind => kind is FlowCaptureKind.LValueCapture or FlowCaptureKind.LValueAndRValueCapture));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AbstractSpeculationAnalyzer.cs (1)

483methodSymbol.Parameters.Zip(newMethodSymbol.Parameters, (p1, p2) => (p1, p2)).All(

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\EnumValueUtilities.cs (1)

119existingConstants.All(GreaterThanOrEqualsZero))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\PathMetadataUtilities.cs (1)

32!rootNamespace.Split(NamespaceSeparatorArray).All(syntaxFacts.IsValidIdentifier))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\INamedTypeSymbolExtensions.cs (2)

350if (!interfacesOrAbstractClasses.All(i => i.TypeKind == TypeKind.Interface) && 351!interfacesOrAbstractClasses.All(i => i.IsAbstractClass()))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ISymbolExtensions.cs (1)

795(symbol.Name.Length == 1 || uint.TryParse(symbol.Name[1..], out _) || symbol.Name.All(n => n.Equals('_')));

Microsoft.CodeAnalysis.PublicApiAnalyzers.CodeFixes (1)

DeclarePublicApiFix.cs (1)

308Debug.Assert(newSymbolNames.All(newSymbolName => !symbolNamesToRemove.Contains(newSymbolName)));

Microsoft.CodeAnalysis.Rebuild.UnitTests (1)

RoundTripUtil.cs (1)

71Assert.True(original.SyntaxTrees.All(x => !string.IsNullOrEmpty(x.FilePath)));

Microsoft.CodeAnalysis.Remote.ServiceHub (1)

Host\RemoteWorkspace.SolutionCreator.cs (1)

128Debug.Assert(solution.ProjectIds.All(id => newVersions.Map.ContainsKey(id)));

Microsoft.CodeAnalysis.ResxSourceGenerator (11)

AbstractResxGenerator.cs (1)

712if (name.All(IsIdentifierPartCharacter))

src\Dependencies\Collections\Extensions\IEnumerableExtensions.cs (1)

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

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\ComputationalComplexityMetrics.cs (1)

329return !operation.DescendantsAndSelf().All(o => o.IsImplicit || (!o.ConstantValue.HasValue && o.Type == null && o.Kind is not (OperationKind.Branch or OperationKind.Attribute)));

src\RoslynAnalyzers\Utilities\Compiler\Extensions\IDictionaryExtensions.cs (1)

15dictionary.Keys.All(key => other.ContainsKey(key) && dictionary[key]?.Equals(other[key]) == true);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\SymbolUsageAnalysis\SymbolUsageAnalysis.DataFlowAnalyzer.FlowGraphAnalysisData.cs (1)

101Debug.Assert(LValueFlowCapturesInGraph.Values.All(kind => kind is FlowCaptureKind.LValueCapture or FlowCaptureKind.LValueAndRValueCapture));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AbstractSpeculationAnalyzer.cs (1)

483methodSymbol.Parameters.Zip(newMethodSymbol.Parameters, (p1, p2) => (p1, p2)).All(

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\EnumValueUtilities.cs (1)

119existingConstants.All(GreaterThanOrEqualsZero))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\PathMetadataUtilities.cs (1)

32!rootNamespace.Split(NamespaceSeparatorArray).All(syntaxFacts.IsValidIdentifier))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\INamedTypeSymbolExtensions.cs (2)

350if (!interfacesOrAbstractClasses.All(i => i.TypeKind == TypeKind.Interface) && 351!interfacesOrAbstractClasses.All(i => i.IsAbstractClass()))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ISymbolExtensions.cs (1)

795(symbol.Name.Length == 1 || uint.TryParse(symbol.Name[1..], out _) || symbol.Name.All(n => n.Equals('_')));

Microsoft.CodeAnalysis.Scripting (1)

Hosting\ObjectFormatter\CommonObjectFormatter.Visitor.cs (1)

319return typeof(IEnumerable).GetTypeInfo().IsAssignableFrom(originalType) && members.All(member => member.Index >= 0);

Microsoft.CodeAnalysis.Test.Utilities (8)

Assert\AssertEx.cs (1)

525var all = actual.All(predicate);

Compilation\ControlFlowGraphVerifier.cs (1)

525referencesAfter.All(r => isLongLivedCaptureReferenceSyntax(r.Syntax)),

Compilation\OperationTreeVerifier.cs (1)

384Debug.Assert(operation.ChildOperations.All(o => o != null));

Compilation\TestOperationVisitor.cs (1)

589Assert.True(operation.Descendants().All(n => n.IsImplicit), $"Explicit node in default argument value ({operation.Syntax.RawKind}): {operation.Syntax.ToString()}");

Diagnostics\DiagnosticDescription.cs (2)

492var includeDefaultSeverity = expected.Any() && expected.All(d => d.DefaultSeverity != null); 493var includeEffectiveSeverity = expected.Any() && expected.All(d => d.EffectiveSeverity != null);

Diagnostics\DiagnosticExtensions.cs (2)

73var includeDefaultSeverity = expected.Any() && expected.All(e => e.DefaultSeverity != null); 74var includeEffectiveSeverity = expected.Any() && expected.All(e => e.EffectiveSeverity != null);

Microsoft.CodeAnalysis.Threading.Package (1)

src\Dependencies\Collections\Extensions\IEnumerableExtensions.cs (1)

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

Microsoft.CodeAnalysis.Workspaces (17)

FindSymbols\SymbolFinder_Helpers.cs (3)

128Contract.ThrowIfFalse(equivalentTypesWithDifferingAssemblies.All(kvp => !SymbolEquivalenceComparer.Instance.Equals(kvp.Key.ContainingAssembly, kvp.Value.ContainingAssembly))); 131Contract.ThrowIfFalse(equivalentTypesWithDifferingAssemblies.All(kvp => kvp.Key.ContainingType == null)); 132Contract.ThrowIfFalse(equivalentTypesWithDifferingAssemblies.All(kvp => kvp.Value.ContainingType == null));

Options\Option.cs (1)

59Debug.Assert(storageLocations.All(l => l is not IEditorConfigValueSerializer));

Options\PerLanguageOption.cs (1)

51Debug.Assert(storageLocations.All(l => l is not IEditorConfigValueSerializer));

Rename\ConflictEngine\ConflictResolver.Session.cs (1)

281if (conflictResolution.ReplacementTextValid && conflictResolution.RelatedLocations.All(loc => (loc.Type & RelatedLocationType.UnresolvableConflict) == 0))

src\Dependencies\Collections\Extensions\IEnumerableExtensions.cs (1)

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

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\SymbolUsageAnalysis\SymbolUsageAnalysis.DataFlowAnalyzer.FlowGraphAnalysisData.cs (1)

101Debug.Assert(LValueFlowCapturesInGraph.Values.All(kind => kind is FlowCaptureKind.LValueCapture or FlowCaptureKind.LValueAndRValueCapture));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AbstractSpeculationAnalyzer.cs (1)

483methodSymbol.Parameters.Zip(newMethodSymbol.Parameters, (p1, p2) => (p1, p2)).All(

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\EnumValueUtilities.cs (1)

119existingConstants.All(GreaterThanOrEqualsZero))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\PathMetadataUtilities.cs (1)

32!rootNamespace.Split(NamespaceSeparatorArray).All(syntaxFacts.IsValidIdentifier))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\INamedTypeSymbolExtensions.cs (2)

350if (!interfacesOrAbstractClasses.All(i => i.TypeKind == TypeKind.Interface) && 351!interfacesOrAbstractClasses.All(i => i.IsAbstractClass()))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ISymbolExtensions.cs (1)

795(symbol.Name.Length == 1 || uint.TryParse(symbol.Name[1..], out _) || symbol.Name.All(n => n.Equals('_')));

Workspace\Solution\ProjectDependencyGraph.cs (2)

495Debug.Assert(referencesMap.Keys.All(projectIds.Contains)); 517Debug.Assert(reverseReferencesMap.Keys.All(projectIds.Contains));

Workspace\Solution\SolutionCompilationState.RegularCompilationTracker_Generators.cs (1)

146oldGeneratedDocuments.States.All(kvp => kvp.Value.ParseOptions.Equals(this.ProjectState.ParseOptions)))

Microsoft.CodeAnalysis.Workspaces.MSBuild.BuildHost (1)

src\Dependencies\Collections\Extensions\IEnumerableExtensions.cs (1)

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

Microsoft.CodeAnalysis.Workspaces.UnitTests (2)

FindReferencesTests.cs (1)

630Assert.True(typeResult.Locations.All(loc => loc.Location.SourceSpan != constructorResult.Locations.Single().Location.SourceSpan));

SolutionTests\SolutionTests.cs (1)

5231Assert.True(compilation1New.References.All(r => r is not CompilationReference));

Microsoft.CommonLanguageServerProtocol.Framework.Package (3)

AbstractLanguageServer.cs (2)

150if (typeRefs.All(r => r is null) || typeRefs.All(r => r is not null))

HandlerProvider.cs (1)

129var missingMethods = requestHandlerKeys.Where(meta => RequiredMethods.All(method => method == meta.MethodName));

Microsoft.Data.Analysis.Tests (6)

ArrayComparer.cs (6)

144f1.Metadata.Keys.All(k => f2.Metadata.ContainsKey(k) && f1.Metadata[k] == f2.Metadata[k]) && 145f2.Metadata.Keys.All(k => f1.Metadata.ContainsKey(k) && f2.Metadata[k] == f1.Metadata[k]); 166if (!s1.FieldsList.All(field => s2.FieldsLookup.Contains(field.Name) && FieldComparer.Equals(field, s2.GetFieldByName(field.Name))) || 167!s2.FieldsList.All(field => s1.FieldsLookup.Contains(field.Name) && FieldComparer.Equals(field, s1.GetFieldByName(field.Name)))) 175s1.Metadata.Keys.All(k => s2.Metadata.ContainsKey(k) && s1.Metadata[k] == s2.Metadata[k]) && 176s2.Metadata.Keys.All(k => s1.Metadata.ContainsKey(k) && s2.Metadata[k] == s1.Metadata[k]);

Microsoft.DotNet.Arcade.Sdk (1)

src\GenerateResxSource.cs (1)

370if (name.All(IsIdentifierPartCharacter))

Microsoft.DotNet.Build.Tasks.Feed (3)

src\model\TargetChannelConfig.cs (1)

203ContentTypes.Zip(other.ContentTypes, (l, r) => l.Equals(r)).All(b => b) &&

src\PublishArtifactsInManifest.cs (1)

263if (results.All(t => t))

src\PublishArtifactsInManifestBase.cs (1)

439return results.All(x => x);

Microsoft.DotNet.Build.Tasks.Packaging (2)

GeneratePackageReport.cs (1)

106if (runtimeIds.All(rid => !String.IsNullOrEmpty(rid)))

HarvestPackage.cs (1)

153return _packageFolders.Values.All(f => f != null);

Microsoft.DotNet.Helix.Sdk.Tests (2)

InstallDotNetToolTests.cs (2)

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

Microsoft.DotNet.NuGetRepack.Tests (1)

TestHelpers\AssertEx.cs (1)

299var all = actual.All(predicate);

Microsoft.DotNet.SignCheckLibrary (6)

Verification\Exclusion.cs (2)

87return FilePatterns.Length != 0 && !FilePatterns.All(fp => String.IsNullOrEmpty(fp)); 98return ParentFiles.Length != 0 && !ParentFiles.All(pf => String.IsNullOrEmpty(pf));

Verification\Jar\JarFile.cs (2)

131if (!SignatureFiles.All(sf => sf.VerifySignature())) 157if (!signatureFilesFailedVerifyDigestManifest.All(sf => sf.VerifyDigestManifestMain(Manifest)))

Verification\Jar\JarManifestFile.cs (1)

43return IndividualSection.All(entry => Verify(entry, archive.GetEntry(entry.Name)));

Verification\Jar\JarSignatureFile.cs (1)

108return ManifestHashDigestAttributes.All(

Microsoft.DotNet.SignTool (2)

src\BatchSignUtil.cs (1)

300return zipData.NestedParts.Values.All(x => (!x.FileSignInfo.SignInfo.ShouldSign ||

src\SignToolTask.cs (1)

595return pkt.ToLower().All(c => (c >= '0' && c <= '9') || (c >= 'a' && c <= 'z'));

Microsoft.DotNet.SwaggerGenerator.CodeGenerator (1)

DefaultHelpers.cs (1)

21return arguments.All(arg => arg);

Microsoft.Extensions.AI (1)

Embeddings\CachingEmbeddingGenerator.cs (1)

105Debug.Assert(results.All(e => e is not null), "Expected all values to be non-null");

Microsoft.Extensions.AI.AzureAIInference (1)

AzureAIInferenceChatClient.cs (1)

472if (input.Contents.All(c => c is TextContent))

Microsoft.Extensions.AI.Evaluation.Integration.Tests (4)

AgentQualityEvaluatorTests.cs (1)

155result.Metrics.Values.All(m => m.ContainsDiagnostics(d => d.Severity is EvaluationDiagnosticSeverity.Error)),

QualityEvaluatorTests.cs (1)

177result.Metrics.Values.All(m => m.ContainsDiagnostics(d => d.Severity is EvaluationDiagnosticSeverity.Error)),

ResultsTests.cs (2)

173Assert.True(result.Metrics.Values.All(m => m.Interpretation is null)); 360Assert.True(result.Metrics.Values.All(m => m.Interpretation is null));

Microsoft.Extensions.AI.Evaluation.Reporting.Tests (7)

ResultStoreTester.cs (7)

90Assert.True(results.All(r => r.executionName == newExecutionName)); 146Assert.True(results.Take(3).All(r => r.executionName == thirdExecutionName)); 147Assert.True(results.Skip(3).Take(3).All(r => r.executionName == secondExecutionName)); 148Assert.True(results.Skip(6).Take(3).All(r => r.executionName == firstExecutionName)); 199Assert.True(results.All(r => r.executionName == executionName1)); 234Assert.True(results.All(r => r.executionName == executionName)); 269Assert.True(results.All(r => r.executionName == executionName));

Microsoft.Extensions.Identity.Core (1)

PasswordValidator.cs (1)

51if (options.RequireNonAlphanumeric && password.All(IsLetterOrDigit))

Microsoft.Gen.Logging (1)

Parsing\Parser.cs (1)

254lm.Parameters.All(x => x.IsLogger || x.IsLogLevel))

Microsoft.Interop.ComInterfaceGenerator (3)

ComInterfaceGenerator.cs (3)

550.Where(context => context.Diagnostics.All(diag => diag.Descriptor.DefaultSeverity != DiagnosticSeverity.Error)) 638.Where(context => context.UnmanagedToManagedStub.Diagnostics.All(diag => diag.Descriptor.DefaultSeverity != DiagnosticSeverity.Error))) 774.Where(context => context.UnmanagedToManagedStub.Diagnostics.All(diag => diag.Descriptor.DefaultSeverity != DiagnosticSeverity.Error));

Microsoft.Maui.Controls.Build.Tasks (1)

CreateObjectVisitor.cs (1)

159 md.Parameters.All(

Microsoft.Maui.Controls.DesignTools (1)

GridLengthCollectionDesignTypeConverter.cs (1)

19 return lengths.All(GridLengthDesignTypeConverter.IsValid);

Microsoft.Maui.Controls.Xaml (3)

CreateValuesVisitor.cs (3)

76 ci.GetParameters().All(pi => pi.CustomAttributes.Any(attr => attr.AttributeType == typeof(ParameterAttribute)))) && 210 ci.GetParameters().All(pi => pi.CustomAttributes.Any(attr => attr.AttributeType == typeof(ParameterAttribute)))); 236 ci.GetParameters().All(pi => pi.CustomAttributes.Any(attr => attr.AttributeType == typeof(ParameterAttribute))));

Microsoft.Maui.Resizetizer (2)

GeneratePackageAppxManifest.cs (2)

319 if (showons.All(x => x.Attribute("Tile")?.Value != "square150x150Logo")) 321 if (showons.All(x => x.Attribute("Tile")?.Value != "wide310x150Logo"))

Microsoft.ML.AutoML (8)

Experiment\Experiment.cs (2)

189if (_history.Count() == 3 && _history.All(r => !r.RunSucceeded)) 209if (e.InnerExceptions.All(exception => exception is OperationCanceledException))

Experiment\Runners\CrossValRunner.cs (1)

62var allRunsSucceeded = trainResults.All(r => r.Exception == null);

Experiment\Runners\CrossValSummaryRunner.cs (2)

67var allRunsSucceeded = trainResults.All(r => r.exception == null); 162if (results.All(result => result == null))

Sweepers\ISweeper.cs (1)

137return other._parameterValues.Values.All(pv => ContainsParamValue(pv));

TransformInference\TransformInference.cs (2)

112obj.ColumnsConsumed.All(cc => ColumnsConsumed.Any(cc.Equals)) && 113obj.ColumnsProduced.All(cp => ColumnsProduced.Any(cp.Equals));

Microsoft.ML.Core (3)

CommandLine\CmdParser.cs (2)

1346Contracts.Assert(args.Select((arg, index) => arg.Index == index).All(b => b)); 1424Contracts.Check(nicks == null || nicks.All(nick => !string.IsNullOrWhiteSpace(nick)));

Data\IEstimator.cs (1)

133Contracts.CheckParam(columns.All(c => c.IsValid), nameof(columns), "Some items are not initialized properly.");

Microsoft.ML.Data (19)

Data\DataViewUtils.cs (2)

802Contracts.Assert(batchColumns.All(bc => bc.Count == count)); 1039Ch.Assert(pipes.All(p => p != null));

Data\RowCursorUtils.cs (2)

477env.CheckParam(Enumerable.Range(0, row.Schema.Count).All(c => row.IsColumnActive(row.Schema[c])), nameof(row), "Some columns were inactive"); 520_host.Assert(Enumerable.Range(0, row.Schema.Count).All(c => row.IsColumnActive(row.Schema[c])));

DataLoadSave\Text\TextLoader.cs (1)

549return Utils.Size(Columns) == 0 || Columns.All(x => x.IsValid());

DataLoadSave\TransformerChain.cs (1)

62bool ITransformer.IsRowToRowMapper => _transformers.All(t => t.IsRowToRowMapper);

DataLoadSave\Transpose\TransposeLoader.cs (1)

553env.Assert(Enumerable.Range(0, schema.Count).All(c => saver.IsColumnSavable(schema[c].Type)));

DataView\AppendRowsDataView.cs (2)

61env.CheckParam(sources.All(s => s != null), nameof(sources)); 113_host.Check(_sources.All(source => source.Schema.Count == colCount), errMsg);

DataView\Transposer.cs (1)

148ch.Assert(Enumerable.Range(0, slicerSchema.Count).All(c => saver.IsColumnSavable(slicerSchema[c].Type)));

EntryPoints\EntryPointNode.cs (3)

646if (!((JArray)pair.Value).All(tok => VariableBinding.IsBindingToken(tok))) 790.All(varBinding => _context.TryGetVariable(varBinding.VariableName, out EntryPointVariable v) && v.IsValueSet); 854_host.Assert(bindings.Skip(1).All(binding => binding.GetType().Equals(firstBinding.GetType())));

Prediction\Calibrator.cs (2)

1238_host.CheckDecode(_binProbs.All(x => (0 <= x && x <= 1))); 1985_host.Assert(mins.Zip(maxes, (min, max) => min <= max).All(x => x));

Transforms\ColumnBindingsBase.cs (2)

151return Source.All(s => !string.IsNullOrEmpty(s)); 194return Source.All(s => !string.IsNullOrEmpty(s));

Transforms\ColumnConcatenatingTransformer.cs (1)

823Contracts.Assert(srcTokens.All(tok => tok != null));

Transforms\ValueToKeyMappingTransformer.cs (1)

645ch.Assert(termMap.All(tm => tm != null));

Microsoft.ML.DataView (1)

VectorType.cs (1)

63Contracts.CheckParam(dimensions.All(d => d >= 0), nameof(dimensions));

Microsoft.ML.Ensemble (6)

PipelineEnsemble.cs (1)

684return v1.DenseValues().Zip(v2.DenseValues(), (x1, x2) => x1.Equals(x2)).All(b => b);

Trainer\Binary\EnsembleTrainer.cs (3)

85if (models.All(m => m.Predictor is TDistPredictor)) 98Host.CheckParam(models.All(m => m is TDistPredictor), nameof(models)); 103Host.CheckParam(models.All(m => m is TScalarPredictor), nameof(models));

Trainer\Multiclass\MulticlassDataPartitionEnsembleTrainer.cs (1)

98Host.CheckParam(models.All(m => m is TVectorPredictor), nameof(models));

Trainer\Regression\RegressionEnsembleTrainer.cs (1)

86Host.CheckParam(models.All(m => m is TScalarPredictor), nameof(models));

Microsoft.ML.FastTree (13)

Dataset\Dataset.cs (3)

48Contracts.Assert(flocks.All(f => f.Examples == datasetSkeleton.NumDocs)); 836if (arrays.All(x => x == null)) 982Contracts.Assert(Enumerable.Range(0, _dataset.NumFlocks).All(f =>

Dataset\Feature.cs (1)

360if (bitsPerItem != IntArrayBits.Bits0 && parts.All(x => x.Bins is DeltaSparseIntArray))

Dataset\FeatureFlock.cs (1)

1183Contracts.Assert(AllBinUpperBounds.Select((b, f) => HotFeatureStarts[f + 1] - HotFeatureStarts[f] + 1 == b.Length).All(i => i));

Dataset\IntArray.cs (1)

99Contracts.Assert(values.All(x => x == 0));

FastTree.cs (5)

944Host.Assert(binUpperBounds.All(b => b != null)); 1090Contracts.Assert(flockBits == IntArrayBits.Bits32 || binnedValues.All(b => b < limBin)); 1164Contracts.Assert(flockBits == IntArrayBits.Bits32 || binnedValues.All(b => b < limBin)); 1634Host.Assert(features.All(f => f != null)); 2697Contracts.Assert(features.All(i => values[i] != null));

TreeEnsemble\InternalRegressionTree.cs (2)

461checker(CategoricalSplitFeatureRanges.All(x => x == null || x.Length == 0 || x.Length == 2), 1247CategoricalSplitFeatures.All(val => val == null))

Microsoft.ML.IntegrationTests (2)

SchemaDefinitionTests.cs (2)

54Assert.True(prediction.Features.All(x => x == 0)); 57Assert.True(prediction.Features.Select((x, i) => i == 3 && x == 1 || x == 0).All(b => b));

Microsoft.ML.OnnxTransformer (1)

OnnxUtils.cs (1)

326if (shapeDictionary[name].All(value => value > 0))

Microsoft.ML.Predictor.Tests (1)

TestPredictors.cs (1)

946if (scores.All(s => !float.IsNaN(s)))

Microsoft.ML.SearchSpace.Tests (2)

UniformNumericOptionTests.cs (2)

83.All((x) => Math.Abs(x.Item1 - x.Item2) < 1e-5) 96.All((x) => Math.Abs(x.Item1 - x.Item2) < 1e-5)

Microsoft.ML.StandardTrainers (15)

LdSvm\LdSvmModelParameters.cs (12)

62Host.Assert(w.All(v => v.IsDense)); 63Host.Assert(w.All(v => v.Length == w[0].Length)); 65Host.Assert(thetaPrime.All(v => v.IsDense)); 66Host.Assert(thetaPrime.All(v => v.Length == thetaPrime[0].Length)); 68Host.Assert(theta.All(v => v.IsDense)); 69Host.Assert(theta.All(v => v.Length == theta[0].Length)); 130Host.Assert(_w.All(v => v.IsDense)); 131Host.Assert(_w.All(v => v.Length == _w[0].Length)); 133Host.Assert(_thetaPrime.All(v => v.IsDense)); 134Host.Assert(_thetaPrime.All(v => v.Length == _thetaPrime[0].Length)); 136Host.Assert(_theta.All(v => v.IsDense)); 137Host.Assert(_theta.All(v => v.Length == _theta[0].Length));

Standard\LogisticRegression\MulticlassLogisticRegression.cs (2)

475if (Weights.All(v => v.IsDense)) 520if (Weights.All(v => v.IsDense))

Standard\MulticlassClassification\MulticlassNaiveBayesTrainer.cs (1)

297Host.Assert(featureHistogram.All(h => h == null || h.Length == featureCount));

Microsoft.ML.Sweeper (1)

ISweeper.cs (1)

166return other._parameterValues.Values.All(pv => ContainsParamValue(pv));

Microsoft.ML.Sweeper.Tests (2)

TestSweeper.cs (2)

534Assert.True(gridPoint.All(bArray => bArray.All(b => b)));

Microsoft.ML.TensorFlow (1)

TensorflowUtils.cs (1)

92(Utils.Size(tensorShape) > 0 && tensorShape.Skip(1).All(x => x > 0)))

Microsoft.ML.TestFramework (1)

TestCommandBase.cs (1)

380Contracts.Assert(Utils.Size(toCompare) == 0 || toCompare.All(x => x != null));

Microsoft.ML.Tests (8)

CachingTests.cs (4)

51Assert.True(trainData.All(x => x.AccessCount == 2)); 61Assert.True(trainData.All(x => x.AccessCount == 1)); 87Assert.True(src.All(x => x.AccessCount == 2)); 94Assert.True(src.All(x => x.AccessCount == 1));

ImagesTests.cs (1)

98.All(x => x));

Scenarios\Api\TestApi.cs (1)

252Assert.True(retrievedReadOnlyMemoryVBuffer.DenseValues().Select((s, i) => s.ToString() == valueStringArray[i]).All(b => b));

Transformers\CustomMappingTests.cs (2)

82Assert.True(inputs.Zip(outputs, (x, y) => y.Together == $"{x.Float1} + {string.Join(", ", x.Float4)}").All(x => x)); 202Assert.True(filteredData.GetColumn<float>(filteredData.Schema[nameof(MyInput.Float1)]).All(x => x % 2 == 1));

Microsoft.ML.TorchSharp (2)

NasBert\Modules\SearchSpace.cs (1)

33if (!hiddenList.All(hidden => hidden == 0 || hidden == maxHidden))

Utils\DataUtils.cs (1)

21Contracts.Assert(values.All(v => v.dim() == 1), "All tensors should be 1D to collate.");

Microsoft.ML.Transforms (17)

Dracula\CMCountTable.cs (2)

62Contracts.Check(tables.All(t => t.All(t2 => t2.Max(kvp => kvp.Key) < Width)), "Keys must be between 0 and Width - 1");

Dracula\CountTable.cs (6)

51Contracts.Check(priorCounts.All(x => x >= 0)); 59Contracts.Check(garbageCounts.All(x => x >= 0)); 98env.CheckDecode(_priorFrequencies.All(x => x >= 0)); 109env.CheckDecode(_garbageCounts.All(x => x >= 0)); 129Contracts.Assert(_priorFrequencies.All(x => x >= 0)); 140Contracts.Assert(_garbageCounts.All(x => x >= 0));

Dracula\CountTableTransformer.cs (2)

122_host.CheckParam(columns.All(col => col.PriorCoefficient > 0), nameof(ColumnOptionsBase.PriorCoefficient), "Must be greater than zero"); 123_host.CheckParam(columns.All(col => col.LaplaceScale >= 0), nameof(ColumnOptionsBase.LaplaceScale), "Must be greater than or equal to zero.");

Dracula\DictCountTable.cs (1)

52Contracts.Check(counts.All(x => x != null), "Count dictionaries must all exist");

Dracula\Featurizer.cs (2)

90_host.CheckDecode(PriorCoef.All(x => x > 0)); 93_host.CheckDecode(LaplaceScale.All(x => x >= 0));

Expression\BuiltinFunctions.cs (1)

373Contracts.CheckParam(!values.All(x => x != null), nameof(values), "Expected values to contain at least one null");

ExpressionTransformer.cs (2)

79_host.Check(columns.All(col => !string.IsNullOrWhiteSpace(col.Expression))); 80_host.Check(columns.All(col => !string.IsNullOrWhiteSpace(col.Name)));

Text\NgramTransform.cs (1)

1058Contracts.CheckUserArg(Utils.Size(maximumNgramsCounts) == 0 || maximumNgramsCounts.All(i => i >= 0) && maximumNgramsCounts[maximumNgramsCounts.Length - 1] > 0, nameof(maximumNgramsCounts));

Microsoft.ML.Vision (1)

ImageClassificationTrainer.cs (1)

885Contracts.Assert(featurizedImages.All(x => x.Item2.Length == featureLength));

Microsoft.VisualBasic.Core (3)

Microsoft\VisualBasic\CompilerServices\Utils.vb (3)

189Enumerable.All(Enumerable.Zip(pis1, 209Enumerable.All(Enumerable.Zip(pis1, 300Enumerable.All(Enumerable.Zip(args1,

Microsoft.VisualStudio.LanguageServices (2)

Implementation\VisualStudioSupportsFeatureService.cs (1)

115.All(cd => cd == null || cd.SupportsRename);

PickMembers\PickMembersDialog.xaml.cs (1)

142var allChecked = selectedItems.All(m => m.IsChecked);

MSBuild (2)

XMake.cs (2)

1648nodeResultKvp.Key.ProjectInstance.GlobalProperties.All(propertyKvp => entryPoint.GlobalProperties.TryGetValue(propertyKvp.Key, out string entryValue) && 1678&& !(exception is AggregateException aggregateException && aggregateException.InnerExceptions.All(innerException => innerException is InvalidProjectFileException))

Roslyn.Diagnostics.Analyzers (10)

src\Dependencies\Collections\Extensions\IEnumerableExtensions.cs (1)

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

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\ComputationalComplexityMetrics.cs (1)

329return !operation.DescendantsAndSelf().All(o => o.IsImplicit || (!o.ConstantValue.HasValue && o.Type == null && o.Kind is not (OperationKind.Branch or OperationKind.Attribute)));

src\RoslynAnalyzers\Utilities\Compiler\Extensions\IDictionaryExtensions.cs (1)

15dictionary.Keys.All(key => other.ContainsKey(key) && dictionary[key]?.Equals(other[key]) == true);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\SymbolUsageAnalysis\SymbolUsageAnalysis.DataFlowAnalyzer.FlowGraphAnalysisData.cs (1)

101Debug.Assert(LValueFlowCapturesInGraph.Values.All(kind => kind is FlowCaptureKind.LValueCapture or FlowCaptureKind.LValueAndRValueCapture));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AbstractSpeculationAnalyzer.cs (1)

483methodSymbol.Parameters.Zip(newMethodSymbol.Parameters, (p1, p2) => (p1, p2)).All(

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\EnumValueUtilities.cs (1)

119existingConstants.All(GreaterThanOrEqualsZero))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\PathMetadataUtilities.cs (1)

32!rootNamespace.Split(NamespaceSeparatorArray).All(syntaxFacts.IsValidIdentifier))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\INamedTypeSymbolExtensions.cs (2)

350if (!interfacesOrAbstractClasses.All(i => i.TypeKind == TypeKind.Interface) && 351!interfacesOrAbstractClasses.All(i => i.IsAbstractClass()))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ISymbolExtensions.cs (1)

795(symbol.Name.Length == 1 || uint.TryParse(symbol.Name[1..], out _) || symbol.Name.All(n => n.Equals('_')));

Roslyn.Diagnostics.CSharp.Analyzers (5)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Formatting\Rules\ElasticTriviaFormattingRule.cs (3)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\CodeGeneration\EnumMemberGenerator.cs (1)

108destination.Members.All(m => m.EqualsValue == null))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\LanguageServices\CSharpTypeInferenceService.TypeInferrer.cs (1)

2246parenthesizedVariableDesignation.Variables.All(v => v is SingleVariableDesignationSyntax { Identifier.ValueText: not "" }))

System.ComponentModel.Composition (1)

System\ComponentModel\Composition\ReflectionModel\LazyMemberInfo.cs (1)

161if (accessors.All(accessor => accessor == null))

System.Linq.Expressions (4)

System\Linq\Expressions\Compiler\LambdaCompiler.Statements.cs (2)

382if (!node.Cases.All(c => c.TestValues.All(t => t is ConstantExpression)))

System\Linq\Expressions\Interpreter\LightCompiler.cs (2)

1531if (node.Cases.All(c => c.TestValues.All(t => t is ConstantExpression)))

System.Windows.Forms.Tests (6)

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

65Assert.True(testingControlProps.All(p => assemblyTypeInfo.DeclaredProperties.Any(ap => ap.Name == p))); 66Assert.True(testingControlEvents.All(e => assemblyTypeInfo.DeclaredEvents.Any(ae => ae.Name == e)));

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

55testingControlProps.All(p => assemblyTypeInfo.DeclaredProperties.Any(ap => ap.Name == p)).Should().BeTrue(); 56testingControlEvents.All(e => assemblyTypeInfo.DeclaredEvents.Any(ae => ae.Name == e)).Should().BeTrue();

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

4392Assert.False(properties.All(p => p.Name != member.Name), "Property not found!");

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

2788Assert.True(control.DisplayedItems.Cast<ToolStripItem>().All(i => i.Visible));

Test.Utilities (9)

src\Dependencies\Collections\Extensions\IEnumerableExtensions.cs (1)

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

src\RoslynAnalyzers\Utilities\Compiler\Extensions\IDictionaryExtensions.cs (1)

15dictionary.Keys.All(key => other.ContainsKey(key) && dictionary[key]?.Equals(other[key]) == true);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\SymbolUsageAnalysis\SymbolUsageAnalysis.DataFlowAnalyzer.FlowGraphAnalysisData.cs (1)

101Debug.Assert(LValueFlowCapturesInGraph.Values.All(kind => kind is FlowCaptureKind.LValueCapture or FlowCaptureKind.LValueAndRValueCapture));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AbstractSpeculationAnalyzer.cs (1)

483methodSymbol.Parameters.Zip(newMethodSymbol.Parameters, (p1, p2) => (p1, p2)).All(

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\EnumValueUtilities.cs (1)

119existingConstants.All(GreaterThanOrEqualsZero))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\PathMetadataUtilities.cs (1)

32!rootNamespace.Split(NamespaceSeparatorArray).All(syntaxFacts.IsValidIdentifier))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\INamedTypeSymbolExtensions.cs (2)

350if (!interfacesOrAbstractClasses.All(i => i.TypeKind == TypeKind.Interface) && 351!interfacesOrAbstractClasses.All(i => i.IsAbstractClass()))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ISymbolExtensions.cs (1)

795(symbol.Name.Length == 1 || uint.TryParse(symbol.Name[1..], out _) || symbol.Name.All(n => n.Equals('_')));

Text.Analyzers (11)

IdentifiersShouldBeSpelledCorrectly.cs (1)

396static bool IsWordAcronym(string word) => word.All(char.IsUpper);

src\Dependencies\Collections\Extensions\IEnumerableExtensions.cs (1)

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

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\ComputationalComplexityMetrics.cs (1)

329return !operation.DescendantsAndSelf().All(o => o.IsImplicit || (!o.ConstantValue.HasValue && o.Type == null && o.Kind is not (OperationKind.Branch or OperationKind.Attribute)));

src\RoslynAnalyzers\Utilities\Compiler\Extensions\IDictionaryExtensions.cs (1)

15dictionary.Keys.All(key => other.ContainsKey(key) && dictionary[key]?.Equals(other[key]) == true);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\SymbolUsageAnalysis\SymbolUsageAnalysis.DataFlowAnalyzer.FlowGraphAnalysisData.cs (1)

101Debug.Assert(LValueFlowCapturesInGraph.Values.All(kind => kind is FlowCaptureKind.LValueCapture or FlowCaptureKind.LValueAndRValueCapture));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AbstractSpeculationAnalyzer.cs (1)

483methodSymbol.Parameters.Zip(newMethodSymbol.Parameters, (p1, p2) => (p1, p2)).All(

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\EnumValueUtilities.cs (1)

119existingConstants.All(GreaterThanOrEqualsZero))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\PathMetadataUtilities.cs (1)

32!rootNamespace.Split(NamespaceSeparatorArray).All(syntaxFacts.IsValidIdentifier))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\INamedTypeSymbolExtensions.cs (2)

350if (!interfacesOrAbstractClasses.All(i => i.TypeKind == TypeKind.Interface) && 351!interfacesOrAbstractClasses.All(i => i.IsAbstractClass()))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ISymbolExtensions.cs (1)

795(symbol.Name.Length == 1 || uint.TryParse(symbol.Name[1..], out _) || symbol.Name.All(n => n.Equals('_')));

WinFormsControlsTest (2)

DragDrop.cs (2)

116if (files.All(file => file.Contains("NyanCat") && file.Contains(".bmp"))) 162&& files.All(file => file.Contains("NyanCat") && file.Contains(".bmp")))

xunit.console (1)

ConsoleRunner.cs (1)

279parallelizeAssemblies = project.All(assembly => assembly.Configuration.ParallelizeAssemblyOrDefault);