public void TestSimpleClassHierarchy()
{
var leftObject = new Element()
{
Name = "root",
Content = new Element()
{
Name = "element1",
Content = new Element()
{
Name = "element2",
}
}
};
var rightObject = new Element()
{
Name = "root",
Content = new Element()
{
Name = "element1",
Content = new Element()
{
Name = "element2",
}
}
};
ObjectGraphFactory factory = new PublicPropertyObjectGraphFactory();
ObjectComparer comparer = new ObjectComparer(factory);
bool match = comparer.Compare(leftObject, rightObject).None();
Assert.True(match, "objects did not match");
}
public void CompareIEnumerable()
{
Element leftObject = new Element()
{
Name = "root",
Content = new List <string>
{
"hello1",
"hello2",
"hello3"
}
};
Element rightObject = new Element()
{
Name = "root",
Content = new List <string>
{
"hello1",
"hello2",
"hello3"
}
};
ObjectGraphFactory factory = new PublicPropertyObjectGraphFactory();
ObjectComparer comparer = new ObjectComparer(factory);
bool match = comparer.Compare(leftObject, rightObject).None();
Assert.True(match, "objects did not match");
}
public CharacterizationTest()
{
_reader = new RecordingXmlReader();
_inputParameters = new List <ParameterRecording>();
_outputParameters = new List <ParameterRecording>();
_objectComparer = new ObjectComparer(new PublicPropertyObjectGraphFactory());
}
public void ComparesEachItemInArrayProperty()
{
var obj1 = new TestObject5 {
PropX = new[] { new TestObject2 {
Prop1 = 123
}, new TestObject2 {
Prop1 = 456
}, }
};
var obj2 = new TestObject5 {
PropX = new[] { new TestObject2 {
Prop1 = 789
}, new TestObject2 {
Prop1 = 456
}, }
};
var sut = new ObjectComparer();
var result = sut.Compare(obj1, obj2).ToList();
Assert.AreEqual(3, result.Count);
CheckComparison(result[0], ComparisonResult.Equal, ".PropX.Length", 2, 2);
CheckComparison(result[1], ComparisonResult.NotEqual, ".PropX[0].Prop1", 123, 789);
CheckComparison(result[2], ComparisonResult.Equal, ".PropX[1].Prop1", 456, 456);
}
public void UsesProvidedIComparer()
{
var comparer = new ObjectComparer();
comparisonConstraint.Using(comparer).ApplyTo(0);
Assert.That(comparer.WasCalled, "Comparer was not called");
}
private void ValidateExpectedEvents(IEnumerable <IEvent> expected, IEnumerable <IEvent> actual)
{
var expectedSegment = new List <IEvent>();
var actualSegment = new List <IEvent>();
int i = 0;
foreach (var e in expected)
{
if (e is VerifyEventsNow)
{
ObjectComparer.AreEqual(expectedSegment, actualSegment, false);
expectedSegment = new List <IEvent>();
actualSegment = new List <IEvent>();
}
else
{
expectedSegment.Add(e);
if (i < actual.Count())
{
actualSegment.Add(actual.ElementAt(i++));
}
}
}
for (int x = i; x < actual.Count(); x++)
{
actualSegment.Add(actual.ElementAt(x));
}
ObjectComparer.AreEqual(expectedSegment, actualSegment, false);
}
public void Expect_the_RouteSet_to_be_RecordRoutes_of_the_response_in_reverse_order()
{
var oc = ObjectComparer.Create();
oc.Compare(ClientDialog.RouteSet, ReceivedResponse.RecordRoutes.ToList());
oc.Differences.Should().BeEmpty();
}
public void ParseMembershipFunctions_ReturnsCorrectListOfMembershipFunctionStrings()
{
// Arrange
string membershipFunctionPart = "Cold:Trapezoidal:(0,20,20,30)|Warm:Trapezoidal:(40,40,50,50)|Hot:Triangular:(50,60,70)";
List <MembershipFunctionStrings> expectedMembershipFunctionStrings = new List <MembershipFunctionStrings>
{
new MembershipFunctionStrings("Cold", "Trapezoidal", new List <double> {
0, 20, 20, 30
}),
new MembershipFunctionStrings("Warm", "Trapezoidal", new List <double> {
40, 40, 50, 50
}),
new MembershipFunctionStrings("Hot", "Triangular", new List <double> {
50, 60, 70
})
};
// Act
List <MembershipFunctionStrings> actualMembershipFunctionStrings =
_membershipFunctionParser.ParseMembershipFunctions(membershipFunctionPart);
// Assert
Assert.AreEqual(expectedMembershipFunctionStrings.Count, actualMembershipFunctionStrings.Count);
for (int i = 0; i < expectedMembershipFunctionStrings.Count; i++)
{
Assert.IsTrue(ObjectComparer.MembershipFunctionStringsAreEqual(expectedMembershipFunctionStrings[i], actualMembershipFunctionStrings[i]));
}
}
public void ArePropertiesEqual_All_Propertes_Is_Equal_InnerObjects_Are_Equal_If_Requested_Consideration()
{
var expected = new MyTestObject
{
Id = 1,
Description = "Description Equal",
InnerObject = new MyTestInnerObject
{
InnerId = 1
}
};
var actual = new MyTestObject
{
Id = 1,
Description = "Description Equal",
InnerObject = new MyTestInnerObject
{
InnerId = 1
}
};
var compareOption = new ObjectComparer.ComparisonOptions {
ShouldRecursivelyCompareSubProperties = true
};
var result = ObjectComparer.ArePropertiesEqual(expected, actual, compareOption);
Assert.True(result);
}
public void AllItemsAreInRange_UsingIComparer()
{
var comparer = new ObjectComparer();
int[] c = new int[] { 12, 27, 19, 32, 45, 99, 26 };
Assert.That(c, Is.All.InRange(10, 100).Using(comparer));
Assert.That(comparer.WasCalled);
}
public void ArePropertiesEqual_All_Propertes_Is_Equal_InnerObjects_Not_Considerred_Equal_By_Default()
{
var expected = new MyTestObject
{
Id = 1,
Description = "Description Equal",
InnerObject = new MyTestInnerObject
{
InnerId = 1
}
};
var actual = new MyTestObject
{
Id = 1,
Description = "Description Equal",
InnerObject = new MyTestInnerObject
{
InnerId = 1
}
};
var result = ObjectComparer.ArePropertiesEqual(expected, actual);
Assert.False(result);
}
public void EqualArrays_ReturnsTrue()
{
var leftArray = new[] { 1, 2, 3, 4, 5 };
var rightArray = new[] { 1, 2, 3, 4, 5 };
Assert.IsTrue(ObjectComparer.AreEnumerationsEquals(leftArray, rightArray));
}
public void ObjectsWithDifferentProps_ReturnsFalse()
{
var leftArray = new { Numero = new Array[1, 2, 3], Letra = "A" };
var rightArray = new { Numero = new Array[1, 5, 3], Letra = "A" };
Assert.IsFalse(ObjectComparer.AreObjectsEqual(leftArray, rightArray));
}
public void CompareObjectWithLoopInSecondLevel()
{
Element leftObject = new Element()
{
Name = "RootElement",
Content = new Element()
{
Name = "ChildElement"
}
};
// child points to root
((Element)leftObject.Content).Content = leftObject;
Element rightObject = new Element()
{
Name = "RootElement",
Content = new Element()
{
Name = "ChildElement"
}
};
// child points to parent
((Element)rightObject.Content).Content = rightObject;
ObjectGraphFactory factory = new PublicPropertyObjectGraphFactory();
ObjectComparer comparer = new ObjectComparer(factory);
bool match = comparer.Compare(leftObject, rightObject).None();
Assert.True(match, "object with loop did not match");
}
public void ParseLinguisticVariable_ReturnsCorrectLinguisticVariableString_WithTwoVariables()
{
// Arrange
var membershipFunction = "Cold:Trapezoidal:(0,20,20,30)|Hot:Trapezoidal(50,60,60,80)";
var linguisticVariable = $"[Water,NotWater]:Initial:[{membershipFunction}]";
var expectedMembershipFunctionStringsList = new List <MembershipFunctionStrings>
{
new MembershipFunctionStrings("Cold", "Trapezoidal", new List <double> {
0, 20, 20, 30
}),
new MembershipFunctionStrings("Hot", "Trapezoidal", new List <double> {
50, 60, 60, 80
})
};
var firstExpectedLinguisticVariableStrings = new LinguisticVariableStrings("Water", "Initial", expectedMembershipFunctionStringsList);
var secondExpectedLinguisticVariableStrings = new LinguisticVariableStrings("NotWater", "Initial", expectedMembershipFunctionStringsList);
_membershipFunctionParserMock.Stub(x => x.ParseMembershipFunctions(membershipFunction)).Return(expectedMembershipFunctionStringsList);
// Act
var actualLinguisticVariableStringsList = _linguisticVariableParser.ParseLinguisticVariable(linguisticVariable);
// Assert
Assert.AreEqual(2, actualLinguisticVariableStringsList.Count);
Assert.IsTrue(ObjectComparer.LinguisticVariableStringsAreEqual(firstExpectedLinguisticVariableStrings, actualLinguisticVariableStringsList[0]));
Assert.IsTrue(ObjectComparer.LinguisticVariableStringsAreEqual(secondExpectedLinguisticVariableStrings, actualLinguisticVariableStringsList[1]));
}
public void CompareTypesDoNotMatch()
{
var leftObject = new Element()
{
Content = 32,
};
var rightObject = new Element()
{
Content = "stringvalue",
};
ObjectGraphFactory factory = new PublicPropertyObjectGraphFactory();
ObjectComparer comparer = new ObjectComparer(factory);
IEnumerable <ObjectComparisonMismatch> mismatches = comparer.Compare(leftObject, rightObject);
bool match = mismatches.None();
string[] expectedMismatches = new string[]
{
"ObjectTypesDoNotMatch:Left=Element.Content(32) Right=Element.Content(stringvalue)",
};
string[] actualMismatches = StringFromMismatches(mismatches);
Assert.False(match);
Assert.True(actualMismatches.Length == expectedMismatches.Length);
for (int index = 0; index < expectedMismatches.Length; index++)
{
Assert.Equal(expectedMismatches[index], actualMismatches[index]);
}
}
public void GetDeviceServiceSettings_WhenBaseUrlDoesNotEndWithForwardSlash_ShouldReturnBaseUrlEndingWithForwardSlash()
{
// Arrange
var baseUrl = "http://api.matlus.com";
var expectedBaseUrl = baseUrl + "/";
var generatedDeviceServiceSettings = new DeviceServiceSettingsBuilder()
.Set(x => x.BaseUrl, baseUrl)
.Build();
var appSettings = new AppSettings {
HttpProxyUrl = ProxyUrl
};
var configurationProvider = InitializeConfigurationProvider(generatedDeviceServiceSettings, appSettings);
var expectedDeviceServiceSettings = new DeviceServiceSettingsBuilder()
.Set(x => x.BaseUrl, expectedBaseUrl)
.Set(x => x.HttpProxyUrl, appSettings.HttpProxyUrl)
.With(generatedDeviceServiceSettings);
// Act
var actualDeviceServiceSettings = configurationProvider.GetDeviceServiceSettings();
// Assert
ObjectComparer.AssertAreEqual(expectedDeviceServiceSettings, actualDeviceServiceSettings);
}
public void UsesProvidedIComparer()
{
var comparer = new ObjectComparer();
Assert.That(rangeConstraint.Using(comparer).ApplyTo(19).IsSuccess);
Assert.That(comparer.WasCalled, "Comparer was not called");
}
public void TestBasicCompareFalse()
{
AnEntity entity1 = AnEntity.Create(10, "test", 100);
AnEntity entity2 = AnEntity.Create(10, "test", 110);
Assert.That(ObjectComparer.AreEqual(entity1, entity2), Is.False);
}
public override bool Matches(Object actualObjectToCompare)
{
ObjectComparer comparer = new ObjectComparer();
differencies = comparer.FindDifferencies(actualObjectToCompare, CompareObj);
return(differencies.Count == 0);
}
public void VerifyDoubleNull()
{
AnEntity entity1 = AnEntity.Create(10, null, 100);
AnEntity entity2 = AnEntity.Create(10, null, 100);
Assert.That(ObjectComparer.AreEqual(entity1, entity2));
}
public void EqualArraysWithObjects_ReturnsTrue()
{
var leftArrayObject = new[] { BasicJson.GetDefault(), BasicJson.GetDefault() };
var rightArrayObject = new[] { BasicJson.GetDefault(), BasicJson.GetDefault() };
Assert.IsTrue(ObjectComparer.AreEnumerationsEquals(leftArrayObject, rightArrayObject));
}
public void GetKnowledgeBase_ReturnsCorrectLinguisticVariablesRelations()
{
// Arrange
List <LinguisticVariableRelations> expectedRelations = new List <LinguisticVariableRelations>
{
new LinguisticVariableRelations(1, new List <string> {
"Temperature = HOT"
}),
new LinguisticVariableRelations(2, new List <string> {
"Pressure = HIGH"
}),
new LinguisticVariableRelations(3, new List <string> {
"Volume = BIG"
}),
new LinguisticVariableRelations(4, new List <string> {
"Color = RED"
}),
new LinguisticVariableRelations(5, new List <string> {
"Danger = HIGH"
}),
new LinguisticVariableRelations(6, new List <string> {
"Evacuate = TRUE"
})
};
// Act
List <LinguisticVariableRelations> actualRelations = _knowledgeBaseManager.GetKnowledgeBase(_profileName).Value.LinguisticVariablesRelations;
// Assert
Assert.AreEqual(expectedRelations.Count, actualRelations.Count);
for (var i = 0; i < expectedRelations.Count; i++)
{
Assert.IsTrue(ObjectComparer.LinguisticVariableRelationsAreEqual(expectedRelations[i], actualRelations[i]));
}
}
public void DifferentArrays_ReturnsFalse()
{
var leftArray = new[] { 1, 2, 3 };
var rightArray = new[] { 7, 1, 9 };
Assert.IsFalse(ObjectComparer.AreEnumerationsEquals(leftArray, rightArray));
}
//NOTE: compare object's values (not refs)
public override bool Equals(object obj) {
if (obj == null || obj.GetType() != GetType()) {
return false;
}
return ObjectComparer.AreEqual(this, obj);
}
public void ComplexTypeWithArrayProperties()
{
var obj1 = new TestObject3
{
List = new[]
{
new TestObject2 { PropX = "xyz", PropY = new TestObject1 { Prop1 = "abc", Prop2 = 123 } },
new TestObject2 { PropX = "xyz", PropY = new TestObject1 { Prop1 = "abc", Prop2 = 123 } },
}
};
var obj2 = new TestObject3
{
List = new[]
{
new TestObject2 { PropX = "abc", PropY = new TestObject1 { Prop1 = "x1", Prop2 = 123 } },
new TestObject2 { PropX = "def", PropY = new TestObject1 { Prop1 = "x2", Prop2 = 456 } },
new TestObject2 { PropX = "ghi", PropY = new TestObject1 { Prop1 = "x3", Prop2 = 789 } },
}
};
var sut = new ObjectComparer();
var result = sut.Compare(obj1, obj2).ToList();
Assert.AreEqual(10, result.Count());
CheckComparison(result[0], ComparisonResult.NotEqual, ".List.Length", 2, 3);
CheckComparison(result[1], ComparisonResult.NotEqual, ".List[0].PropX", "xyz", "abc");
CheckComparison(result[2], ComparisonResult.NotEqual, ".List[0].PropY.Prop1", "abc", "x1");
CheckComparison(result[3], ComparisonResult.Equal, ".List[0].PropY.Prop2", 123, 123);
CheckComparison(result[4], ComparisonResult.NotEqual, ".List[1].PropX", "xyz", "def");
CheckComparison(result[5], ComparisonResult.NotEqual, ".List[1].PropY.Prop1", "abc", "x2");
CheckComparison(result[6], ComparisonResult.NotEqual, ".List[1].PropY.Prop2", 123, 456);
CheckComparison(result[7], ComparisonResult.NotEqual, ".List[2].PropX", null, "ghi");
CheckComparison(result[8], ComparisonResult.NotEqual, ".List[2].PropY.Prop1", null, "x3");
CheckComparison(result[9], ComparisonResult.NotEqual, ".List[2].PropY.Prop2", null, 789);
}
public void UsesProvidedIComparer()
{
var comparer = new ObjectComparer();
Assert.That(2 + 2, Is.EqualTo(4).Using(comparer));
Assert.That(comparer.WasCalled, "Comparer was not called");
}
public void RightEnumNull_ThrowsArgumentNullException()
{
var left = new List <string> {
"Unosquare"
};
Assert.Throws <ArgumentNullException>(() => ObjectComparer.AreEnumerationsEquals(left, NullStringList));
}
public void TwoEqualDecimalsShouldReturnNoVariance()
{
// Arrange and Act
IEnumerable <ObjectVariance> variances = ObjectComparer.GetObjectVariances(.1m, .1m);
// Assert
Assert.Empty(variances);
}
public void EqualOneLevelStringsShouldReturnNoVariance()
{
// Arrange and Act
IEnumerable <ObjectVariance> variances = ObjectComparer.GetObjectVariances("test", "test");
// Assert
Assert.Empty(variances);
}
public void TwoNullsShouldReturnNoVariance()
{
// Arrange and Act
IEnumerable <ObjectVariance> variances = ObjectComparer.GetObjectVariances(null, null);
// Assert
Assert.Empty(variances);
}
public void ComparerWithComparer()
{
var foo = new KeyValuePair<string, IEnumerable<int>>("Hallo", new[] {1, 2, 3});
var bar = new KeyValuePair<string, IEnumerable<int>>("Hallo", new[] {1, 2, 3, 4});
var comparer = new ObjectComparer<KeyValuePair<string, IEnumerable<int>>>()
.Add("Key", x => x.Key)
.Add(x => x.Value, EqualityComparer<int>.Default.ToSequenceComparer());
Assert.NotEqual(foo, bar, comparer);
}
public void ComparesObjectValuesIfObjectsHaveNoProperties()
{
var obj1 = new TestObject1();
var obj2 = new TestObject1();
var sut = new ObjectComparer();
var result = sut.Compare(obj1, obj2).ToList();
Assert.AreEqual(1, result.Count);
CheckComparison(result[0], ComparisonResult.NotEqual, "", obj1, obj2);
}
public void SimpleType()
{
var obj1 = new TestObject1 { Prop1 = "abc", Prop2 = 123 };
var obj2 = new TestObject1 { Prop1 = "abc", Prop2 = 345 };
var sut = new ObjectComparer();
var result = sut.Compare(obj1, obj2).ToList();
Assert.AreEqual(2, result.Count());
CheckComparison(result[0], ComparisonResult.Equal, ".Prop1", "abc", "abc");
CheckComparison(result[1], ComparisonResult.NotEqual, ".Prop2", 123, 345);
}
public void IfOneObjectIsNullTheOtherIsStillExploredRecursively()
{
var obj1 = new TestObject5 { PropX = new[] { new TestObject2 { Prop1 = 123 }, new TestObject2 { Prop1 = 456 }, } };
var sut = new ObjectComparer();
var result = sut.Compare(obj1, null).ToList();
Assert.AreEqual(3, result.Count);
CheckComparison(result[0], ComparisonResult.NotEqual, ".PropX.Length", 2, 0);
CheckComparison(result[1], ComparisonResult.NotEqual, ".PropX[0].Prop1", 123, null);
CheckComparison(result[2], ComparisonResult.NotEqual, ".PropX[1].Prop1", 456, null);
}
public void ComplexType()
{
var obj1 = new TestObject2 { PropX = "xyz", PropY = new TestObject1 { Prop1 = "abc", Prop2 = 123 } };
var obj2 = new TestObject2 { PropX = "zyx", PropY = new TestObject1 { Prop1 = "abc", Prop2 = 345 } };
var sut = new ObjectComparer();
var result = sut.Compare(obj1, obj2).ToList();
Assert.AreEqual(3, result.Count());
CheckComparison(result[0], ComparisonResult.NotEqual, ".PropX", "xyz", "zyx");
CheckComparison(result[1], ComparisonResult.Equal, ".PropY.Prop1", "abc", "abc");
CheckComparison(result[2], ComparisonResult.NotEqual, ".PropY.Prop2", 123, 345);
}
public void IndicesPastArrayEndAreTreatedAsNull()
{
var obj1 = new TestObject5 { PropX = new[] { new TestObject2 { Prop1 = 123 }, } };
var obj2 = new TestObject5 { PropX = new[] { new TestObject2 { Prop1 = 789 }, new TestObject2 { Prop1 = 456 }, } };
var sut = new ObjectComparer();
var result = sut.Compare(obj1, obj2).ToList();
Assert.AreEqual(3, result.Count);
CheckComparison(result[0], ComparisonResult.NotEqual, ".PropX.Length", 1, 2);
CheckComparison(result[1], ComparisonResult.NotEqual, ".PropX[0].Prop1", 123, 789);
CheckComparison(result[2], ComparisonResult.NotEqual, ".PropX[1].Prop1", null, 456);
}
public void ComparesEachItemInArrayProperty()
{
var obj1 = new TestObject5 { PropX = new[] { new TestObject2 { Prop1 = 123 }, new TestObject2 { Prop1 = 456 }, } };
var obj2 = new TestObject5 { PropX = new[] { new TestObject2 { Prop1 = 789 }, new TestObject2 { Prop1 = 456 }, } };
var sut = new ObjectComparer();
var result = sut.Compare(obj1, obj2).ToList();
Assert.AreEqual(3, result.Count);
CheckComparison(result[0], ComparisonResult.Equal, ".PropX.Length", 2, 2);
CheckComparison(result[1], ComparisonResult.NotEqual, ".PropX[0].Prop1", 123, 789);
CheckComparison(result[2], ComparisonResult.Equal, ".PropX[1].Prop1", 456, 456);
}
public void SetUp()
{
comparer = new ObjectComparer<Address>();
comparer.MatchOn(x => x.City).MatchOn((x => x.Address1)).MatchOn(x => x.DistanceFromOffice);
}
public void ThrowsIfObjectsDoNotHaveSameType()
{
var obj1 = new TestObject1();
var obj2 = new TestObject2();
var sut = new ObjectComparer();
sut.Compare(obj1, obj2);
}
public void ReturnsEqualForIntProperty()
{
const int VALUE = 123;
var obj1 = new TestObject2 { Prop1 = VALUE };
var obj2 = new TestObject2 { Prop1 = VALUE };
var sut = new ObjectComparer();
var result = sut.Compare(obj1, obj2).ToList();
Assert.AreEqual(1, result.Count);
CheckComparison(result[0], ComparisonResult.Equal, ".Prop1", VALUE, VALUE);
}
public void ReturnsEqualForEnumProperty()
{
const Enum4 VALUE = Enum4.Something;
var obj1 = new TestObject4 { Prop1 = VALUE };
var obj2 = new TestObject4 { Prop1 = VALUE };
var sut = new ObjectComparer();
var result = sut.Compare(obj1, obj2).ToList();
Assert.AreEqual(1, result.Count);
CheckComparison(result[0], ComparisonResult.Equal, ".Prop1", VALUE, VALUE);
}
public void SortDelegate(BrightIdeasSoftware.OLVColumn column, SortOrder order)
{
List<Media> mediaList = new List<Media>();
string orderStr;
switch (order)
{
case SortOrder.Ascending:
case SortOrder.None:
orderStr = "ASC";
break;
case SortOrder.Descending:
default:
orderStr = "DESC";
break;
}
if (mediaListBackup == null)
{
ObjectComparer<Media> comparer;
if (column.AspectName == "TrackNr")
{
comparer = new ObjectComparer<Media>("Artist ASC, Album ASC, TrackNr ASC", true);
}
else
{
comparer = new ObjectComparer<Media>(column.AspectName + " " + orderStr, true);
}
Playlist.Instance.Sort(comparer);
}
else
{
switch (order)
{
case SortOrder.Ascending:
case SortOrder.None:
StandardQuery.sort.order = Query.SortOrder.Ascending;
break;
case SortOrder.Descending:
default:
StandardQuery.sort.order = Query.SortOrder.Descending;
break;
}
if (column.AspectName == "TrackNr")
StandardQuery.sort.by = Query.SortBy.Smart;
else if (column.AspectName == "Artist")
StandardQuery.sort.by = Query.SortBy.Artist;
else if (column.AspectName == "Title")
StandardQuery.sort.by = Query.SortBy.Title;
else if (column.AspectName == "Album")
StandardQuery.sort.by = Query.SortBy.Album;
queryPlaylist();
}
lvPlaylist.BuildList();
}
public void ReturnsNotEqualForStringProperty()
{
const string VALUE1 = "abc";
const string VALUE2 = "def";
var obj1 = new TestObject3 { Prop1 = VALUE1 };
var obj2 = new TestObject3 { Prop1 = VALUE2 };
var sut = new ObjectComparer();
var result = sut.Compare(obj1, obj2).ToList();
Assert.AreEqual(1, result.Count);
CheckComparison(result[0], ComparisonResult.NotEqual, ".Prop1", VALUE1, VALUE2);
}
