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