public void ValidateExpressionWithMethodCall()
{
var target = new EqualityChecker <Person>();
// Method calls are not allowed in the expression.
target.Ignore(p => p.GetAddress().Line1);
}
public static bool AreEqual <T, U> (IList <T> list1, IList <U> list2)
{
bool equal = true;
if (typeof(T) != typeof(U))
{
equal = false;
}
else if (!EqualityChecker.AreEqual(list1, list2))
{
if (list1.Count != list2.Count)
{
equal = false;
}
else
{
int length = list1.Count;
for (int i = 0; i < length; i++)
{
if (!EqualityChecker.AreEqual(list1[i], list2[i]))
{
equal = false;
break;
}
}
}
}
return(equal);
}
public void ValidateExpressionSuccess()
{
var target = new EqualityChecker <Person>();
// This expression is OK.
target.Ignore(p => p.HomeAddress.City);
}
public static bool AreEqual <T, U, V, W>(IDictionary <T, U> dict1, IDictionary <V, W> dict2) where V : class
{
bool equal = true;
if (typeof(T) != typeof(V) || typeof(U) != typeof(W))
{
equal = false;
}
else if (!EqualityChecker.AreEqual(dict1, dict2))
{
if (dict1.Count != dict2.Count)
{
equal = false;
}
else
{
foreach (KeyValuePair <T, U> pair in dict1)
{
V key = pair.Key as V;
if (!dict2.ContainsKey(key) || !EqualityChecker.AreEqual(pair.Value, dict2[key]))
{
equal = false;
break;
}
}
}
}
return(equal);
}
public void ValidateExpressionFail()
{
var target = new EqualityChecker <Person>();
var person = new Person();
// This expression does not use the parameter of the lambda expression, p.
target.Ignore(p => person.HomeAddress.City);
}
public void CircularReferenceBreaks()
{
var obj1 = new SelfReferencingObject();
var obj2 = new SelfReferencingObject();
var target = new EqualityChecker <SelfReferencingObject>();
target.HaveEqualValues(obj1, obj2);
}
public void CompareObjectsWithStringsAndEnums()
{
var person1 = GetDefaultPerson();
var person2 = GetDefaultPerson();
var equalityChecker = new EqualityChecker <Person>();
var equal = equalityChecker.HaveEqualValues(person1, person2);
Assert.IsTrue(equal);
}
public void AddressDifferentCaseNotEqual()
{
var addr1 = GetDefaultAddress();
var addr2 = GetDefaultAddress();
addr1.City = addr1.City.ToLower();
addr2.City = addr2.City.ToUpper();
var target = new EqualityChecker <Address>();
Assert.IsFalse(target.HaveEqualValues(addr1, addr2));
}
public static void Main()
{
EqualityChecker <string> eq1 = new EqualityChecker <string>();
eq1.CheckEquality("Hello", "Hello");
eq1.CheckEquality("Hello", "World");
Console.WriteLine("------------------------------------");
EqualityChecker <MyClass> eq2 = new EqualityChecker <MyClass>();
eq2.CheckEquality(new MyClass(5), new MyClass(5));
}
public static void Main()
{
EqualityChecker <int> eq1 = new EqualityChecker <int>();
eq1.CheckEquality(2, 2);
eq1.CheckEquality(3, 4);
Console.WriteLine("-------------------------");
EqualityChecker <MyStruct> eq2 = new EqualityChecker <MyStruct>();
eq2.CheckEquality(new MyStruct(5), new MyStruct(5));
}
public static void Main()
{
EqualityChecker <string> eq1 = new EqualityChecker <string>();
eq1.CheckEquality("Hello", "Hello");
Console.WriteLine("-----------------------");
EqualityChecker <int> eq2 = new EqualityChecker <int>();
eq2.CheckEquality(2, 4);
Console.WriteLine("-----------------------");
}
public void CompareObjectsOnlyEnumDifferent()
{
var person1 = GetDefaultPerson();
var person2 = GetDefaultPerson();
person1.HomeAddress.State = State.IN;
person2.HomeAddress.State = State.MI;
var equalityChecker = new EqualityChecker <Person>();
var equal = equalityChecker.HaveEqualValues(person1, person2);
Assert.IsFalse(equal);
}
public void AddressDifferentCaseOverrideString()
{
var addr1 = GetDefaultAddress();
var addr2 = GetDefaultAddress();
addr1.City = addr1.City.ToLower();
addr2.City = addr2.City.ToUpper();
var target = new EqualityChecker <Address>()
.Override((string s1, string s2) => s1.Equals(s2, StringComparison.InvariantCultureIgnoreCase));
Assert.IsTrue(target.HaveEqualValues(addr1, addr2));
}
public void ReferenceSharedByBothObjectsNoExceptionThrown()
{
var obj1 = GetDefaultPerson();
var obj2 = GetDefaultPerson();
var address = GetDefaultAddress();
obj1.HomeAddress = address;
obj2.WorkAddress = address;
var target = new EqualityChecker <Person>();
target.HaveEqualValues(obj1, obj2);
}
public void SharedLeafNodeNoExceptionThrown()
{
var obj1 = GetDefaultPerson();
var obj2 = GetDefaultPerson();
var address = GetDefaultAddress();
obj1.WorkAddress = address;
obj1.HomeAddress = address;
var target = new EqualityChecker <Person>();
target.HaveEqualValues(obj1, obj2);
}
public void IgnorePropertyByExpression()
{
var p1 = GetDefaultPerson();
var p2 = GetDefaultPerson();
p1.HomeAddress.City = "ldsfkjdslkj";
p2.HomeAddress.City = "Grand Rapids";
var target = new EqualityChecker <Person>()
.Ignore(p => p.HomeAddress.City);
Assert.IsTrue(target.HaveEqualValues(p1, p2));
}
public void OverridePropertyByExpression()
{
var p1 = GetDefaultPerson();
var p2 = GetDefaultPerson();
p1.HomeAddress.City = "GRAND RAPIDS";
p2.HomeAddress.City = "Grand Rapids";
var target = new EqualityChecker <Person>()
.Override(p => p.HomeAddress.City, (string s1, string s2) => s1.Equals(s2, StringComparison.InvariantCultureIgnoreCase))
.Override(p => p.FirstName, (string s1, string s2) => true);
Assert.IsTrue(target.HaveEqualValues(p1, p2));
}
public void IgnorePropertyTypes()
{
var addr1 = GetDefaultAddress();
var addr2 = GetDefaultAddress();
addr1.State = State.IN;
addr2.State = State.MI;
var target = new EqualityChecker <Address>()
.Ignore(typeof(State));
var result = target.HaveEqualValues(addr1, addr2);
Assert.IsTrue(result);
}
public void CalculateMostFrequentNWords_WithValidText_WithValidNValue()
{
IList <IWordFrequency> expected = new List <IWordFrequency>()
{
new WordFrequency("one", 3),
new WordFrequency("three", 3),
new WordFrequency("two", 3),
new WordFrequency("five", 1)
};
List <IWordFrequency> expectedToList = expected as List <IWordFrequency>;
IList <IWordFrequency> actual = (analyzer.CalculateMostFrequentNWords("one, two, three, two, three, two, three, one, one, four, five", 4));
List <IWordFrequency> actualToList = actual as List <IWordFrequency>;
Assert.IsTrue(EqualityChecker.AreEqual(expectedToList, actualToList));
}
public void CheckCircularReferenceNoExceptionThrown()
{
var obj1 = GetDefaultPerson();
var obj2 = GetDefaultPerson();
var addrInfo1 = new AddressInfo
{
PropertyOwner = new PropertyOwner {
Name = "Joe Smith"
},
PropertyValue = 50000
};
obj1.HomeAddress.AddressInfo = addrInfo1;
obj2.HomeAddress.AddressInfo = addrInfo1;
// Person
// |
//HomeAddress MailingAddress
// | |
// | |
// |
// AddressInfo
// |
// PropertyOwner
// There is no circular reference, so no exception should be thrown.
var target = new EqualityChecker <Person>();
Assert.IsTrue(target.HaveEqualValues(obj1, obj2));
// [ ]
// |
// _______
// | |
//[ ] [ ]
// | |
// ______
// |
// [ ] <-- This test tests this scenario to make sure it is not treated as a circular reference.
// |
// [ ]
}
public void CircularReferenceLongChainBreaks()
{
var addr1 = GetDefaultAddress();
var addr2 = GetDefaultAddress();
var addr3 = GetDefaultAddress();
addr1.AddressRef = addr2;
addr2.AddressRef = addr3;
addr3.AddressRef = addr1;
var addr4 = GetDefaultAddress();
var addr5 = GetDefaultAddress();
var addr6 = GetDefaultAddress();
addr4.AddressRef = addr5;
addr5.AddressRef = addr6;
addr6.AddressRef = addr4;
// These object graphs have circular references.
var target = new EqualityChecker <Address>();
target.HaveEqualValues(addr1, addr4);
}
public void CompareModelWithList()
{
var p1 = GetDefaultPerson();
var p2 = GetDefaultPerson();
p1.Addresses = new List <Address>
{
GetDefaultAddress(),
GetDefaultAddress(),
GetDefaultAddress(),
};
p2.Addresses = new List <Address>
{
GetDefaultAddress(),
GetDefaultAddress(),
GetDefaultAddress(),
};
var target = new EqualityChecker <Person>();
Assert.IsTrue(target.HaveEqualValues(p1, p2));
}
