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