SequenceEqual

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

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

TelemetryRepositoryTests\MetricsTests.cs (1)

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

CompilationDiff.cs (1)

159if (originalBytes.SequenceEqual(rebuildBytes))

RuntimeSource\SourceGenerators\DiagnosticInfo.cs (1)

45MessageArgs.SequenceEqual(other.MessageArgs) &&

TextTests.4.1.0.cs (1)

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

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

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

IOperationClassWriter.cs (1)

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

Binding\FormDataMapperTests.cs (1)

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

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

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

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

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

Cache\DistributedCacheTagHelperService.cs (1)

192if (serializedKeyBuffer.SequenceEqual(expectedKey))

Comparers\OpenApiAnyComparer.cs (2)

35OpenApiBinary binaryX => y is OpenApiBinary binaryY && binaryX.Value.SequenceEqual(binaryY.Value), 43OpenApiByte byteX => y is OpenApiByte byteY && byteX.Value.SequenceEqual(byteY.Value),

ApacheModRewrite\FlagParserTest.cs (1)

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

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

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

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

InMemoryTransportBenchmark.cs (1)

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

NamedPipesTransportBenchmark.cs (1)

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

SegmentWriteStreamTests.cs (2)

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

Internal\Protocol\CustomObject.cs (1)

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

FallbackStaticFileTest.cs (1)

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

StaticFileMiddlewareTests.cs (1)

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

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

TestClientTests.cs (2)

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

TaskInvocationAnalysisDataTests.cs (3)

174parameter4.EnumerateValues().SequenceEqual(array1).ShouldBeTrue(); 175parameter4.EnumerateStringValues().SequenceEqual(array1).ShouldBeTrue(); 180parameter5.EnumerateValues().SequenceEqual(array2).ShouldBeTrue();

BinaryLogger_Tests.cs (1)

260bytes1.SequenceEqual(bytes2).ShouldBeTrue(

TaskItem_Tests.cs (1)

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

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

Compilation\ParseOptions.cs (1)

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

Diagnostic\DiagnosticWithInfo.cs (1)

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

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

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

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

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

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

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

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

Attributes\AttributeTests_Nullable.cs (1)

4219if (!expectedPreviously.SequenceEqual(expectedNow))

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

Extensions\EnumerableExtensionTests.cs (1)

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

CodeFixes\RoslynAssemblyHelper.cs (1)

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

GenerateConstructorFromMembers\AbstractGenerateConstructorFromMembersCodeRefactoringProvider.State.cs (1)

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

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

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

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

61entry.AnalyzerReferences.SequenceEqual(project.AnalyzerReferences))

Protocol\Converters\SumConverter.cs (2)

136.SequenceEqual(expressionLambdaMethodTypes)) 147.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)))

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

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\ImmutableArrayExtensionsTests.cs (1)

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

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

Rename\Renamer.cs (1)

123if (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)

72!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\Workspace\Core\Extensions\IMethodSymbolExtensions.cs (2)

47if (method.TypeParameters.Select(t => t.Name).SequenceEqual(newNames)) 81if (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\SolutionCompilationState.RegularCompilationTracker.cs (1)

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

Workspace\Solution\SolutionState.cs (1)

184var analyzerReferencesEqual = AnalyzerReferences.SequenceEqual(analyzerReferences);

Workspace\Solution\TextDocumentStates.cs (1)

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

ObjectSerializationTests.cs (1)

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

XxHash128Tests.cs (1)

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

DataFrameJoinExtensionsTests.cs (1)

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

src\AzureStorageExtensions.cs (1)

70if (!remoteBuffer.SequenceEqual(localBuffer))

src\model\TargetChannelConfig.cs (1)

104if (!left.SequenceEqual(right))

src\model\TargetFeedConfig.cs (2)

100LatestLinkShortUrlPrefixes.SequenceEqual(other.LatestLinkShortUrlPrefixes) && 113return FilenamesToExclude.SequenceEqual(other.FilenamesToExclude);

SignToolTests.cs (1)

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

DistributedCacheTests.cs (4)

77Assert.True(expected.SequenceEqual(actual)); 85Assert.True(expected.SequenceEqual(actual)); 123Assert.True(expected.SequenceEqual(actual)); 131Assert.True(expected.SequenceEqual(actual));

ComClassInfo.cs (1)

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

ComInterfaceGenerator.cs (1)

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

ComponentModel\ComponentCatalog.cs (1)

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

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

Model\EnglishRobertaTokenizer.cs (1)

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

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

StringWithQualityHeaderValueComparerTest.cs (1)

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

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)

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

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

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

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

134return _accessors.SequenceEqual(other._accessors);

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

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

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\FontConverterTests.cs (1)

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

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

45MessageArgs.SequenceEqual(other.MessageArgs) &&