public override void VerifyMethod <T>(
ReferenceHandling referenceHandling = ReferenceHandling.Structural,
string excludedMembers = null,
Type ignoredType = null,
Type immutableType = null)
{
var builder = FieldsSettings.Build();
if (excludedMembers != null)
{
builder.AddIgnoredField <T>(excludedMembers);
}
if (ignoredType != null)
{
builder.AddImmutableType(ignoredType);
}
if (immutableType != null)
{
builder.AddImmutableType(immutableType);
}
var settings = builder.CreateSettings(referenceHandling);
EqualBy.VerifyCanEqualByFieldValues <T>(settings);
}
public override void CopyMethod <T>(
T source,
T target,
ReferenceHandling referenceHandling = ReferenceHandling.Structural,
string excluded = null,
Type ignoredType = null,
Type immutableType = null)
{
var builder = FieldsSettings.Build();
if (excluded != null)
{
builder.AddIgnoredField <T>(excluded);
}
if (ignoredType != null)
{
builder.IgnoreType(ignoredType);
}
if (immutableType != null)
{
builder.AddImmutableType(immutableType);
}
var settings = builder.CreateSettings(referenceHandling);
Copy.FieldValues(source, target, settings);
}
public override Diff DiffMethod <T>(
T x,
T y,
ReferenceHandling referenceHandling = ReferenceHandling.Structural,
string excludedMembers = null,
Type ignoredType = null,
Type immutableType = null)
{
var builder = FieldsSettings.Build();
if (excludedMembers != null)
{
builder.AddIgnoredField <T>(excludedMembers);
}
if (ignoredType != null)
{
builder.IgnoreType(ignoredType);
}
if (immutableType != null)
{
builder.AddImmutableType(immutableType);
}
var settings = builder.CreateSettings(referenceHandling);
return(DiffBy.FieldValues(x, y, settings));
}
public override bool EqualByMethod <T, TValue>(T x, T y, IEqualityComparer <TValue> comparer, ReferenceHandling referenceHandling = ReferenceHandling.Structural)
{
var builder = FieldsSettings.Build();
builder.AddComparer(comparer);
var settings = builder.CreateSettings(referenceHandling);
return(EqualBy.FieldValues(x, y, settings));
}
public void Ignores()
{
var type = typeof(ComplexType);
var nameField = type.GetField(nameof(ComplexType.Name));
var valueField = type.GetField(nameof(ComplexType.Value));
var settings = new FieldsSettings(new[] { nameField }, null, null, null, null, ReferenceHandling.Throw, Constants.DefaultFieldBindingFlags);
Assert.AreEqual(true, settings.IsIgnoringField(nameField));
Assert.AreEqual(false, settings.IsIgnoringField(valueField));
}
public void Cache(BindingFlags bindingFlags, ReferenceHandling referenceHandling)
{
var settings = FieldsSettings.GetOrCreate(referenceHandling, bindingFlags);
Assert.AreEqual(bindingFlags, settings.BindingFlags);
Assert.AreEqual(referenceHandling, settings.ReferenceHandling);
var second = FieldsSettings.GetOrCreate(referenceHandling, BindingFlags.Public);
Assert.AreSame(settings, second);
}
public void IgnoresWithBuilder()
{
var type = typeof(ComplexType);
var settings = FieldsSettings.Build()
.AddIgnoredField <ComplexType>(nameof(ComplexType.Name))
.CreateSettings();
var nameField = type.GetField(nameof(ComplexType.Name), Constants.DefaultFieldBindingFlags);
Assert.AreEqual(true, settings.IsIgnoringField(nameField));
var valueField = type.GetField(nameof(ComplexType.Value), Constants.DefaultFieldBindingFlags);
Assert.AreEqual(false, settings.IsIgnoringField(valueField));
}
public void IgnoresCollectionFields(Type type)
{
var settings = FieldsSettings.GetOrCreate();
var fieldInfos = type.GetFields(Constants.DefaultFieldBindingFlags);
if (type != typeof(int[]))
{
CollectionAssert.IsNotEmpty(fieldInfos);
}
foreach (var fieldInfo in fieldInfos)
{
Assert.AreEqual(true, settings.IsIgnoringField(fieldInfo));
}
}
public void IgnoresIteratorFields()
{
var enumaberbles = new object[]
{
Enumerable.Repeat(1, 0),
new[] { 1 }.Where(x => x > 1),
new[] { 1 }.Select(x => x)
};
foreach (var enumerable in enumaberbles)
{
var type = enumerable.GetType();
var settings = FieldsSettings.GetOrCreate();
var fieldInfos = type.GetFields(Constants.DefaultFieldBindingFlags);
CollectionAssert.IsNotEmpty(fieldInfos);
foreach (var fieldInfo in fieldInfos)
{
Assert.AreEqual(true, settings.IsIgnoringField(fieldInfo));
}
}
}
public void IgnoresNull()
{
var settings = FieldsSettings.GetOrCreate();
Assert.AreEqual(true, settings.IsIgnoringField(null));
}
