SequenceEqual

256 references to SequenceEqual

aspire (1)

Backchannel\ExtensionBackchannel.cs (1)

182return GetCertificate().RawData.SequenceEqual(c.GetRawCertData());

Aspire.Dashboard (4)

Components\Controls\AspireMenuButton.razor.cs (1)

55if (Items != null && !_items.SequenceEqual(Items))

Components\Controls\Chart\ChartBase.cs (1)

95_renderedDimensionAttributes is null || !_renderedDimensionAttributes.SequenceEqual(dimensionAttributes) ||

Model\DebugSessionHelpers.cs (1)

33return cert.RawData.SequenceEqual(c.RawData);

Otlp\Model\MetricValues\DimensionScope.cs (1)

98explicitBounds = lastHistogramValue.ExplicitBounds.SequenceEqual(h.ExplicitBounds)

Aspire.Dashboard.Tests (1)

TelemetryRepositoryTests\MetricsTests.cs (1)

1247Assert.True(Enumerable.SequenceEqual(MemoryMarshal.ToEnumerable(key), scope.Attributes), "Key and attributes don't match.");

Aspire.Hosting (3)

ApplicationModel\ResourceNotificationService.cs (1)

758return publicKey is not null && microsoftOpenPublicKey.SequenceEqual(publicKey);

Dcp\Model\Container.cs (2)

332&& (Entries ?? Enumerable.Empty<ContainerFileSystemEntry>()).SequenceEqual(other.Entries ?? Enumerable.Empty<ContainerFileSystemEntry>()); 423&& (Entries ?? Enumerable.Empty<ContainerFileSystemEntry>()).SequenceEqual(other.Entries ?? Enumerable.Empty<ContainerFileSystemEntry>());

BuildValidator (1)

CompilationDiff.cs (1)

159if (originalBytes.SequenceEqual(rebuildBytes))

ConfigurationSchemaGenerator (1)

RuntimeSource\SourceGenerators\DiagnosticInfo.cs (1)

45MessageArgs.SequenceEqual(other.MessageArgs) &&

Extensibility.MessageEncoder.IntegrationTests (1)

TextTests.4.1.0.cs (1)

117Assert.True(requestBytes.SequenceEqual(returnedByteArraySegment.Array), "Returned bytes are different than sent bytes");

GenerateDocumentationAndConfigFiles (6)

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

48if (arguments.SequenceEqual(symbol.TypeArguments))

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

46if (arguments.SequenceEqual(symbol.TypeArguments))

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

50if (arguments.SequenceEqual(symbol.TypeArguments))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\IMethodSymbolExtensions.cs (2)

45if (method.TypeParameters.Select(t => t.Name).SequenceEqual(newNames)) 79if (parameterList.Select(p => p.Name).SequenceEqual(parameterNames))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\IPropertySymbolExtensions.cs (1)

18if (parameterList.Select(p => p.Name).SequenceEqual(parameterNames))

IdentitySample.PasskeyConformance (4)

InMemoryUserStore.cs (4)

41=> Task.FromResult(_users.Values.FirstOrDefault(u => u.Passkeys.Any(p => p.CredentialId.SequenceEqual(credentialId)))); 44=> Task.FromResult(ToUserPasskeyInfo(user.Passkeys.FirstOrDefault(p => p.CredentialId.SequenceEqual(credentialId)))); 75var passkeyEntity = user.Passkeys.FirstOrDefault(p => p.CredentialId.SequenceEqual(passkey.CredentialId)); 95var passkey = user.Passkeys.SingleOrDefault(p => p.CredentialId.SequenceEqual(credentialId));

IdentitySample.PasskeyUI (4)

InMemoryUserStore.cs (4)

InMemory.FunctionalTests (2)

src\Servers\Kestrel\shared\test\CertificateAuthority.cs (2)

134if (!certificate.IssuerName.RawData.SequenceEqual(_cert.SubjectName.RawData)) 205if (!subjectName.RawData.SequenceEqual(_cert.IssuerName.RawData))

IOperationGenerator (1)

IOperationClassWriter.cs (1)

406bool hasSkippedProperties = !GetAllProperties(type, includeSkipGenerationProperties: true).SequenceEqual(allProps);

Metrics (3)

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

48if (arguments.SequenceEqual(symbol.TypeArguments))

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

46if (arguments.SequenceEqual(symbol.TypeArguments))

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

50if (arguments.SequenceEqual(symbol.TypeArguments))

Metrics.Legacy (3)

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

48if (arguments.SequenceEqual(symbol.TypeArguments))

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

46if (arguments.SequenceEqual(symbol.TypeArguments))

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

50if (arguments.SequenceEqual(symbol.TypeArguments))

Microsoft.AspNetCore.Components.Endpoints.Tests (1)

Binding\FormDataMapperTests.cs (1)

1281Assert.True(((IEnumerable<TElement>)expected).SequenceEqual((IEnumerable<TElement>)list));

Microsoft.AspNetCore.Http.Results.Tests (2)

src\Shared\ResultsTests\FileStreamResultTestBase.cs (2)

391Assert.True(originalBytes.SequenceEqual(outBytes)); 416Assert.True(originalBytes.SequenceEqual(outBytes));

Microsoft.AspNetCore.Identity.EntityFrameworkCore (4)

UserOnlyStore.cs (2)

592userPasskey => userPasskey.UserId.Equals(userId) && userPasskey.CredentialId.SequenceEqual(credentialId), 604return UserPasskeys.SingleOrDefaultAsync(userPasskey => userPasskey.CredentialId.SequenceEqual(credentialId), cancellationToken);

UserStore.cs (2)

728userPasskey => userPasskey.UserId.Equals(userId) && userPasskey.CredentialId.SequenceEqual(credentialId), 740return UserPasskeys.SingleOrDefaultAsync(userPasskey => userPasskey.CredentialId.SequenceEqual(credentialId), cancellationToken);

Microsoft.AspNetCore.Mvc.Core.Test (2)

src\Shared\ResultsTests\FileStreamResultTestBase.cs (2)

391Assert.True(originalBytes.SequenceEqual(outBytes)); 416Assert.True(originalBytes.SequenceEqual(outBytes));

Microsoft.AspNetCore.Mvc.TagHelpers (1)

Cache\DistributedCacheTagHelperService.cs (1)

192if (serializedKeyBuffer.SequenceEqual(expectedKey))

Microsoft.AspNetCore.Rewrite.Tests (1)

ApacheModRewrite\FlagParserTest.cs (1)

81.SequenceEqual((dictionary ?? new Dictionary<TKey, TValue>())

Microsoft.AspNetCore.Routing.Tests (2)

Matching\MatcherAssert.cs (2)

19!expectedValues.OrderBy(kvp => kvp.Key).SequenceEqual(actualValues.OrderBy(kvp => kvp.Key))) 85!values.OrderBy(kvp => kvp.Key).SequenceEqual(actualValues.OrderBy(kvp => kvp.Key)))

Microsoft.AspNetCore.Server.Kestrel.Core.Tests (2)

src\Servers\Kestrel\shared\test\CertificateAuthority.cs (2)

134if (!certificate.IssuerName.RawData.SequenceEqual(_cert.SubjectName.RawData)) 205if (!subjectName.RawData.SequenceEqual(_cert.IssuerName.RawData))

Microsoft.AspNetCore.Server.Kestrel.Microbenchmarks (2)

InMemoryTransportBenchmark.cs (1)

77if (!Enumerable.SequenceEqual(expectedResponseLines, responseLines))

NamedPipesTransportBenchmark.cs (1)

79if (!Enumerable.SequenceEqual(expectedResponseLines, responseLines))

Microsoft.AspNetCore.Shared.Tests (2)

SegmentWriteStreamTests.cs (2)

69Assert.True(expectedSegment.SequenceEqual(segment)); 102Assert.True(expectedSegment.SequenceEqual(segment));

Microsoft.AspNetCore.SignalR.Common.Tests (1)

Internal\Protocol\CustomObject.cs (1)

42System.Linq.Enumerable.SequenceEqual(ByteArrProp, right.ByteArrProp);

Microsoft.AspNetCore.StaticFiles.FunctionalTests (2)

FallbackStaticFileTest.cs (1)

132Assert.True(responseContent.SequenceEqual(fileContents));

StaticFileMiddlewareTests.cs (1)

171Assert.True(responseContent.SequenceEqual(fileContents));

Microsoft.AspNetCore.StaticFiles.Tests (5)

StaticFileMiddlewareTests.cs (5)

199Assert.True(responseContent.SequenceEqual(fileContents)); 238Assert.True(responseContent.SequenceEqual(fileContents)); 280Assert.True(responseContent.SequenceEqual(fileContents)); 330Assert.True(responseContent.SequenceEqual(fileContents)); 373Assert.True(responseContent.SequenceEqual(fileContents));

Microsoft.AspNetCore.TestHost.Tests (2)

TestClientTests.cs (2)

628Assert.True(hello.SequenceEqual(buffer.Take(hello.Length))); 633Assert.True(world.SequenceEqual(buffer.Take(world.Length)));

Microsoft.Build.BuildCheck.UnitTests (10)

TaskInvocationAnalysisDataTests.cs (10)

Microsoft.Build.Engine.UnitTests (1)

BinaryLogger_Tests.cs (1)

259bytes1.SequenceEqual(bytes2).ShouldBeTrue(

Microsoft.Build.Utilities.UnitTests (1)

TaskItem_Tests.cs (1)

342Assert.True(actualMetadata.SequenceEqual(expectedMetadata));

Microsoft.Cci.Extensions (3)

Differs\Rules\TokenListDiffer.cs (1)

67return list1.SequenceEqual(list2);

HostEnvironment.cs (2)

355!assemblyIdentity.PublicKeyToken.SequenceEqual(this.CoreAssemblySymbolicIdentity.PublicKeyToken)) 365if (assemblyIdentity.PublicKeyToken == null || !assemblyIdentity.PublicKeyToken.SequenceEqual(s_ecmaKey))

Microsoft.CodeAnalysis (2)

Compilation\ParseOptions.cs (1)

144this.Features.SequenceEqual(other.Features) &&

Diagnostic\DiagnosticWithInfo.cs (1)

172this.AdditionalLocations.SequenceEqual(other.AdditionalLocations);

Microsoft.CodeAnalysis.Analyzers (6)

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

48if (arguments.SequenceEqual(symbol.TypeArguments))

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

46if (arguments.SequenceEqual(symbol.TypeArguments))

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

50if (arguments.SequenceEqual(symbol.TypeArguments))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\IMethodSymbolExtensions.cs (2)

45if (method.TypeParameters.Select(t => t.Name).SequenceEqual(newNames)) 79if (parameterList.Select(p => p.Name).SequenceEqual(parameterNames))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\IPropertySymbolExtensions.cs (1)

18if (parameterList.Select(p => p.Name).SequenceEqual(parameterNames))

Microsoft.CodeAnalysis.AnalyzerUtilities (4)

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

101InterproceduralCallStack.SequenceEqual(other.InterproceduralCallStack) &&

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

48if (arguments.SequenceEqual(symbol.TypeArguments))

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

46if (arguments.SequenceEqual(symbol.TypeArguments))

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

50if (arguments.SequenceEqual(symbol.TypeArguments))

Microsoft.CodeAnalysis.BannedApiAnalyzers (6)

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

48if (arguments.SequenceEqual(symbol.TypeArguments))

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

46if (arguments.SequenceEqual(symbol.TypeArguments))

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

50if (arguments.SequenceEqual(symbol.TypeArguments))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\IMethodSymbolExtensions.cs (2)

45if (method.TypeParameters.Select(t => t.Name).SequenceEqual(newNames)) 79if (parameterList.Select(p => p.Name).SequenceEqual(parameterNames))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\IPropertySymbolExtensions.cs (1)

18if (parameterList.Select(p => p.Name).SequenceEqual(parameterNames))

Microsoft.CodeAnalysis.CodeStyle (3)

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

48if (arguments.SequenceEqual(symbol.TypeArguments))

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

46if (arguments.SequenceEqual(symbol.TypeArguments))

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

50if (arguments.SequenceEqual(symbol.TypeArguments))

Microsoft.CodeAnalysis.CodeStyle.Fixes (4)

src\Analyzers\Core\CodeFixes\GenerateConstructor\AbstractGenerateConstructorService.State.cs (1)

221constructor.Parameters.Select(p => p.Type).SequenceEqual(ParameterTypes))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\IMethodSymbolExtensions.cs (2)

45if (method.TypeParameters.Select(t => t.Name).SequenceEqual(newNames)) 79if (parameterList.Select(p => p.Name).SequenceEqual(parameterNames))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\IPropertySymbolExtensions.cs (1)

18if (parameterList.Select(p => p.Name).SequenceEqual(parameterNames))

Microsoft.CodeAnalysis.CSharp (3)

Binder\Binder_InterpolatedString.cs (1)

669Debug.Assert(appendCallsArray.Select(a => a.Length).SequenceEqual(partsArray.Select(a => a.Length)));

Compilation\SyntaxAndDeclarationManager.cs (1)

476var loadDirectivesHaveChanged = !oldTree.GetCompilationUnitRoot().GetLoadDirectives().SequenceEqual(newLoadDirectivesSyntax);

FlowAnalysis\FlowAnalysisPass.cs (1)

95Debug.Assert(getErrorsOnly(flowAnalysisDiagnostics.ToReadOnly()).SequenceEqual(getErrorsOnly(diagnostics.ToReadOnly().Diagnostics.Skip(initialDiagnosticCount))));

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

Attributes\AttributeTests_Nullable.cs (1)

4219if (!expectedPreviously.SequenceEqual(expectedNow))

Microsoft.CodeAnalysis.CSharp.Syntax.UnitTests (11)

Parsing\ParsingErrorRecoveryTests.cs (7)

7399Assert.True(syntaxTree.GetDiagnostics().Select(d => ((IFormattable)d).ToString(null, EnsureEnglishUICulture.PreferredOrNull)).SequenceEqual(new[] 7418Assert.True(syntaxTree.GetDiagnostics().Select(d => ((IFormattable)d).ToString(null, EnsureEnglishUICulture.PreferredOrNull)).SequenceEqual(new[] 7451Assert.True(syntaxTree.GetDiagnostics().Select(d => ((IFormattable)d).ToString(null, EnsureEnglishUICulture.PreferredOrNull)).SequenceEqual(new[] 7476Assert.True(syntaxTree.GetDiagnostics().Select(d => ((IFormattable)d).ToString(null, EnsureEnglishUICulture.PreferredOrNull)).SequenceEqual(new[] 7501Assert.True(syntaxTree.GetDiagnostics().Select(d => ((IFormattable)d).ToString(null, EnsureEnglishUICulture.PreferredOrNull)).SequenceEqual(new[] 7527Assert.True(syntaxTree.GetDiagnostics().Select(d => ((IFormattable)d).ToString(null, EnsureEnglishUICulture.PreferredOrNull)).SequenceEqual(new[] 7551Assert.True(syntaxTree.GetDiagnostics().Select(d => ((IFormattable)d).ToString(null, EnsureEnglishUICulture.PreferredOrNull)).SequenceEqual(new[]

Syntax\SyntaxNodeTests.cs (4)

1565Assert.True(related.SequenceEqual(related2)); 1569Assert.True(related.SequenceEqual(related3)); 2046Assert.True(expectedTokenKinds.SequenceEqual(actualTokens.Select(t => t.Kind()))); 2067Assert.True(expectedTokenKinds.SequenceEqual(actualTokens.Select(t => (SyntaxKind)t.RawKind)));

Microsoft.CodeAnalysis.Extensions.Package (3)

Symbols\ITypeSymbolExtensions.AnonymousTypeRemover.cs (1)

48if (arguments.SequenceEqual(symbol.TypeArguments))

Symbols\ITypeSymbolExtensions.UnavailableTypeParameterRemover.cs (1)

46if (arguments.SequenceEqual(symbol.TypeArguments))

Symbols\ITypeSymbolExtensions.UnnamedErrorTypeRemover.cs (1)

50if (arguments.SequenceEqual(symbol.TypeArguments))

Microsoft.CodeAnalysis.Features (5)

AddImport\References\Reference.cs (1)

71SearchResult.NameParts.SequenceEqual(other.SearchResult.NameParts);

CodeFixes\RoslynAssemblyHelper.cs (1)

15=> source.GetType().GetTypeInfo().Assembly.GetName().GetPublicKey().SequenceEqual(

Diagnostics\Service\EngineV2\DiagnosticIncrementalAnalyzer.StateManager.ProjectStates.cs (1)

49entry.AnalyzerReferences.SequenceEqual(project.AnalyzerReferences))

GenerateConstructors\AbstractGenerateConstructorsCodeRefactoringProvider.State.cs (1)

120=> parameters.Select(p => p.Type).SequenceEqual(constructor.Parameters.Select(p => p.Type));

src\Analyzers\Core\CodeFixes\GenerateConstructor\AbstractGenerateConstructorService.State.cs (1)

221constructor.Parameters.Select(p => p.Type).SequenceEqual(ParameterTypes))

Microsoft.CodeAnalysis.LanguageServer.Protocol (4)

Protocol\Converters\SumConverter.cs (2)

137.SequenceEqual(expressionLambdaMethodTypes)) 148.SequenceEqual(jsonSerializerDeserializeMethodTypes))

Protocol\Diagnostic.cs (1)

152: this.Tags.Equals(other.Tags) || this.Tags.SequenceEqual(other.Tags))

Protocol\SymbolInformation.cs (1)

120: (this.Tags.Equals(other.Tags) || this.Tags.SequenceEqual(other.Tags)))

Microsoft.CodeAnalysis.PerformanceSensitiveAnalyzers (6)

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

48if (arguments.SequenceEqual(symbol.TypeArguments))

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

46if (arguments.SequenceEqual(symbol.TypeArguments))

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

50if (arguments.SequenceEqual(symbol.TypeArguments))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\IMethodSymbolExtensions.cs (2)

45if (method.TypeParameters.Select(t => t.Name).SequenceEqual(newNames)) 79if (parameterList.Select(p => p.Name).SequenceEqual(parameterNames))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\IPropertySymbolExtensions.cs (1)

18if (parameterList.Select(p => p.Name).SequenceEqual(parameterNames))

Microsoft.CodeAnalysis.PublicApiAnalyzers (4)

DeclarePublicApiAnalyzer.Impl.cs (1)

340overload.Parameters.Select(p => p.Type).SequenceEqual(method.Parameters.Select(p => p.Type)))

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

48if (arguments.SequenceEqual(symbol.TypeArguments))

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

46if (arguments.SequenceEqual(symbol.TypeArguments))

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

50if (arguments.SequenceEqual(symbol.TypeArguments))

Microsoft.CodeAnalysis.ResxSourceGenerator (3)

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

48if (arguments.SequenceEqual(symbol.TypeArguments))

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

46if (arguments.SequenceEqual(symbol.TypeArguments))

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

50if (arguments.SequenceEqual(symbol.TypeArguments))

Microsoft.CodeAnalysis.Test.Utilities (4)

Assert\AssertEx.cs (1)

728=> expected.Where(c => !char.IsWhiteSpace(c)).SequenceEqual(actual.Where(c => !char.IsWhiteSpace(c)));

Diagnostics\DiagnosticDescription.cs (1)

332if (!args1.SequenceEqual(args2))

Diagnostics\DiagnosticsHelper.cs (1)

28Assert.True(expectedDiagnosticIds.SequenceEqual(actualDiagnosticIds),

Diagnostics\TrackingDiagnosticAnalyzer.cs (1)

166Assert.True(expected.SequenceEqual(actual),

Microsoft.CodeAnalysis.UnitTests (14)

Collections\Extensions\EnumerableExtensionsTests.cs (1)

105Assert.True(elements.SequenceEqual(result));

Collections\Extensions\ImmutableArrayExtensionsTests.cs (1)

270Assert.True(a.Concat(a).SequenceEqual(ImmutableArray.Create<int>(0, 2, 4, 0, 2, 4)));

Collections\HashSet\SegmentedHashSet_Generic_Tests`1.cs (1)

284Assert.True(arr1.SequenceEqual(arr2));

Collections\IdentifierCollectionTests.cs (4)

41Assert.True(Enumerable.SequenceEqual(strings.OrderBy(x => x), idcol.OrderBy(x => x))); 50Assert.True(Enumerable.SequenceEqual(strings.OrderBy(x => x), copy.OrderBy(x => x))); 58Assert.True(Enumerable.SequenceEqual(strings.OrderBy(x => x), idcol.OrderBy(x => x))); 67Assert.True(Enumerable.SequenceEqual(strings.OrderBy(x => x), copy.OrderBy(x => x)));

Collections\ImmutablesTestBase.nonnetstandard.cs (1)

60bool expectedResult = value != null && Enumerable.SequenceEqual(objectUnderTest, value);

Collections\List\ICollection.Generic.Tests.cs (2)

536Assert.True(Enumerable.SequenceEqual(collection, array)); 546Assert.True(Enumerable.SequenceEqual(collection, array.Take(count)));

MetadataReferences\FusionAssemblyPortabilityPolicy.cs (1)

98Enumerable.SequenceEqual(_fileHash, other._fileHash);

Text\CompositeTextTests.cs (1)

39Assert.True(sourceLinesText.SequenceEqual(compositeLinesText));

Text\SourceTextStreamTests.cs (2)

55Assert.True(buffer.Take(baseText.Length).SequenceEqual(encoding.GetBytes(baseText))); 58Assert.True(buffer.Take(3).SequenceEqual(encoding.GetBytes(new[] { '\u2019' })));

Microsoft.CodeAnalysis.Workspaces (16)

Rename\Renamer.cs (1)

121if (newDocumentFolders != null && !newDocumentFolders.SequenceEqual(document.Folders))

Rename\Renamer.RenameDocumentActionSet.cs (1)

141return project.Documents.FirstOrDefault(d => d.Name == _documentName && d.Folders.SequenceEqual(_documentFolders))

Shared\Extensions\IMethodSymbolExtensions.cs (1)

68!method1.Parameters.Select(p => p.Name).SequenceEqual(method2.Parameters.Select(p => p.Name)))

Shared\Extensions\INamespaceSymbolExtensions.Comparer.cs (1)

16=> GetNameParts(x).SequenceEqual(GetNameParts(y));

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

48if (arguments.SequenceEqual(symbol.TypeArguments))

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

46if (arguments.SequenceEqual(symbol.TypeArguments))

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

50if (arguments.SequenceEqual(symbol.TypeArguments))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\IMethodSymbolExtensions.cs (2)

45if (method.TypeParameters.Select(t => t.Name).SequenceEqual(newNames)) 79if (parameterList.Select(p => p.Name).SequenceEqual(parameterNames))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\IPropertySymbolExtensions.cs (1)

18if (parameterList.Select(p => p.Name).SequenceEqual(parameterNames))

Workspace\Solution\DocumentInfo.cs (1)

214newFolders.SequenceEqual(Folders) &&

Workspace\Solution\ProjectState.cs (1)

1049if (documentIds.SequenceEqual(DocumentStates.Ids))

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

576if (!Enumerable.SequenceEqual(compilationWithoutGeneratedDocuments.ExternalReferences, newReferences))

Workspace\Solution\SolutionState.cs (1)

195var analyzerReferencesEqual = AnalyzerReferences.SequenceEqual(analyzerReferences);

Workspace\Solution\TextDocumentStates.cs (1)

276=> !States.Values.SequenceEqual(oldStates.States.Values);

Workspace\Workspace.cs (1)

1632if (!CurrentSolution.AnalyzerReferences.SequenceEqual(newSolution.AnalyzerReferences))

Microsoft.CodeAnalysis.Workspaces.UnitTests (2)

ObjectSerializationTests.cs (1)

268Assert.True(Enumerable.SequenceEqual(expected, (byte[])reader.ReadByteArray()));

XxHash128Tests.cs (1)

123Assert.True(destination.SequenceEqual(destination2));

Microsoft.Data.Analysis.Tests (1)

DataFrameJoinExtensionsTests.cs (1)

151Assert.True(expected.SequenceEqual(intersection));

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

src\AzureStorageExtensions.cs (1)

70if (!remoteBuffer.SequenceEqual(localBuffer))

src\model\TargetChannelConfig.cs (1)

112if (!left.SequenceEqual(right))

src\model\TargetFeedConfig.cs (3)

103LatestLinkShortUrlPrefixes.SequenceEqual(other.LatestLinkShortUrlPrefixes) && 111(AkaMSCreateLinkPatterns.Select(p => p.ToString()).SequenceEqual(other.AkaMSCreateLinkPatterns.Select(p => p.ToString())))) && 113(AkaMSDoNotCreateLinkPatterns.Select(p => p.ToString()).SequenceEqual(other.AkaMSDoNotCreateLinkPatterns.Select(p => p.ToString()))));

Microsoft.DotNet.SignTool.Tests (1)

SignToolTests.cs (1)

357beforeSigningEngineFilesList.SequenceEqual(afterSigningEngineFilesList).Should().BeTrue();

Microsoft.Extensions.AI.Abstractions.Tests (1)

Embeddings\GeneratedEmbeddingsTests.cs (1)

84Assert.True(embeddings.SequenceEqual(generatedEmbeddings));

Microsoft.Extensions.AI.Evaluation.NLP (1)

Common\NGram.cs (1)

35=> Values.SequenceEqual(other.Values);

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

ResponseCacheTester.cs (14)

ScenarioRunResultTests.cs (1)

105Assert.True(entry.Tags!.SequenceEqual(deserialized.Tags!));

Microsoft.Extensions.Caching.Hybrid.Tests (8)

DistributedCacheTests.cs (4)

76Assert.True(expected.SequenceEqual(actual)); 84Assert.True(expected.SequenceEqual(actual)); 122Assert.True(expected.SequenceEqual(actual)); 130Assert.True(expected.SequenceEqual(actual));

PayloadTests.cs (4)

59Assert.True(payload.SequenceEqual(bytes)); 87Assert.True(payload.SequenceEqual(bytes)); 153Assert.True(payload.SequenceEqual(bytes)); 191Assert.True(payload.SequenceEqual(bytes));

Microsoft.Interop.ComInterfaceGenerator (2)

ComClassInfo.cs (1)

76&& ImplementedInterfacesNames.SequenceEqual(other.ImplementedInterfacesNames);

ComInterfaceGenerator.cs (1)

511if (a.GenerationContext.SignatureContext.ManagedParameters.SequenceEqual(b.GenerationContext.SignatureContext.ManagedParameters))

Microsoft.Maui.Controls.Foldable (1)

DualScreenInfo.cs (1)

128 !Enumerable.SequenceEqual(_spanningBounds, value))

Microsoft.Maui.Controls.SourceGen (2)

CodeBehindGenerator.cs (1)

785 return x.ExternalReferences.OfType<PortableExecutableReference>().SequenceEqual(y.ExternalReferences.OfType<PortableExecutableReference>());

src\Controls\src\Xaml\XamlNode.cs (1)

69 TypeArguments != null && other.TypeArguments != null && TypeArguments.SequenceEqual(other.TypeArguments));

Microsoft.Maui.Controls.Xaml (1)

XamlNode.cs (1)

69 TypeArguments != null && other.TypeArguments != null && TypeArguments.SequenceEqual(other.TypeArguments));

Microsoft.Maui.Essentials (1)

Connectivity\Connectivity.shared.cs (1)

117 if (currentAccess != e.NetworkAccess || !currentProfiles.SequenceEqual(e.ConnectionProfiles))

Microsoft.ML.Core (1)

ComponentModel\ComponentCatalog.cs (1)

1124return assembly.GetName().GetPublicKey().SequenceEqual(

Microsoft.ML.Tests (3)

OnnxConversionTest.cs (1)

1145return Enumerable.SequenceEqual(MissingIndicator, other.MissingIndicator);

Scenarios\Api\TestApi.cs (2)

257Assert.True(retrievedFloatVBuffer.Items().SequenceEqual(valueFloatVBuffer.Items())); 261Assert.True(retrievedVBuffer.Items().SequenceEqual(valueVBuffer.Items()));

Microsoft.ML.Tokenizers (1)

Model\EnglishRobertaTokenizer.cs (1)

1219public bool Equals(HighestOccurrenceMapping other) => _idToIndex.SequenceEqual(other._idToIndex);

Microsoft.ML.TorchSharp (2)

NasBert\Modules\MultiHeadAttention.cs (2)

265Debug.Assert(attentionWeights.size().SequenceEqual(new[] { batchSize * _numHeads, tgtLen, srcLen })); 294Debug.Assert(attention.size().SequenceEqual(new[] { batchSize * _numHeads, tgtLen, _headDim }));

Microsoft.Net.Http.Headers.Tests (1)

StringWithQualityHeaderValueComparerTest.cs (1)

57Assert.True(expectedSortedValues.SequenceEqual(actualSorted));

Microsoft.VisualStudio.LanguageServices (3)

EditorConfigSettings\NamingStyle\ViewModel\ColumnViewModels\NamingStylesStyleViewModel.cs (1)

36if (value is not null && !_styleValues.SequenceEqual(value))

GenerateType\GenerateTypeDialogViewModel.cs (1)

378this.SelectedProject.Documents.Where(n => n.Name != null && n.Folders.Count > 0 && n.Name == this.FileName && this.Folders.SequenceEqual(n.Folders)).Any()) ||

ProjectSystem\VisualStudioWorkspaceImpl.cs (1)

1354if (document.Folders != updatedInfo.Folders && !document.Folders.SequenceEqual(updatedInfo.Folders))

Roslyn.Diagnostics.Analyzers (6)

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

48if (arguments.SequenceEqual(symbol.TypeArguments))

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

46if (arguments.SequenceEqual(symbol.TypeArguments))

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

50if (arguments.SequenceEqual(symbol.TypeArguments))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\IMethodSymbolExtensions.cs (2)

45if (method.TypeParameters.Select(t => t.Name).SequenceEqual(newNames)) 79if (parameterList.Select(p => p.Name).SequenceEqual(parameterNames))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\IPropertySymbolExtensions.cs (1)

18if (parameterList.Select(p => p.Name).SequenceEqual(parameterNames))

Roslyn.VisualStudio.Next.UnitTests (4)

UnifiedSettings\TestModel\EnumIntegerToString.cs (1)

27return Input.Equals(other.Input) && Map.SequenceEqual(other.Map);

UnifiedSettings\TestModel\UnifiedSettingBase.cs (1)

55return Messages.SequenceEqual(other.Messages);

UnifiedSettings\TestModel\UnifiedSettingsEnumOption.cs (2)

28return base.Equals(other) && @Enum.SequenceEqual(other.@Enum) && EnumItemLabels.SequenceEqual(other.EnumItemLabels);

System.ComponentModel.Annotations (1)

System\ComponentModel\DataAnnotations\UIHintAttribute.cs (1)

152return leftParams.OrderBy(p => p.Key).SequenceEqual(rightParams.OrderBy(p => p.Key));

System.ComponentModel.Composition (1)

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

134return _accessors.SequenceEqual(other._accessors);

System.Composition.Runtime (1)

System\Composition\Hosting\Core\CompositionContract.cs (1)

201if (secondEnumerable == null || !Enumerable.SequenceEqual(firstEnumerable.Cast<object>(), secondEnumerable.Cast<object>()))

System.Composition.TypedParts (2)

System\Composition\TypedParts\Discovery\DiscoveredPart.cs (1)

236if (_appliedArguments.Any(args => Enumerable.SequenceEqual(args, typeArguments)))

System\Composition\TypedParts\Discovery\TypeInspector.cs (1)

193if (!(mappedType == partType || mappedType.GenericTypeArguments.SequenceEqual(partType.GenericTypeParameters)))

System.Drawing.Common.Tests (1)

System\Drawing\FontConverterTests.cs (1)

111Assert.True(propNames.SequenceEqual(expectedPropNames));

System.Text.Json.SourceGeneration (1)

src\libraries\Common\src\SourceGenerators\DiagnosticInfo.cs (1)

45MessageArgs.SequenceEqual(other.MessageArgs) &&

Test.Utilities (3)

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

48if (arguments.SequenceEqual(symbol.TypeArguments))

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

46if (arguments.SequenceEqual(symbol.TypeArguments))

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

50if (arguments.SequenceEqual(symbol.TypeArguments))

Text.Analyzers (6)

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

48if (arguments.SequenceEqual(symbol.TypeArguments))

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

46if (arguments.SequenceEqual(symbol.TypeArguments))

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

50if (arguments.SequenceEqual(symbol.TypeArguments))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\IMethodSymbolExtensions.cs (2)

45if (method.TypeParameters.Select(t => t.Name).SequenceEqual(newNames)) 79if (parameterList.Select(p => p.Name).SequenceEqual(parameterNames))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\IPropertySymbolExtensions.cs (1)

18if (parameterList.Select(p => p.Name).SequenceEqual(parameterNames))