public bool Equals(CacheKey other)
{
return(EqualityUtility.NotNullAndSameType(this, other) &&
_type.Equals(other._type) &&
string.Equals(_methodName, other._methodName) &&
_bindingFlags == other._bindingFlags);
}
public bool Equals(ProjectRestoreMetadata other)
{
if (other == null)
{
return(false);
}
if (ReferenceEquals(this, other))
{
return(true);
}
return(ProjectStyle == other.ProjectStyle &&
PathUtility.GetStringComparerBasedOnOS().Equals(ProjectPath, other.ProjectPath) &&
PathUtility.GetStringComparerBasedOnOS().Equals(ProjectJsonPath, other.ProjectJsonPath) &&
PathUtility.GetStringComparerBasedOnOS().Equals(OutputPath, other.OutputPath) &&
PathUtility.GetStringComparerBasedOnOS().Equals(ProjectName, other.ProjectName) &&
PathUtility.GetStringComparerBasedOnOS().Equals(ProjectUniqueName, other.ProjectUniqueName) &&
Sources.OrderedEquals(other.Sources.Distinct(), source => source.Source, StringComparer.OrdinalIgnoreCase) &&
PathUtility.GetStringComparerBasedOnOS().Equals(PackagesPath, other.PackagesPath) &&
ConfigFilePaths.OrderedEquals(other.ConfigFilePaths, filePath => filePath, PathUtility.GetStringComparerBasedOnOS(), PathUtility.GetStringComparerBasedOnOS()) &&
FallbackFolders.OrderedEquals(other.FallbackFolders, fallbackFolder => fallbackFolder, PathUtility.GetStringComparerBasedOnOS(), PathUtility.GetStringComparerBasedOnOS()) &&
EqualityUtility.SequenceEqualWithNullCheck(TargetFrameworks, other.TargetFrameworks) &&
OriginalTargetFrameworks.OrderedEquals(other.OriginalTargetFrameworks, fw => fw, StringComparer.OrdinalIgnoreCase, StringComparer.OrdinalIgnoreCase) &&
CrossTargeting == other.CrossTargeting &&
LegacyPackagesDirectory == other.LegacyPackagesDirectory &&
ValidateRuntimeAssets == other.ValidateRuntimeAssets &&
SkipContentFileWrite == other.SkipContentFileWrite &&
EqualityUtility.SequenceEqualWithNullCheck(Files, other.Files) &&
EqualityUtility.EqualsWithNullCheck(ProjectWideWarningProperties, other.ProjectWideWarningProperties));
}
internal TrackingCacheData Merge(ITextSnapshot snapshot, TrackingCacheData trackingCacheData)
{
var left = TrackingSpan.GetSpanSafe(snapshot);
var right = trackingCacheData.TrackingSpan.GetSpanSafe(snapshot);
SnapshotSpan span;
if (left.HasValue && right.HasValue)
{
span = left.Value.CreateOverarching(right.Value);
}
else if (left.HasValue)
{
span = left.Value;
}
else if (right.HasValue)
{
span = right.Value;
}
else
{
span = new SnapshotSpan(snapshot, 0, 0);
}
var trackingSpan = snapshot.CreateTrackingSpan(span, SpanTrackingMode.EdgeInclusive);
var tagList = TrackingList
.Concat(trackingCacheData.TrackingList)
.Distinct(EqualityUtility.Create <Tuple <ITrackingSpan, TTag> >(
(x, y) => x.Item1.GetSpanSafe(snapshot) == y.Item1.GetSpanSafe(snapshot),
tuple => tuple.Item1.GetSpanSafe(snapshot).GetHashCode()))
.ToReadOnlyCollection();
return(new TrackingCacheData(trackingSpan, tagList));
}
private static bool HasProjectDependencyChanged(IEnumerable <LibraryDependency> newDependencies, IEnumerable <LockFileDependency> lockFileDependencies)
{
// If the count is not the same, something has changed.
// Otherwise we N^2 walk below determines whether anything has changed.
var newPackageDependencies = newDependencies.Where(dep => dep.LibraryRange.TypeConstraint == LibraryDependencyTarget.Package);
if (newPackageDependencies.Count() != lockFileDependencies.Count())
{
return(true);
}
foreach (var dependency in newPackageDependencies)
{
var lockFileDependency = lockFileDependencies.FirstOrDefault(d => StringComparer.OrdinalIgnoreCase.Equals(d.Id, dependency.Name));
if (lockFileDependency == null || !EqualityUtility.EqualsWithNullCheck(lockFileDependency.RequestedVersion, dependency.LibraryRange.VersionRange))
{
// dependency has changed and lock file is out of sync.
return(true);
}
}
// no dependency changed. Lock file is still valid.
return(false);
}
public bool Equals(Tuple <T1, T2, T3> other)
{
return(EqualityUtility.NotNullAndSameType(this, other) &&
EqualityUtility.Equals(_item1, other._item1) &&
EqualityUtility.Equals(_item2, other._item2) &&
EqualityUtility.Equals(_item3, other._item3));
}
/// <summary>
/// The method will return true if:
/// 1. If a transitive dependency from the lock file is now added to the central file.
/// or
/// 1. If there is a mistmatch between the RequestedVersion of a lock file dependency marked as CentralTransitive and the the version specified in the central package management file.
/// or
/// 2. If a central version that is a transitive dependency is removed from CPVM the lock file is invalidated.
/// </summary>
private static bool HasProjectTransitiveDependencyChanged(
IDictionary <string, CentralPackageVersion> centralPackageVersions,
IList <LockFileDependency> lockFileCentralTransitiveDependencies,
IList <LockFileDependency> lockTransitiveDependencies)
{
// Transitive dependencies moved to be centraly managed will invalidate the lock file
var transitiveDependenciesMovedToBeManagedCentrally = lockTransitiveDependencies.Where(dep => centralPackageVersions.ContainsKey(dep.Id));
if (transitiveDependenciesMovedToBeManagedCentrally.Any())
{
return(true);
}
foreach (var lockFileDependencyEnforcedByCPV in lockFileCentralTransitiveDependencies)
{
if (centralPackageVersions.TryGetValue(lockFileDependencyEnforcedByCPV.Id, out var centralPackageVersion))
{
if (centralPackageVersion != null && !EqualityUtility.EqualsWithNullCheck(lockFileDependencyEnforcedByCPV.RequestedVersion, centralPackageVersion.VersionRange))
{
return(true);
}
continue;
}
// The central version was removed
return(true);
}
return(false);
}
public bool Equals(ProjectRestoreMetadata other)
{
if (other == null)
{
return(false);
}
if (ReferenceEquals(this, other))
{
return(true);
}
return(ProjectStyle == other.ProjectStyle &&
ProjectPath == other.ProjectPath &&
ProjectJsonPath == other.ProjectJsonPath &&
OutputPath == other.OutputPath &&
ProjectName == other.ProjectName &&
ProjectUniqueName == other.ProjectUniqueName &&
EqualityUtility.SequenceEqualWithNullCheck(Sources, other.Sources) &&
PackagesPath == other.PackagesPath &&
EqualityUtility.SequenceEqualWithNullCheck(ConfigFilePaths, other.ConfigFilePaths) &&
EqualityUtility.SequenceEqualWithNullCheck(FallbackFolders, other.FallbackFolders) &&
EqualityUtility.SequenceEqualWithNullCheck(TargetFrameworks, other.TargetFrameworks) &&
EqualityUtility.SequenceEqualWithNullCheck(OriginalTargetFrameworks, other.OriginalTargetFrameworks) &&
CrossTargeting == other.CrossTargeting &&
LegacyPackagesDirectory == other.LegacyPackagesDirectory &&
ValidateRuntimeAssets == other.ValidateRuntimeAssets &&
SkipContentFileWrite == other.SkipContentFileWrite &&
EqualityUtility.SequenceEqualWithNullCheck(Files, other.Files) &&
EqualityUtility.EqualsWithNullCheck(ProjectWideWarningProperties, other.ProjectWideWarningProperties));
}
/// <summary>
/// Creates a plugin from the discovered plugin.
/// We firstly check the cache for the operation claims for the given request key.
/// If there is a valid cache entry, and it does contain the requested operation claim, then we start the plugin, and if need be update the cache value itself.
/// If there is a valid cache entry, and it does NOT contain the requested operation claim, then we return a null.
/// If there is no valid cache entry or an invalid one, we start the plugin as normally, return an active plugin even if the requested claim is not available, and write a cache entry.
/// </summary>
/// <param name="result">plugin discovery result</param>
/// <param name="requestedOperationClaim">The requested operation claim</param>
/// <param name="requestKey">plugin request key</param>
/// <param name="packageSourceRepository">package source repository</param>
/// <param name="serviceIndex">service index</param>
/// <param name="cancellationToken">cancellation token</param>
/// <returns>A plugin creation result, null if the requested plugin cannot handle the given operation claim</returns>
private async Task <Tuple <bool, PluginCreationResult> > TryCreatePluginAsync(
PluginDiscoveryResult result,
OperationClaim requestedOperationClaim,
PluginRequestKey requestKey,
string packageSourceRepository,
JObject serviceIndex,
CancellationToken cancellationToken)
{
PluginCreationResult pluginCreationResult = null;
var cacheEntry = new PluginCacheEntry(_pluginsCacheDirectory.Value, result.PluginFile.Path, requestKey.PackageSourceRepository);
return(await ConcurrencyUtilities.ExecuteWithFileLockedAsync(
cacheEntry.CacheFileName,
action : async lockedToken =>
{
if (cacheEntry.OperationClaims == null || cacheEntry.OperationClaims.Contains(requestedOperationClaim))
{
if (result.PluginFile.State.Value == PluginFileState.Valid)
{
var plugin = await _pluginFactory.GetOrCreateAsync(
result.PluginFile.Path,
PluginConstants.PluginArguments,
new RequestHandlers(),
_connectionOptions,
cancellationToken);
var utilities = await PerformOneTimePluginInitializationAsync(plugin, cancellationToken);
// We still make the GetOperationClaims call even if we have the operation claims cached. This is a way to self-update the cache.
var operationClaims = await _pluginOperationClaims.GetOrAdd(
requestKey,
key => new Lazy <Task <IReadOnlyList <OperationClaim> > >(() =>
GetPluginOperationClaimsAsync(
plugin,
packageSourceRepository,
serviceIndex,
cancellationToken))).Value;
if (!EqualityUtility.SequenceEqualWithNullCheck(operationClaims, cacheEntry.OperationClaims))
{
cacheEntry.OperationClaims = operationClaims;
await cacheEntry.UpdateCacheFileAsync();
}
pluginCreationResult = new PluginCreationResult(
plugin,
utilities.Value,
operationClaims);
}
else
{
pluginCreationResult = new PluginCreationResult(result.Message);
}
}
return new Tuple <bool, PluginCreationResult>(pluginCreationResult != null, pluginCreationResult);
},
token : cancellationToken
));
}
public void DictionaryEquals_CompareWithNullDict_ReturnsFalse()
{
// Arrange
var dict = new Dictionary <int, string>();
// Act & Assert
EqualityUtility.DictionaryEquals(dict, null).Should().BeFalse();
}
public void DictionaryEquals_CompareSameDicts_ReturnsTrue()
{
// Arrange
var dict = new Dictionary <int, string>();
// Act & Assert
EqualityUtility.DictionaryEquals(dict, dict).Should().BeTrue();
}
private static void ValidateProjectSpecPackageReference(PackageSpec spec, IEnumerable <string> files)
{
// Verify frameworks
ValidateFrameworks(spec, files);
// NETCore may not specify a project.json file
if (!string.IsNullOrEmpty(spec.RestoreMetadata.ProjectJsonPath))
{
var message = string.Format(
CultureInfo.CurrentCulture,
Strings.PropertyNotAllowedForProjectType,
nameof(spec.RestoreMetadata.ProjectJsonPath),
ProjectStyle.PackageReference.ToString());
throw RestoreSpecException.Create(message, files);
}
// Output path must be set for netcore
if (string.IsNullOrEmpty(spec.RestoreMetadata.OutputPath))
{
var message = string.Format(
CultureInfo.CurrentCulture,
Strings.MissingRequiredPropertyForProjectType,
nameof(spec.RestoreMetadata.OutputPath),
ProjectStyle.PackageReference.ToString());
throw RestoreSpecException.Create(message, files);
}
// Original frameworks must be set for netcore
if (spec.RestoreMetadata.OriginalTargetFrameworks.Count < 1)
{
var message = string.Format(
CultureInfo.CurrentCulture,
Strings.MissingRequiredPropertyForProjectType,
nameof(spec.RestoreMetadata.OriginalTargetFrameworks),
ProjectStyle.PackageReference.ToString());
throw RestoreSpecException.Create(message, files);
}
//OriginalTargetFrameworks must match the aliases.
if (spec.RestoreMetadata.TargetFrameworks.Count > 1)
{
var aliases = spec.TargetFrameworks.Select(e => e.TargetAlias);
if (!EqualityUtility.OrderedEquals(aliases, spec.RestoreMetadata.OriginalTargetFrameworks, e => e, StringComparer.OrdinalIgnoreCase, StringComparer.OrdinalIgnoreCase))
{
var message = string.Format(
CultureInfo.CurrentCulture,
Strings.SpecValidation_OriginalTargetFrameworksMustMatchAliases,
string.Join(";", spec.RestoreMetadata.OriginalTargetFrameworks),
string.Join(";", aliases)
);
throw RestoreSpecException.Create(message, files);
}
}
}
public bool Equals([CanBeNull] CustomType other)
{
if (!EqualityUtility.ClassEquals(this, other))
{
return(false);
}
Trace.Assert(other != null);
return(_value == other._value);
}
public bool Equals([CanBeNull] TypeKey other)
{
if (!EqualityUtility.ClassEquals(this, other))
{
return(false);
}
Trace.Assert(other != null);
return(_type == other._type);
}
public bool Equals([CanBeNull] MemberKeyPart other)
{
if (!EqualityUtility.ClassEquals(this, other))
{
return(false);
}
Trace.Assert(other != null);
return(Member.Name == other.Member.Name && MemberType == other.MemberType);
}
public static bool IsLockFileStillValid(DependencyGraphSpec dgSpec, PackagesLockFile nuGetLockFile)
{
var uniqueName = dgSpec.Restore.First();
var project = dgSpec.GetProjectSpec(uniqueName);
// Validate all the direct dependencies
foreach (var framework in project.TargetFrameworks)
{
var target = nuGetLockFile.Targets.FirstOrDefault(
t => EqualityUtility.EqualsWithNullCheck(t.TargetFramework, framework.FrameworkName));
if (target != null)
{
var directDependencies = target.Dependencies.Where(dep => dep.Type == PackageDependencyType.Direct);
if (HasProjectDependencyChanged(framework.Dependencies, directDependencies))
{
// lock file is out of sync
return(false);
}
}
}
// Validate all P2P references
foreach (var p2p in dgSpec.Projects)
{
if (PathUtility.GetStringComparerBasedOnOS().Equals(p2p.RestoreMetadata.ProjectUniqueName, uniqueName))
{
continue;
}
var projectName = Path.GetFileNameWithoutExtension(p2p.RestoreMetadata.ProjectPath);
foreach (var framework in p2p.TargetFrameworks)
{
var target = nuGetLockFile.Targets.FirstOrDefault(
t => EqualityUtility.EqualsWithNullCheck(t.TargetFramework, framework.FrameworkName));
if (target != null)
{
var projectDependency = target.Dependencies.FirstOrDefault(
dep => dep.Type == PackageDependencyType.Project &&
PathUtility.GetStringComparerBasedOnOS().Equals(dep.Id, projectName));
if (HasP2PDependencyChanged(framework.Dependencies, projectDependency))
{
// lock file is out of sync
return(false);
}
}
}
}
return(true);
}
public ConstructionKey(AssembledTypeID typeID, Type delegateType, bool allowNonPublic)
{
ArgumentUtility.DebugCheckNotNull("delegateType", delegateType);
_typeID = typeID;
_delegateType = delegateType;
_allowNonPublic = allowNonPublic;
// Pre-compute hash code.
_hashCode = EqualityUtility.GetRotatedHashCode(_typeID.GetHashCode(), delegateType, allowNonPublic);
}
protected new int GetHashCode()
{
var fieldValues = new object[s_targetFields.Length];
for (int i = 0; i < fieldValues.Length; ++i)
{
fieldValues[i] = s_targetFields[i].GetValue(Target);
}
return(EqualityUtility.GetRotatedHashCode(fieldValues));
}
public AssembledTypeID(Type requestedType, object[] parts)
{
ArgumentUtility.DebugCheckNotNull("requestedType", requestedType);
ArgumentUtility.DebugCheckNotNull("parts", parts);
_requestedType = requestedType;
_parts = parts;
// Pre-compute hash code.
_hashCode = requestedType.GetHashCode() ^ EqualityUtility.GetRotatedHashCode(_parts);
}
public CustomAttributeDataCacheKey(ICustomAttributeProvider attributeTarget, bool inherit)
{
ArgumentUtility.DebugCheckNotNull("attributeTarget", attributeTarget);
Assertion.DebugAssert(!(attributeTarget is IMutableMember));
_attributeTarget = attributeTarget;
_inherit = inherit;
// Pre-compute hash code.
_hashCode = EqualityUtility.GetRotatedHashCode(RuntimeHelpers.GetHashCode(attributeTarget), inherit);
}
private static (bool, string) HasDirectPackageDependencyChanged(IEnumerable <LibraryDependency> newDependencies, IEnumerable <LockFileDependency> lockFileDependencies, NuGetFramework nuGetFramework)
{
// If the count is not the same, something has changed.
// Otherwise the N^2 walk below determines whether anything has changed.
var newPackageDependencies = newDependencies.Where(dep => dep.LibraryRange.TypeConstraint == LibraryDependencyTarget.Package);
var newPackageDependenciesCount = newPackageDependencies.Count();
var lockFileDependenciesCount = lockFileDependencies.Count();
if (newPackageDependenciesCount != lockFileDependenciesCount)
{
return(true,
string.Format(
CultureInfo.CurrentCulture,
Strings.PackagesLockFile_PackageReferencesHaveChanged,
nuGetFramework.GetShortFolderName(),
lockFileDependenciesCount > 0 ? string.Join(", ", lockFileDependencies.Select(e => e.Id + ":" + e.RequestedVersion.ToNormalizedString()).OrderBy(dep => dep)) : Strings.None,
newPackageDependenciesCount > 0 ? string.Join(", ", newPackageDependencies.Select(e => e.LibraryRange.Name + ":" + e.LibraryRange.VersionRange.ToNormalizedString()).OrderBy(dep => dep)) : Strings.None)
);
}
foreach (var dependency in newPackageDependencies)
{
var lockFileDependency = lockFileDependencies.FirstOrDefault(d => StringComparer.OrdinalIgnoreCase.Equals(d.Id, dependency.Name));
if (lockFileDependency == null)
{
// dependency has changed and lock file is out of sync.
return(true,
string.Format(
CultureInfo.CurrentCulture,
Strings.PackagesLockFile_PackageReferenceAdded,
dependency.Name,
nuGetFramework.GetShortFolderName())
);
}
if (!EqualityUtility.EqualsWithNullCheck(lockFileDependency.RequestedVersion, dependency.LibraryRange.VersionRange))
{
// dependency has changed and lock file is out of sync.
return(true,
string.Format(
CultureInfo.CurrentCulture,
Strings.PackagesLockFile_PackageReferenceVersionChanged,
dependency.Name,
lockFileDependency.RequestedVersion.ToNormalizedString(),
dependency.LibraryRange.VersionRange.ToNormalizedString())
);
}
}
// no dependency changed. Lock file is still valid.
return(false, string.Empty);
}
public ConstructorForAssembledTypeCacheKey(Type assembledType, Type delegateType, bool allowNonPublic)
{
ArgumentUtility.DebugCheckNotNull("assembledType", assembledType);
ArgumentUtility.DebugCheckNotNull("delegateType", delegateType);
_assembledType = assembledType;
_delegateType = delegateType;
_allowNonPublic = allowNonPublic;
// Pre-compute hash code.
_hashCode = EqualityUtility.GetRotatedHashCode(_assembledType.GetHashCode(), delegateType, allowNonPublic);
}
/// <summary>
/// Initializes a new instance of the <see cref="ConcreteMixinTypeIdentifier"/> class.
/// </summary>
/// <param name="mixinType">The mixin type for which a concrete type was generated.</param>
/// <param name="overriders">Mixin methods that override methods of the target class.</param>
/// <param name="overridden">Mixin methods that are overridden by the target class.</param>
public ConcreteMixinTypeIdentifier(Type mixinType, HashSet <MethodInfo> overriders, HashSet <MethodInfo> overridden)
{
ArgumentUtility.CheckNotNull("mixinType", mixinType);
ArgumentUtility.CheckNotNull("overriders", overriders);
ArgumentUtility.CheckNotNull("overridden", overridden);
_mixinType = mixinType;
_overriders = overriders;
_overridden = overridden;
_cachedHashCode = MixinType.GetHashCode()
^ EqualityUtility.GetXorHashCode(_overriders)
^ EqualityUtility.GetXorHashCode(_overridden);
}
public override int GetHashCode()
{
return(EqualityUtility.GetRotatedHashCode(
_dataInfo,
_selectProjection,
_whereCondition,
_topExpression,
_isDistinctQuery,
_rowNumberSelector,
_currentRowNumberOffset,
_groupByExpression)
^ EqualityUtility.GetRotatedHashCode(_sqlTables)
^ EqualityUtility.GetRotatedHashCode(_orderings));
}
public LocalPackageInfo FindPackage(string packageId, NuGetVersion version)
{
LocalPackageInfo package = null;
var packages = FindPackagesByIdImpl(packageId);
var count = packages.Count;
for (var i = 0; i < count; i++)
{
var candidatePackage = packages[i];
if (candidatePackage.Version == version)
{
package = candidatePackage;
break;
}
}
if (package == null)
{
return(null);
}
// Check for an exact match on casing
if (StringComparer.Ordinal.Equals(packageId, package.Id) &&
EqualityUtility.SequenceEqualWithNullCheck(version.ReleaseLabels, package.Version.ReleaseLabels, StringComparer.Ordinal))
{
return(package);
}
// nuspec
var nuspec = _packageFileCache.GetOrAddNuspec(package.ManifestPath, package.ExpandedPath);
// files
var files = _packageFileCache.GetOrAddFiles(package.ExpandedPath);
// sha512
var sha512 = _packageFileCache.GetOrAddSha512(package.Sha512Path);
// Create a new info to match the given id/version
return(new LocalPackageInfo(
packageId,
version,
package.ExpandedPath,
package.ManifestPath,
package.ZipPath,
package.Sha512Path,
nuspec,
files,
sha512));
}
/// <summary>
/// The method will return true if:
/// 1. If a transitive dependency from the lock file is now added to the central file.
/// or
/// 1. If there is a mistmatch between the RequestedVersion of a lock file dependency marked as CentralTransitive and the the version specified in the central package management file.
/// or
/// 2. If a central version that is a transitive dependency is removed from CPVM the lock file is invalidated.
/// </summary>
private static (bool, string) HasProjectTransitiveDependencyChanged(
IDictionary <string, CentralPackageVersion> centralPackageVersions,
IList <LockFileDependency> lockFileCentralTransitiveDependencies,
IList <LockFileDependency> lockTransitiveDependencies)
{
// Transitive dependencies moved to be centraly managed will invalidate the lock file
LockFileDependency dependency = lockTransitiveDependencies.FirstOrDefault(dep => centralPackageVersions.ContainsKey(dep.Id));
if (dependency != null)
{
return(true,
string.Format(
CultureInfo.CurrentCulture,
Strings.PackagesLockFile_ProjectTransitiveDependencyChanged,
dependency.Id
)
);
}
foreach (var lockFileDependencyEnforcedByCPV in lockFileCentralTransitiveDependencies)
{
if (centralPackageVersions.TryGetValue(lockFileDependencyEnforcedByCPV.Id, out var centralPackageVersion))
{
if (centralPackageVersion != null && !EqualityUtility.EqualsWithNullCheck(lockFileDependencyEnforcedByCPV.RequestedVersion, centralPackageVersion.VersionRange))
{
return(true,
string.Format(
CultureInfo.CurrentCulture,
Strings.PackagesLockFile_ProjectTransitiveDependencyVersionChanged,
lockFileDependencyEnforcedByCPV.RequestedVersion.ToNormalizedString(),
centralPackageVersion.VersionRange.ToNormalizedString()
)
);
}
continue;
}
// The central version was removed
return(true,
string.Format(
CultureInfo.CurrentCulture,
Strings.PackagesLockFile_CentralPackageVersionRemoved,
lockFileDependencyEnforcedByCPV.Id
)
);
}
return(false, string.Empty);
}
public void DictionaryEquals_CompareEquivalentDicts_ReturnsTrue()
{
// Arrange
var dict1 = new Dictionary <int, string>()
{
{ 1, "unit.test" }
};
var dict2 = new Dictionary <int, string>()
{
{ 1, "unit.test" }
};
// Act & Assert
EqualityUtility.DictionaryEquals(dict1, dict2).Should().BeTrue();
}
public bool Equals(LockFileDependency x, LockFileDependency y)
{
if (ReferenceEquals(x, y))
{
return(true);
}
if (x == null || y == null)
{
return(false);
}
return(StringComparer.OrdinalIgnoreCase.Equals(x.Id, y.Id) &&
EqualityUtility.EqualsWithNullCheck(x.ResolvedVersion, y.ResolvedVersion));
}
public bool Equals(NodeWarningProperties other)
{
if (other == null)
{
return(false);
}
if (ReferenceEquals(this, other))
{
return(true);
}
return(EqualityUtility.SetEqualsWithNullCheck(ProjectWide, other.ProjectWide) &&
EqualityUtility.DictionaryEquals(PackageSpecific, other.PackageSpecific, (s, o) => EqualityUtility.SetEqualsWithNullCheck(s, o)));
}
public void GetXorHashCode()
{
IEnumerable objects1 = new int[] { 1, 2, 3 };
IEnumerable objects2 = new int[] { 1, 2, 3 };
Assert.That(EqualityUtility.GetXorHashCode(objects2), Is.EqualTo(EqualityUtility.GetXorHashCode(objects1)));
IEnumerable objects3 = new int[] { 3, 2, 1 };
Assert.That(EqualityUtility.GetXorHashCode(objects3), Is.EqualTo(EqualityUtility.GetXorHashCode(objects1)));
IEnumerable objects4 = new int[] { 1, 2, 17 };
Assert.That(EqualityUtility.GetXorHashCode(objects4), Is.Not.EqualTo(EqualityUtility.GetXorHashCode(objects1)));
}
public void GetRotatedHashCode_Nulls()
{
var array1 = new object[] { 1, null, 2 };
var array2 = new object[] { 1, null, 2 };
var array3 = new object[] { 1, null, null, 2 };
Assert.That(EqualityUtility.GetRotatedHashCode(array1), Is.EqualTo(EqualityUtility.GetRotatedHashCode(array2)));
Assert.That(EqualityUtility.GetRotatedHashCode(array1), Is.Not.EqualTo(EqualityUtility.GetRotatedHashCode(array3)));
Assert.That(EqualityUtility.GetRotatedHashCode((IEnumerable)array1), Is.EqualTo(EqualityUtility.GetRotatedHashCode((IEnumerable)array2)));
Assert.That(EqualityUtility.GetRotatedHashCode((IEnumerable)array1), Is.Not.EqualTo(EqualityUtility.GetRotatedHashCode((IEnumerable)array3)));
Assert.That(EqualityUtility.GetRotatedHashCode(array1), Is.EqualTo(EqualityUtility.GetRotatedHashCode((IEnumerable)array1)));
Assert.That(EqualityUtility.GetRotatedHashCode(array3), Is.EqualTo(EqualityUtility.GetRotatedHashCode((IEnumerable)array3)));
}
