/// <inheritdoc/>
protected override int GetHashCode(object item, ValuerChainer valuer)
{
if (item == null)
{
throw new ArgumentNullException(nameof(item));
}
if (valuer == null)
{
throw new ArgumentNullException(nameof(valuer));
}
Type type = item.GetType();
int hash = ValueComparer.BaseHash + type.GetHashCode();
foreach (PropertyInfo property in type.GetProperties(_scope).Where(p => p.CanRead))
{
hash = hash * ValueComparer.HashMultiplier + valuer.GetHashCode(property.GetValue(item));
}
foreach (FieldInfo field in type.GetFields(_scope))
{
hash = hash * ValueComparer.HashMultiplier + valuer.GetHashCode(field.GetValue(item));
}
return(hash);
}
/// <inheritdoc cref="Compare"/>
private static IEnumerable <Difference> LazyCompare(
IEnumerable expected, IEnumerable actual, ValuerChainer valuer)
{
IEnumerator expectedEnumerator = expected.GetEnumerator();
IEnumerator actualEnumerator = actual.GetEnumerator();
int index = 0;
while (expectedEnumerator.MoveNext())
{
if (actualEnumerator.MoveNext())
{
foreach (Difference diff in valuer.Compare(expectedEnumerator.Current, actualEnumerator.Current))
{
yield return(new Difference(index, diff));
}
}
else
{
yield return(new Difference(index, new Difference(expectedEnumerator.Current, "'outofbounds'")));
}
index++;
}
while (actualEnumerator.MoveNext())
{
yield return(new Difference(index++, new Difference("'outofbounds'", actualEnumerator.Current)));
}
}
/// <inheritdoc cref="Compare"/>
/// <typeparam name="T">Item type being compared.</typeparam>
private static async Task <IEnumerable <Difference> > CompareAsync <T>(
IAsyncEnumerable <T> expected, IAsyncEnumerable <T> actual, ValuerChainer valuer)
{
await using IAsyncEnumerator <T> expectedEnumerator = expected.GetAsyncEnumerator();
await using IAsyncEnumerator <T> actualEnumerator = actual.GetAsyncEnumerator();
int index = 0;
List <Difference> differences = new();
while (await expectedEnumerator.MoveNextAsync().ConfigureAwait(false))
{
if (await actualEnumerator.MoveNextAsync().ConfigureAwait(false))
{
differences.AddRange(valuer
.Compare(expectedEnumerator.Current, actualEnumerator.Current)
.Select(diff => new Difference(index, diff)));
}
else
{
differences.Add(new Difference(index, new Difference(expectedEnumerator.Current, "'outofbounds'")));
}
index++;
}
while (await actualEnumerator.MoveNextAsync().ConfigureAwait(false))
{
differences.Add(new Difference(index++, new Difference("'outofbounds'", actualEnumerator.Current)));
}
return(differences);
}
/// <inheritdoc cref="Compare"/>
private static IEnumerable <Difference> LazyCompare(
IDictionary expected, IDictionary actual, ValuerChainer valuer)
{
object[] expectedKeys = expected.Keys.Cast <object>().ToArray();
object[] actualKeys = actual.Keys.Cast <object>().ToArray();
foreach (object key in expectedKeys)
{
object match = actualKeys.FirstOrDefault(k => valuer.Equals(key, k));
if (match != null)
{
foreach (Difference diff in valuer.Compare(expected[key], actual[match]))
{
yield return(new Difference($"[{key}]", diff));
}
}
else
{
yield return(new Difference($"[{key}]", new Difference(expected[key], "'null'")));
}
}
foreach (object key in actualKeys)
{
if (!expectedKeys.Any(k => valuer.Equals(key, k)))
{
yield return(new Difference($"[{key}]", new Difference("'null'", actual[key])));
}
}
}
/// <inheritdoc/>
protected override int GetHashCode(IFaked item, ValuerChainer valuer)
{
if (valuer == null)
{
throw new ArgumentNullException(nameof(valuer));
}
return(valuer.GetHashCode(item?.FakeMeta));
}
/// <inheritdoc/>
protected override int GetHashCode(Task item, ValuerChainer valuer)
{
if (valuer == null)
{
throw new ArgumentNullException(nameof(valuer));
}
return(valuer.GetHashCode(ExtractResult(item)));
}
/// <inheritdoc/>
protected override int GetHashCode(object item, ValuerChainer valuer)
{
if (item == null)
{
throw new ArgumentNullException(nameof(item));
}
return(item.GetType().GetHashCode());
}
/// <inheritdoc/>
protected override int GetHashCode(StringDictionary item, ValuerChainer valuer)
{
if (valuer == null)
{
throw new ArgumentNullException(nameof(valuer));
}
return(valuer.GetHashCode(Convert(item)));
}
/// <inheritdoc/>
protected override IEnumerable <Difference> Compare(
StringDictionary expected, StringDictionary actual, ValuerChainer valuer)
{
if (valuer == null)
{
throw new ArgumentNullException(nameof(valuer));
}
return(valuer.Compare(Convert(expected), Convert(actual)));
}
/// <inheritdoc/>
protected override bool Supports(object expected, object actual, ValuerChainer valuer)
{
if (expected == null)
{
throw new ArgumentNullException(nameof(expected));
}
if (actual == null)
{
throw new ArgumentNullException(nameof(actual));
}
return(expected.GetType().Inherits(typeof(IAsyncEnumerable <>)) &&
actual.GetType().Inherits(typeof(IAsyncEnumerable <>)));
}
/// <inheritdoc/>
protected override bool Supports(object expected, object actual, ValuerChainer valuer)
{
if (expected == null)
{
throw new ArgumentNullException(nameof(expected));
}
if (actual == null)
{
throw new ArgumentNullException(nameof(actual));
}
return(expected.GetType().Inherits(typeof(IEquatable <>).MakeGenericType(expected.GetType())) &&
!(expected is IStructuralEquatable));
}
/// <inheritdoc/>
protected override bool Supports(object expected, object actual, ValuerChainer valuer)
{
Type objectType = expected?.GetType();
return(objectType == null ||
actual == null ||
(objectType != actual.GetType() &&
!objectType.Inherits(typeof(IAsyncEnumerable <>))) ||
objectType.IsPrimitive ||
objectType.IsEnum ||
objectType == typeof(string) ||
objectType == typeof(object) ||
expected is Delegate ||
expected is Type);
}
/// <inheritdoc/>
protected override bool Supports(object expected, object actual, ValuerChainer valuer)
{
if (expected == null)
{
throw new ArgumentNullException(nameof(expected));
}
if (actual == null)
{
throw new ArgumentNullException(nameof(actual));
}
Type type = expected.GetType();
return(!type.GetProperties(_Scope).Any(p => p.CanRead) &&
!type.GetFields(_Scope).Any());
}
/// <inheritdoc/>
protected override int GetHashCode(object item, ValuerChainer valuer)
{
if (item == null)
{
throw new ArgumentNullException(nameof(item));
}
if (valuer == null)
{
throw new ArgumentNullException(nameof(valuer));
}
return(Task.Run(() => ((Task <int>)GetType()
.GetMethod(nameof(GetHashCodeAsync), BindingFlags.Static | BindingFlags.NonPublic)
.MakeGenericMethod(item.GetType().GetGenericArguments().Single())
.Invoke(null, new object[] { item, valuer }))).Result);
}
/// <inheritdoc/>
protected override IEnumerable <Difference> Compare(
IDictionary expected, IDictionary actual, ValuerChainer valuer)
{
if (expected == null)
{
throw new ArgumentNullException(nameof(expected));
}
if (actual == null)
{
throw new ArgumentNullException(nameof(actual));
}
if (valuer == null)
{
throw new ArgumentNullException(nameof(valuer));
}
return(LazyCompare(expected, actual, valuer));
}
/// <inheritdoc/>
protected override int GetHashCode(IEnumerable item, ValuerChainer valuer)
{
if (item == null)
{
throw new ArgumentNullException(nameof(item));
}
if (valuer == null)
{
throw new ArgumentNullException(nameof(valuer));
}
int hash = ValueComparer.BaseHash;
foreach (object value in item)
{
hash = hash * ValueComparer.HashMultiplier + valuer.GetHashCode(value);
}
return(hash);
}
/// <inheritdoc/>
protected override int GetHashCode(IDictionary item, ValuerChainer valuer)
{
if (item == null)
{
throw new ArgumentNullException(nameof(item));
}
if (valuer == null)
{
throw new ArgumentNullException(nameof(valuer));
}
int hash = ValueComparer.BaseHash;
foreach (DictionaryEntry entry in item)
{
hash += valuer.GetHashCode(entry.Key, entry.Value);
}
return(hash);
}
/// <inheritdoc cref="Compare"/>
private IEnumerable <Difference> LazyCompare(object expected, object actual, ValuerChainer valuer)
{
Type type = expected.GetType();
foreach (PropertyInfo property in type.GetProperties(_scope).Where(p => p.CanRead))
{
foreach (Difference diff in valuer.Compare(property.GetValue(expected), property.GetValue(actual)))
{
yield return(new Difference(property, diff));
}
}
foreach (FieldInfo field in expected.GetType().GetFields(_scope))
{
foreach (Difference diff in valuer.Compare(field.GetValue(expected), field.GetValue(actual)))
{
yield return(new Difference(field, diff));
}
}
}
/// <inheritdoc/>
protected override IEnumerable <Difference> Compare(
object expected, object actual, ValuerChainer valuer)
{
if (expected == null)
{
throw new ArgumentNullException(nameof(expected));
}
if (actual == null)
{
throw new ArgumentNullException(nameof(actual));
}
if (valuer == null)
{
throw new ArgumentNullException(nameof(valuer));
}
return(Task.Run(() => ((Task <IEnumerable <Difference> >)GetType()
.GetMethod(nameof(CompareAsync), BindingFlags.Static | BindingFlags.NonPublic)
.MakeGenericMethod(expected.GetType().GetGenericArguments().Single())
.Invoke(null, new object[] { expected, actual, valuer }))).Result);
}
/// <inheritdoc/>
protected override IEnumerable <Difference> Compare(IFaked expected, IFaked actual, ValuerChainer valuer)
{
if (valuer == null)
{
throw new ArgumentNullException(nameof(valuer));
}
return(valuer.Compare(expected?.FakeMeta, actual?.FakeMeta));
}
/// <inheritdoc/>
protected override IEnumerable <Difference> Compare(object expected, object actual, ValuerChainer valuer)
{
if (expected == null)
{
throw new ArgumentNullException(nameof(expected));
}
if (!expected.Equals(actual))
{
return(new[] { new Difference(expected, actual) });
}
else
{
return(Enumerable.Empty <Difference>());
}
}
/// <inheritdoc cref="GetHashCode"/>
/// <typeparam name="T">Item type being compared.</typeparam>
private static async Task <int> GetHashCodeAsync <T>(IAsyncEnumerable <T> item, ValuerChainer valuer)
{
int hash = ValueComparer.BaseHash;
await foreach (T current in item)
{
hash = hash * ValueComparer.HashMultiplier + valuer.GetHashCode(current);
}
return(hash);
}
/// <inheritdoc/>
protected override IEnumerable <Difference> Compare(object expected, object actual, ValuerChainer valuer)
{
if (expected == null && actual == null)
{
yield break;
}
if (expected == null || actual == null)
{
yield return(new Difference(expected, actual));
}
else if (expected.GetType() != actual.GetType())
{
yield return(new Difference(expected.GetType(), actual.GetType()));
}
else if (!expected.Equals(actual))
{
yield return(new Difference(expected, actual));
}
}
/// <inheritdoc/>
protected override int GetHashCode(object item, ValuerChainer valuer)
{
return(ValueComparer.Use.GetHashCode(item));
}
/// <inheritdoc/>
protected override IEnumerable <Difference> Compare(object expected, object actual, ValuerChainer valuer)
{
return(Enumerable.Empty <Difference>());
}
/// <inheritdoc/>
protected override IEnumerable <Difference> Compare(Task expected, Task actual, ValuerChainer valuer)
{
if (valuer == null)
{
throw new ArgumentNullException(nameof(valuer));
}
return(valuer.Compare(ExtractResult(expected), ExtractResult(actual)));
}
