// private static void CheckComparison(Comparison comparison, ComparisonResult comparisonResult, string propName, object lValue, object rValue) { Assert.AreEqual(comparisonResult, comparison.Result); Assert.AreEqual(propName, comparison.PropName); Assert.AreEqual(lValue, comparison.LValue); Assert.AreEqual(rValue, comparison.RValue); }
/// <summary> /// The "standard" difference evaluator which decides which /// differences make two XML documents really different and which /// still leave them similar. /// </summary> public static ComparisonResult Default(Comparison comparison, ComparisonResult outcome) { if (outcome == ComparisonResult.DIFFERENT) { switch (comparison.Type) { case ComparisonType.NODE_TYPE: XmlNodeType control = (XmlNodeType) comparison.ControlDetails.Value; XmlNodeType test = (XmlNodeType) comparison.TestDetails.Value; if ((control == XmlNodeType.Text && test == XmlNodeType.CDATA) || (control == XmlNodeType.CDATA && test == XmlNodeType.Text) ) { outcome = ComparisonResult.SIMILAR; } break; case ComparisonType.XML_ENCODING: case ComparisonType.HAS_DOCTYPE_DECLARATION: case ComparisonType.DOCTYPE_SYSTEM_ID: case ComparisonType.SCHEMA_LOCATION: case ComparisonType.NO_NAMESPACE_SCHEMA_LOCATION: case ComparisonType.NAMESPACE_PREFIX: case ComparisonType.ATTR_VALUE_EXPLICITLY_SPECIFIED: case ComparisonType.CHILD_NODELIST_SEQUENCE: outcome = ComparisonResult.SIMILAR; break; } } return outcome; }
public Comparison(string a, string b) { _a = a; _b = b; double na, nb; if (!Double.TryParse(a, out na)) na = Double.NaN; if (!Double.TryParse(b, out nb)) nb = Double.NaN; bool ba = Util.BooleanRep(a); bool bb = Util.BooleanRep(b); _result |= a == b ? ComparisonResult.Equal : ComparisonResult.NotEqual; _result |= ba && bb ? ComparisonResult.All : ba || bb ? ComparisonResult.Any : ComparisonResult.None; if (ba != bb) _result |= ComparisonResult.One; if (na < nb) _result |= ComparisonResult.Less; if (na > nb) _result |= ComparisonResult.Greater; }
public void GetBusinessDiscovery_LogicTest() { // Arrange var instaBusiness = this.CreateInstaBusiness(); BusinessDiscovery expected = new BusinessDiscovery(); expected.media = new BusinessDiscoveryData(); expected.media.followersCount = 1357; expected.media.mediaCount = 88; // Act var actual = instaBusiness.GetBusinessDiscovery( _instagramId, _accountName); // Assert ComparisonResult comparisonResult = _logic.Compare(actual, expected); Assert.True(comparisonResult.AreEqual, comparisonResult.DifferencesString); }
public void TestEnumeration() { List <Deck> list1 = new List <Deck>(); list1.Add(Deck.Engineering); list1.Add(Deck.SickBay); List <Deck> list2 = new List <Deck>(); list2.Add(Deck.Engineering); list2.Add(Deck.SickBay); ComparisonResult result = _compare.Compare(list1, list2); if (!result.AreEqual) { throw new Exception(result.DifferencesString); } }
public void IgnoredMemberGetPropertyAccessed() { //This is the comparison class CompareLogic compareLogic = new CompareLogic(); compareLogic.Config.MembersToIgnore.Add("PersonWithNotImplementedProperty.Name"); //Create a couple objects to compare PersonWithNotImplementedProperty person1 = new PersonWithNotImplementedProperty(); person1.DateCreated = DateTime.Now; PersonWithNotImplementedProperty person2 = new PersonWithNotImplementedProperty(); person2.DateCreated = person1.DateCreated; ComparisonResult result = compareLogic.Compare(person1, person2); Assert.IsTrue(result.AreEqual); }
public async Task Compare_App_In_Mongo_Test() { if (!_context.AllowMongoDB) { Assert.True(true); return; } // Arrange DatabaseOptions databaseOptions = new DatabaseOptions { ConnectionString = _context.MongoDatabaseConenction.ConnectionString, ConnectionType = ConnectionType.MongoDB, Datasource = _context.MongoDatabaseConenction.DataSource }; IOptionsMonitor <DatabaseOptions> databaseOptionsMock = Mock.Of <IOptionsMonitor <DatabaseOptions> >(_ => _.CurrentValue == databaseOptions); AppMongoRepository appMongoRepository = new AppMongoRepository(new Core.Persistences.MongoConnection(databaseOptionsMock.CurrentValue)); // Act App app = new App { Id = DataUtil.GenerateUniqueId(), Name = "testapp123456", DisplayName = "Test App" }; await appMongoRepository.AddAsync(app); List <Menu> menus = new List <Menu> { new Menu { Id = Guid.NewGuid().ToString(), DisplayName = "Core" } }; app.Menus = menus; ComparisonResult result = await appMongoRepository.Compare(app); appMongoRepository.Dispose(); // Assert Assert.True(result.Result.Properties.First(a => a.Name == "Menus").ComparedState == ComparedState.Changed); }
public void TestWalletSignaturesNonDeterministic() { //This is the comparison class CompareLogic compareLogic = new CompareLogic(); List <String> mnemonic = new List <String>(singleVector2.Split(" ", StringSplitOptions.RemoveEmptyEntries)); NetworkInfo info = new NetworkInfo(bech32Hrp: "did:com:", lcdUrl: ""); Wallet wallet = Wallet.derive(mnemonic, networkInfo); String data = "Quos Iupiter perdere vult, dementat prius"; String signature1 = HexEncDec.ByteArrayToString(wallet.sign(Encoding.UTF8.GetBytes(data))); String signature2 = HexEncDec.ByteArrayToString(wallet.sign(Encoding.UTF8.GetBytes(data))); // Check it - we use compareNet objects here // a String comparison would have been enough... ComparisonResult result = compareLogic.Compare(signature1, signature2); Assert.AreEqual(result.AreEqual, false); }
public List <FieldAuditLog> CompareObjects(Object oldRecord, Object newRecord) { CompareLogic compObjects = new CompareLogic(); compObjects.Config.MaxDifferences = 99; ComparisonResult comparisonResult = compObjects.Compare(oldRecord, newRecord); List <FieldAuditLog> fieldAuditLogList = new List <FieldAuditLog>(); foreach (var changeLog in comparisonResult.Differences) { FieldAuditLog fieldAuditLog = new FieldAuditLog(); fieldAuditLog.FieldName = changeLog.PropertyName; fieldAuditLog.OldValue = changeLog.Object1Value; fieldAuditLog.NewValue = changeLog.Object2Value; fieldAuditLogList.Add(fieldAuditLog); } return(fieldAuditLogList); }
public void TypeOfTypePositiveTest() { Table table1 = new Table(); table1.TableName = "Person"; table1.ClassType = typeof(Person); Table table2 = new Table(); table2.TableName = "Person"; table2.ClassType = typeof(Person); ComparisonResult result = _compare.Compare(table1, table2); if (!result.AreEqual) { throw new Exception(result.DifferencesString); } }
private bool PrimitivesAreEqual(ComparisonResult propertiesData) { // all possible primitives comparison approaches var typedLeftValue = propertiesData.LeftValue as IComparable; if ((propertiesData.LeftValue == null && propertiesData.RightValue == null) || (typedLeftValue != null && typedLeftValue.CompareTo(propertiesData.RightValue) == 0) || Equals(propertiesData.LeftValue, propertiesData.RightValue)) { return(true); } propertiesData.Message = StringHelper.FormatCurrentCulture(EqualityViolationMessage, propertiesData.PropertyName, propertiesData.LeftValue, propertiesData.RightValue); return(false); }
public void ByteArrayTestNegative() { byte[] b1 = new byte[256]; byte[] b2 = new byte[256]; for (int i = 0; i <= 255; i++) { b1[i] = (byte)i; } b1.CopyTo(b2, 0); b2[5] = 77; ComparisonResult result = _compare.Compare(b1, b2); if (result.AreEqual) { throw new Exception(result.DifferencesString); } }
private void TestSerializationAndDeserialization <T>(Action <Fixture> customizeAction) where T : IBinarySerializable, new() { // Fixture setup var fixture = new Fixture(); fixture.Customizations.Add(new RandomDateSequenceGenerator()); fixture.Customizations.Add(new RandomTimeSpanSequenceGenerator()); customizeAction(fixture); var source = fixture.Create <T>(); var target = new T(); byte[] data; using (var memoryStream = new MemoryStream()) { using (var writer = new BinaryWriter(memoryStream, Encoding.UTF8)) { source.Serialize(writer); data = memoryStream.ToArray(); } } HexDump(data); using (var memoryStream = new MemoryStream(data)) { using (var reader = new BinaryReader(memoryStream)) { target.Deserialize(reader); } } var compareLogic = new CompareLogic(); ComparisonResult result = compareLogic.Compare(source, target); //If different, write out the differences if (!result.AreEqual) { Assert.Fail(result.DifferencesString); } }
private int GetDesiredDistance(ComparisonResult desiredComparison, int startingDistance) { var destinations = locations.Values.ToAvailabilityDictionary(); int desiredDistance = startingDistance; foreach (var d in locations.Values) { Iterate(d, 0, locations.Count - 1); } return(desiredDistance); // It's sad that the best algorithm is a dynamic one with time complexity O(n^2 * 2^n) // With the brute force one being O(n!), being the implementation below void Iterate(Destination currentDestination, int currentDistance, int remaining) { if (remaining == 0) { var result = currentDistance.GetComparisonResult(desiredDistance); if (result == desiredComparison) { desiredDistance = currentDistance; } return; } destinations[currentDestination] = false; foreach (var availability in destinations) { if (!availability.Value) { continue; } var targetDestination = availability.Key; var trip = locations[currentDestination.Name].GetTrip(targetDestination); Iterate(targetDestination, currentDistance + trip.Distance, remaining - 1); } destinations[currentDestination] = true; } }
public ComparisonResult Compare(ProviderServiceRequest expected, ProviderServiceRequest actual) { var result = new ComparisonResult("sends a request which"); if (expected == null) { result.RecordFailure(new ErrorMessageComparisonFailure("Expected request cannot be null")); return(result); } var methodResult = _httpMethodComparer.Compare(expected.Method, actual.Method); result.AddChildResult(methodResult); var pathResult = _httpPathComparer.Compare(expected.Path, actual.Path); result.AddChildResult(pathResult); var queryResult = _httpQueryStringComparer.Compare(expected.Query, actual.Query); result.AddChildResult(queryResult); if (expected.Headers != null && expected.Headers.Any()) { var headerResult = _httpHeaderComparer.Compare(expected.Headers, actual.Headers); result.AddChildResult(headerResult); } if (expected.Body != null) { var bodyResult = _httpBodyComparer.Compare(expected.Body, actual.Body, expected.MatchingRules); result.AddChildResult(bodyResult); } else if (expected.Body == null && expected.ShouldSerializeBody() && //Body was explicitly set actual.Body != null) { result.RecordFailure(new ErrorMessageComparisonFailure("Expected request body was explicitly set to null however the actual request body was not null")); } return(result); }
public static Output <bool, List <string>, List <string>, List <string> > IsEqual(this object obj1, object obj2, BH.oM.Base.ComparisonConfig config = null) { //Use default config if null config = config ?? Create.DefaultTestComparisonConfig(); CompareLogic comparer = new CompareLogic(); comparer.Config.MaxDifferences = config.MaxPropertyDifferences; comparer.Config.MembersToIgnore = config.PropertyExceptions; comparer.Config.DoublePrecision = config.NumericTolerance; comparer.Config.TypesToIgnore = config.TypeExceptions; comparer.Config.CompareStaticFields = false; comparer.Config.CompareStaticProperties = false; Output <bool, List <string>, List <string>, List <string> > output = new Output <bool, List <string>, List <string>, List <string> > { Item1 = false, Item2 = new List <string>(), Item3 = new List <string>(), Item4 = new List <string>() }; if (obj1 == null || obj2 == null) { return(output); } try { ComparisonResult result = comparer.Compare(obj1, obj2); output.Item1 = result.AreEqual; output.Item2 = result.Differences.Select(x => x.PropertyName).ToList(); output.Item3 = result.Differences.Select(x => x.Object1Value).ToList(); output.Item4 = result.Differences.Select(x => x.Object2Value).ToList(); } catch (Exception e) { Engine.Base.Compute.RecordError($"Comparison between {obj1.IToText()} and {obj2.IToText()} failed:\n{e.Message}"); } return(output); }
/// <summary> /// Determines the sync operation of the single items that exist either in the source or the destination. /// </summary> /// <param name="comparisonResult">The comparison result of the source and destination items.</param> /// <param name="syncContext">The sync context contains the items that will be inserted/updated/deleted in source/destination.</param> private void InterpretSingleItemOperations(ComparisonResult <TItem> comparisonResult, SyncContext <TItem> syncContext) { if (comparisonResult.ItemsInSourceOnly.Count > 0) { switch (GetSyncConfigurations().SyncMode.ItemsInSourceOnly) { case SyncItemOperation.None: // do nothing break; case SyncItemOperation.Add: syncContext.ItemsToBeInsertedInDestination.AddRange(comparisonResult.ItemsInSourceOnly); break; case SyncItemOperation.Delete: syncContext.ItemsToBeDeletedFromSource.AddRange(comparisonResult.ItemsInSourceOnly); break; default: throw new NotSupportedException($"Not supported source {nameof(SyncItemOperation)} '{GetSyncConfigurations().SyncMode.ItemsInSourceOnly.ToString()}'."); } } if (comparisonResult.ItemsInDestinationOnly.Count > 0) { switch (GetSyncConfigurations().SyncMode.ItemsInDestinationOnly) { case SyncItemOperation.None: // do nothing break; case SyncItemOperation.Add: syncContext.ItemsToBeInsertedInSource.AddRange(comparisonResult.ItemsInDestinationOnly); break; case SyncItemOperation.Delete: syncContext.ItemsToBeDeletedFromDestination.AddRange(comparisonResult.ItemsInDestinationOnly); break; default: throw new NotSupportedException($"Not supported destination {nameof(SyncItemOperation)} '{GetSyncConfigurations().SyncMode.ItemsInSourceOnly.ToString()}'."); } } }
public IChangeManager Create(ComparisonResult comparisonResult) { changeManager.ClearChanger(); if (comparisonResult.AreEqual) { return(changeManager); } //根据实体与快照的差异进行分析实体的变动 foreach (var difference in comparisonResult.Differences) { ChangeEntry change = this.ResolveChangeEntry(difference); if (change.Type == ChangeEntryType.Addition || change.Type == ChangeEntryType.Remove) { this.changeManager.AddChanger(change); if (change.Type == ChangeEntryType.Addition) { //如果为新增类型,需要进一步分析实体中的值对象 var values = this.ResolveChangeObjectValue(change); foreach (var item in values) { this.changeManager.AddChanger(item); } } } else { var change2 = this.changeManager.GetChanger(change.NewestEntry); if (change2 == null) { this.changeManager.AddChanger(change); change2 = change; } //解析修改的字段 ChangeEntryPropertys changeProperty = this.ResolveChangeEntryPropertys(difference); change2.ChangePropertys.Add(changeProperty); } } return(changeManager); }
public void CompareMatchEvaluatesAttributeMatchesWhenBothItemsVisibleAndItemMatchIsNotBreaking( bool firstItemVisible, bool secondItemVisible, SemVerChangeType changeType, bool attributesEvaluated) { var firstItem = Substitute.For <IClassDefinition>(); var firstItemAttributes = Model.UsingModule <ConfigurationModule>().Create <List <TestAttributeDefinition> >(); var secondItem = Substitute.For <IClassDefinition>(); var secondItemAttributes = Model.UsingModule <ConfigurationModule>().Create <List <TestAttributeDefinition> >(); var itemResult = new ComparisonResult(changeType, firstItem, secondItem, Guid.NewGuid().ToString()); var attributeResult = new ComparisonResult(changeType, firstItemAttributes.Last(), secondItemAttributes.Last(), Guid.NewGuid().ToString()); var attributeResults = new List <ComparisonResult> { attributeResult }; var match = new ItemMatch <IClassDefinition>(firstItem, secondItem); var options = ComparerOptions.Default; var attributeProcessor = Substitute.For <IAttributeMatchProcessor>(); firstItem.IsVisible.Returns(firstItemVisible); secondItem.IsVisible.Returns(secondItemVisible); attributeProcessor.CalculateChanges(firstItem.Attributes, secondItem.Attributes, options) .Returns(attributeResults); var sut = new Wrapper <IClassDefinition>(attributeProcessor, itemResult); var actual = sut.CompareMatch(match, options).ToList(); _output.WriteResults(actual); if (attributesEvaluated) { attributeProcessor.Received().CalculateChanges(firstItem.Attributes, secondItem.Attributes, options); actual.Should().Contain(attributeResult); } else { attributeProcessor.DidNotReceive().CalculateChanges(Arg.Any <IEnumerable <IAttributeDefinition> >(), Arg.Any <IEnumerable <IAttributeDefinition> >(), Arg.Any <ComparerOptions>()); } }
public void SerializesAndDeserializesCorrectly() { // I.e. deserialized(serialized(PROJECT)) should equal PROJECT string tmpPath = Path.GetTempPath(); MyConfiguration.SetupModuleSearchPath(); MyConfiguration.LoadModules(); MyConfiguration.KnownNodes.Add(typeof(TestNode), new MyNodeConfig()); var project = new MyProject(); project.Network = project.CreateNode <MyNetwork>(); project.Network.Name = "Network"; project.CreateWorld(typeof(MyTestingWorld)); project.Name = "test"; var node = project.CreateNode <TestNode>(); project.Network.AddChild(node); project.Restore(); string serialized = project.Serialize(tmpPath); MyProject deserializedProject = MyProject.Deserialize(serialized, tmpPath); // MaxDifferences = 20 - A magic number. It shows more than one difference in the log. // There should eventually be zero differences, so this number can be arbitrary. Adjust as needed. // Observers are ignored - there are none, and the (de)serialization mechanism works with them in a special way. var compareLogic = new CompareLogic(new ComparisonConfig { MaxDifferences = 20, MembersToIgnore = new List <string> { "Observers" } }); ComparisonResult result = compareLogic.Compare(project, deserializedProject); m_output.WriteLine(result.DifferencesString); Assert.True(result.AreEqual); }
private string DeconstructTestCaseResultsResponse(DeconstructTestCase data) { string status = string.Empty; MIDdeconstrutionResponse expectedResult = null; MachineComponentsForMIDdeconstruction machineComponentsForMIDdeconstruction = data.machineComponentsForMIDdeconstruction; MIDCodeDeconstructionRequest midCodeDeconstructionRequest = new MIDCodeDeconstructionRequest(); midCodeDeconstructionRequest.machineComponentsForMIDdeconstruction = machineComponentsForMIDdeconstruction; if (ModelState.IsValid) { expectedResult = data.result; string xmlString = XmlHelper.ConvertObjectToXML(midCodeDeconstructionRequest); XElement xElement = XElement.Parse(xmlString); MIDdeconstrutionResponse actulResult = _deconstructionService.MIDCodeDeconstruction(xElement.ToString()); if (actulResult != null) { CompareLogic compareLogic = new CompareLogic(); ComparisonResult result = compareLogic.Compare(expectedResult, actulResult); if (result.AreEqual) { status = "Passed"; } else { status = "failed"; } } else { status = "Failed"; } } else { status = "Validation Failed"; } return(status); }
public void BeyondCompareReportTest() { string expected = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "beyondExpected.txt"); string actual = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "beyondActual.txt"); if (File.Exists(expected)) { File.Delete(expected); } if (File.Exists(actual)) { File.Delete(actual); } Movie beyondExpected = new Movie(); beyondExpected.Name = "Oblivion"; beyondExpected.PaymentForTomCruise = 2000000M; Movie beyondActual = new Movie(); beyondActual.Name = "Edge of Tomorrow"; beyondActual.PaymentForTomCruise = 3000000M; CompareLogic compareLogic = new CompareLogic(); compareLogic.Config.MaxDifferences = Int32.MaxValue; ComparisonResult result = compareLogic.Compare(beyondExpected, beyondActual); BeyondCompareReport beyondCompare = new BeyondCompareReport(); beyondCompare.OutputFiles(result.Differences, expected, actual); Assert.IsTrue(File.Exists(expected)); Assert.IsTrue(File.Exists(actual)); if (!string.IsNullOrEmpty(beyondCompare.FindBeyondCompare())) { beyondCompare.LaunchApplication(expected, actual); } }
public void CompareDynamicObjectWithUnderlyingTypeNegative() { SimpleEntity x = new SimpleEntity(); dynamic dynamicX = x; dynamicX.Name = nameof(SimpleEntity); dynamicX.Id = typeof(SimpleEntity).GUID; SimpleEntity y = new SimpleEntity(); dynamic dynamicY = y; dynamicY.Name = nameof(SimpleEntity); dynamicY.Id = Guid.NewGuid(); CompareLogic comparer = new CompareLogic(); ComparisonResult result = comparer.Compare(dynamicX, dynamicY); Assert.False(result.AreEqual); }
private void FilterResults(ComparisonResult result) { foreach (var difference in result.Differences.ToList()) { if (difference.Object1TypeName == difference.Object2TypeName && difference.Object1TypeName == typeof(DateTime).Name) { if (difference.Object1Value == Any.Date.ToString() || difference.Object2Value == Any.Date.ToString()) { result.Differences.Remove(difference); } } if (difference.Object1TypeName == difference.Object2TypeName && difference.Object1TypeName == typeof(Guid).Name) { if (difference.Object2Value == Any.Guid.ToString() || difference.Object2Value == Any.Guid.ToString()) { result.Differences.Remove(difference); } } } }
public void OverallChangeTypeReturnsHighestResult(SemVerChangeType firstType, SemVerChangeType secondType, SemVerChangeType expected) { var firstItem = new TestPropertyDefinition(); var secondItem = new TestPropertyDefinition(); var match = new ItemMatch <IPropertyDefinition>(firstItem, secondItem); var firstResult = new ComparisonResult(firstType, match.OldItem, match.NewItem, Guid.NewGuid().ToString()); var secondResult = new ComparisonResult(secondType, match.OldItem, match.NewItem, Guid.NewGuid().ToString()); var sut = new ChangeResultAggregator(); sut.AddResult(firstResult); sut.AddResult(secondResult); var actual = sut.OverallChangeType; actual.Should().Be(expected); }
private void FireComparisonPerformed(Comparison comp, ComparisonResult outcome) { ComparisonListener cl = ComparisonListener; ComparisonListener ml = MatchListener; ComparisonListener dl = DifferenceListener; if (cl != null) { cl(comp, outcome); } if (outcome == ComparisonResult.EQUAL && ml != null) { ml(comp, outcome); } else if (outcome != ComparisonResult.EQUAL && dl != null) { dl(comp, outcome); } }
public void ObjectTypeObjectTest() { ObjectTypeClass objectClass1 = new ObjectTypeClass(); objectClass1.FieldObject = new object(); objectClass1.PropertyObject = new object(); ObjectTypeClass.StaticObject = new object(); ObjectTypeClass objectClass2 = new ObjectTypeClass(); objectClass2.FieldObject = new object(); objectClass2.PropertyObject = new object(); ComparisonResult result = _compare.Compare(objectClass1, objectClass2); if (!result.AreEqual) { Assert.Fail(result.DifferencesString); } }
public void Notify(Comparison comparison, ComparisonResult outcome) { switch (outcome) { case ComparisonResult.EQUAL: Equal++; break; case ComparisonResult.SIMILAR: Similars++; break; case ComparisonResult.DIFFERENT: Differents++; break; default: break; } }
public void DifferentDecimalsShouldNotBeEqualInsideAnAnonymousType() { CompareLogic compareLogic = new CompareLogic(); // try with decimals var dec1 = new { MyNumber = (decimal)0 }; var dec2 = new { MyNumber = (decimal)3.0 }; // test with CompareChildren = false compareLogic.Config.CompareChildren = false; ComparisonResult test1 = compareLogic.Compare(dec1, dec2); Assert.IsFalse(test1.AreEqual, "Decimal Test - CompareChildren = false"); // test with CompareChildren = true compareLogic.Config.CompareChildren = true; ComparisonResult test2 = compareLogic.Compare(dec1, dec2); Assert.IsFalse(test2.AreEqual, "Decimal Test - CompareChildren = true"); }
/// <summary> /// Compares an ExpectedExceptions object with an exception. /// </summary> /// <param name="expectedExceptions">The expected exceptions.</param> /// <param name="actualException">The actual exception.</param> /// <returns>Success if the exception matches, skipped if there was no exception and none was expected, or failed if the exception does not match.</returns> public static ComparisonResult CompareException(ExpectedExceptions expectedExceptions, Exception actualException) { if (expectedExceptions == null) { if (actualException != null) { throw actualException; } return(ComparisonResult.Skipped); } else { ComparisonResult result = Verify(expectedExceptions, actualException); if (result != ComparisonResult.Failure) { return(result); } else { if (actualException == null) { throw new TaupoInvalidOperationException("No exception was thrown but one was expected."); } else if (expectedExceptions.ExpectedException != null) { throw new TaupoInvalidOperationException("A different exception was thrown than expected.", actualException); } else { // bug: remove once SqlCeExceptions can be expected. if (actualException.GetType().FullName == "System.Data.SqlServerCe.SqlCeException") { return(ComparisonResult.Success); } throw actualException; } } } }
public void DifferentIntegersShouldNotBeEqualInsideAnAnonymousType() { CompareLogic compareLogic = new CompareLogic(); // try with integers var int1 = new { MyNumber = (int)0 }; var int2 = new { MyNumber = (int)3 }; // test with CompareChildren = false compareLogic.Config.CompareChildren = false; ComparisonResult test3 = compareLogic.Compare(int1, int2); Assert.IsFalse(test3.AreEqual, "int Test - CompareChildren = false"); // test with CompareChildren = true compareLogic.Config.CompareChildren = true; ComparisonResult test4 = compareLogic.Compare(int1, int2); Assert.AreEqual(1, test4.Differences.Count); Assert.IsFalse(test4.AreEqual, "int Test - CompareChildren = true"); }
private ComparisonResult EvaluateConsideringPlaceholders(string controlText, string testText, ComparisonResult outcome) { Match m = placeholderRegex.Match(controlText); if (m.Success) { string keyword = m.Groups[2].Captures[0].Value.Trim(); if (IsKnown(keyword)) { if (m.Groups[1].Captures[0].Value.Trim() != controlText.Trim()) { throw new XMLUnitException("The placeholder must exclusively occupy the text node."); } return(Evaluate(keyword, testText)); } } // no placeholder at all or unknown keyword return(outcome); }
//[Test] public void ParentIsAClassTest() { Person person1 = new Person(); person1.Name = "Batman"; Person person2 = new Person(); person2.Name = "Robin"; ComparisonResult result = _compare.Compare(person1, person2); Assert.IsTrue(result.Differences[0].ParentObject1 != null); Assert.IsTrue(result.Differences[0].ParentObject2 != null); Assert.IsTrue(result.Differences[0].ParentObject1.Target.GetType() == typeof(Person)); Assert.IsTrue(result.Differences[0].ParentObject2.Target.GetType() == typeof(Person)); Assert.AreEqual("Batman", ((Person)result.Differences[0].ParentObject1.Target).Name); Assert.AreEqual("Robin", ((Person)result.Differences[0].ParentObject2.Target).Name); }
public void Comparing_values(object value1, object value2, ComparisonResult expected) { "Given a Fixture" .Given(() => Fixture = new Fixture()); "And an EnumComparer" .And(() => SUT = Fixture.Create<EnumComparison>()); "And a Comparison context object" .And(() => { Context = new ComparisonContext("Property"); }); "When calling Compare({0}, {1})" .When(() => Result = SUT.Compare(Context, value1, value2)); "Then it should return {2}" .Then(() => Result.ShouldBe(expected)); if (expected == ComparisonResult.Pass) { "And it should not add any differences" .And(() => Context.Differences.Count.ShouldBe(0)); } else { var expectedDifference = new Difference { Breadcrumb = "Property", Value1 = value1, Value2 = value2 }; "And it should add a differences" .And(() => Context.Differences[0].ShouldBe(expectedDifference)); } }
public ComparisonResult Evaluate(Comparison comparison, ComparisonResult orig) { Called = true; return ret; }
public void When_comparing_sets(IEnumerable value1, IEnumerable value2, ComparisonResult expected) { var list1 = value1.Cast<object>().ToArray(); var list2 = value2.Cast<object>().ToArray(); "Given a fixture" .Given(() => { Fixture = new Fixture(); Fixture.Customize(new AutoMoqCustomization()); }); "And an inner comparison" .And(() => { Inner = Fixture.Freeze<Mock<IComparison>>(); Inner .Setup(x => x.CanCompare(It.IsAny<Type>(), It.IsAny<Type>())) .Returns(true); Inner .Setup(x => x.Compare(It.IsAny<IComparisonContext>(), It.IsAny<object>(), It.IsAny<object>())) .Returns<IComparisonContext, object, object>((c, v1, v2) => v1.Equals(v2) ? ComparisonResult.Pass : ComparisonResult.Fail); }); "And a SetComparison" .And(() => SUT = Fixture.Create<SetComparison>()); "And a Comparison context object" .And(() => Context = new ComparisonContext("Set")); "When comparing enumerables" .When(() => Result = SUT.Compare(Context, value1, value2)); "Then it should return {2}" .Then(() => Result.ShouldBe(expected)); if (list1.Length == list2.Length) { "And it should call the inner comparison Compare for each element in the set" .And(() => { for (var i = 0; i < list1.Length; i++) { var local = i; Inner.Verify(x => x.Compare( It.IsAny<ComparisonContext>(), list1[local], It.IsAny<object>()), Times.AtLeastOnce()); } }); if (expected == ComparisonResult.Fail) { "And it should add a SetDifference" .And(() => Context.Differences[0].ShouldBeTypeOf<SetDifference>()); } } else { var expectedDifference = new Difference { Breadcrumb = "Set", ChildProperty = "Count", Value1 = list1.Length, Value2 = list2.Length }; "And it should add a Difference" .And(() => Context.Differences[0].ShouldBe(expectedDifference)); } }
/// <summary> /// Add a difference to the result /// </summary> /// <param name="difference">The difference to add to the result</param> /// <param name="result">The comparison result</param> protected void AddDifference(ComparisonResult result, Difference difference) { if (result == null) throw new ArgumentNullException("result"); if (difference == null) throw new ArgumentNullException("difference"); difference.ActualName = result.Config.ActualName; difference.ExpectedName = result.Config.ExpectedName; difference.Object1TypeName = difference.Object1 != null && difference.Object1.Target != null ? difference.Object1.Target.GetType().Name : "null"; difference.Object2TypeName = difference.Object2 != null && difference.Object2.Target != null ? difference.Object2.Target.GetType().Name : "null"; result.Differences.Add(difference); result.Config.DifferenceCallback(difference); }
internal Evaluator(ComparisonResult ret) { this.ret = ret; }
/// <summary> /// Difference evaluator that just echos the result passed in. /// </summary> public static ComparisonResult Accept(Comparison comparison, ComparisonResult outcome) { return outcome; }
// This is called by diff.CompareEvent private void Compared(ComparisonResult result, FileSystemInfo[] files, bool isADir) { #region SizeDifferent if (result == ComparisonResult.SizeDifferent) // Can only be files, not dirs { FileActions action = this.defSize; if (action == FileActions.Ask) action = this.AskWhatToDo(files, isADir, -1); // Need to ask user if // default action is Ask if (action == FileActions.CancelCopy) // user choice: Cancel { this.CancelNow(); return; } switch (action) { case FileActions.Ignore: // Do nothing break; case FileActions.Delete: // The file(s) must be deleted if (files[0].Exists) { files[0].Delete(); } else { files[1].Delete(); } break; // Copy by looking at the dates ************************************* case FileActions.OverwriteNewer: // D this.OverWriteDate((FileInfo)files[0], (FileInfo)files[1], false); // break; // A // case FileActions.OverwriteOlder: // T this.OverWriteDate((FileInfo)files[0], (FileInfo)files[1], true); // break; // E // //******************************************************************** case FileActions.Write1to2: // Writes the file to folder 2 (the file should exist) try { ((FileInfo)files[0]).CopyTo(files[1].FullName, true); } catch (Exception e) // This should NOT happen (and it doesn't, usually...) { string[] f = new string[2]; f[0] = files[0].FullName; f[1] = files[1].FullName; this.ErrorEvent(e, f); } break; case FileActions.Write2to1: // Writes the file to folder 1 (the file should exist) try { ((FileInfo)files[1]).CopyTo(files[0].FullName, true); } catch (Exception e) // This should NOT happen (and it doesn't, usually...) { string[] f = new string[2]; f[0] = files[0].FullName; f[1] = files[1].FullName; this.ErrorEvent(e, f); } break; } } #endregion #region MissingInFolderx if (result == ComparisonResult.MissingInFolder1 | result == ComparisonResult.MissingInFolder2) { FileActions action = FileActions.Ask; int missingIndex = 0; // used only for the AskWhatToDo event // if default action is Ask if (result == ComparisonResult.MissingInFolder1) { action = this.defMissing1; missingIndex = 1; } if (result == ComparisonResult.MissingInFolder2) { action = this.defMissing2; missingIndex = 2; } if (action == FileActions.Ask) action = this.AskWhatToDo(files, isADir, missingIndex); if (action == FileActions.CancelCopy) { this.CancelNow(); return; } switch (action) { case FileActions.Ignore: break; case FileActions.Copy: // Copy the missing file or dir if (!isADir) // It's not a dir (incredible!) { int missingFileIndex = missingIndex - 1; // missingFileIndex has to be 0-based int presentFileIndex = Math.Abs(missingFileIndex - 1); try { ((FileInfo)files[presentFileIndex]).CopyTo(files[missingFileIndex].FullName, false); } catch (IOException e) // This should not happen because files[presentIndex] should not exist { string[] f = new string[2]; f[0] = files[0].FullName; f[1] = files[1].FullName; this.ErrorEvent(e, f); } } else if (isADir) // It's a dir (wow!) { int missingFolderIndex = missingIndex - 1; int presentFolderIndex = Math.Abs(missingFolderIndex - 1); RecursiveCopy rCopy = new RecursiveCopy(files[presentFolderIndex].FullName, files[missingFolderIndex].FullName, false); rCopy.ErrorEvent += this.ErrorEvent; rCopy.Copy(); } break; case FileActions.Delete: // The existing file or dir will be deleted if (isADir) { if (files[0].Exists) ((DirectoryInfo)files[0]).Delete(true); else if (files[1].Exists) ((DirectoryInfo)files[1]).Delete(true); } else { if (files[0].Exists) ((FileInfo)files[0]).Delete(); else if (files[1].Exists) ((FileInfo)files[1]).Delete(); } break; case FileActions.Write1to2: // Shall write the file or dir from folder index 0 to folder index 1 if (files[0].Exists & isADir) { RecursiveCopy rCopy = new RecursiveCopy(files[0].FullName, files[1].FullName, false); rCopy.ErrorEvent += this.ErrorEvent; rCopy.Copy(); } else if (files[0].Exists & !isADir) { try { ((FileInfo)files[0]).CopyTo(files[1].FullName, false); // Copies the file } catch (Exception e) { string[] f = new string[2]; f[0] = files[0].FullName; f[1] = files[1].FullName; this.ErrorEvent(e, f); } } break; case FileActions.Write2to1: // Shall write the file or dir from folder index 1 to folder index 0 if (files[1].Exists & isADir) { RecursiveCopy rCopy = new RecursiveCopy(files[1].FullName, files[0].FullName, false); rCopy.ErrorEvent += this.ErrorEvent; rCopy.Copy(); } else if (files[1].Exists & !isADir) { try { ((FileInfo)files[1]).CopyTo(files[0].FullName, false); } catch (Exception e) { string[] f = new string[2]; f[0] = files[0].FullName; f[1] = files[1].FullName; this.ErrorEvent(e, f); } } break; } } #endregion }
public void When_comparing_objects_of_the_same_type(bool ignoreUnmatchedProperties, object value1, object value2, ComparisonResult expected) { SetUp(); "And IgnoreUnmatchedProperties is set to {0}" .And(() => SUT.IgnoreUnmatchedProperties = ignoreUnmatchedProperties); "When calling Compare" .When(() => Result = SUT.Compare(Context, value1, value2)); "It should return {3}" .Then(() => Result.ShouldBe(expected)); if (expected == ComparisonResult.Fail) { "And it should add a difference to the context" .And(() => Context.Differences.Count.ShouldBe(1)); } else { "And there should be no differences in the context" .And(() => Context.Differences.Count.ShouldBe(0)); } "And it should call Compare on the inner comparison for each property" .And(() => { var properties1 = value1.GetType().GetProperties(); var properties2 = value2.GetType().GetProperties().ToDictionary(x => x.Name); foreach (var p1 in properties1) { if(!properties2.ContainsKey(p1.Name)) continue; var p2 = properties2[p1.Name]; var v1 = p1.GetValue(value1); var v2 = p2.GetValue(value2); Inner.Verify(x => x.Compare(It.Is<IComparisonContext>(c => c.Breadcrumb == "Property." + p1.Name), v1, v2), Times.Once()); } }); }
/// <summary> /// Add a difference to the result /// </summary> /// <param name="difference">The difference to add to the result</param> /// <param name="result">The comparison result</param> protected void AddDifference(ComparisonResult result, Difference difference) { difference.ActualName = result.Config.ActualName; difference.ExpectedName = result.Config.ExpectedName; difference.Object1TypeName = difference.Object1 != null && difference.Object1.Target != null ? difference.Object1.Target.GetType().Name : "null"; difference.Object2TypeName = difference.Object2 != null && difference.Object2.Target != null ? difference.Object2.Target.GetType().Name : "null"; result.Differences.Add(difference); result.Config.DifferenceCallback(difference); }
private string GetMatchIndex(ComparisonResult result, List<string> spec, object currentObject) { List<PropertyInfo> properties = Cache.GetPropertyInfo(result, currentObject.GetType()).ToList(); StringBuilder sb = new StringBuilder(); foreach (var item in spec) { var info = properties.FirstOrDefault(o => o.Name == item); if (info == null) { throw new Exception(string.Format("Invalid CollectionMatchingSpec. No such property {0} for type {1} ", item, currentObject.GetType().Name)); } var propertyValue = info.GetValue(currentObject, null); if (propertyValue == null) { sb.AppendFormat("{0}:(null),",item); } else { string formatString = string.Format("{{0}}:{{1{0}}},", info.PropertyType.Name == "Decimal" ? ":N" : string.Empty); sb.Append(string.Format(formatString, item, propertyValue)); } } if (sb.Length == 0) sb.Append(currentObject); return sb.ToString().TrimEnd(','); }
private List<string> GetMatchingSpec(ComparisonResult result,Type type) { //The user defined a key for the order if (result.Config.CollectionMatchingSpec.Keys.Contains(type)) { return result.Config.CollectionMatchingSpec.First(p => p.Key == type).Value.ToList(); } //Make a key out of primative types, date, decimal, string, guid, and enum of the class List<string> list = Cache.GetPropertyInfo(result, type) .Where(o => o.CanWrite && (TypeHelper.IsSimpleType(o.PropertyType) || TypeHelper.IsEnum(o.PropertyType))) .Select(o => o.Name).ToList(); //Remove members to ignore in the key foreach (var member in result.Config.MembersToIgnore) { list.Remove(member); } return list; }
private ComparisonResult ResultGrabber(Comparison comparison, ComparisonResult outcome) { this.outcome = outcome; return outcome; }
public void When_comparing_sets(IDictionary value1, IDictionary value2, ComparisonResult expected) { SetUp(); "When comparing dictionaries" .When(() => Result = SUT.Compare(Context, value1, value2)); "Then it should return {2}" .Then(() => Result.ShouldBe(expected)); }
public EchoComparison(ComparisonResult result) { this.result = result; }
public void When_testing_nulls(object value1, object value2, ComparisonResult expected) { "Given a Comparison context object" .Given(() => Context = Fixture.Create<Mock<IComparisonContext>>()); "When calling Compare" .When(() => Result = SUT.Compare(Context.Object, value1, value2)); "Then it should return {2}" .And(() => Result.ShouldBe(expected)); "And it should not call the inner comparers CanCompare" .And(() => Inner.VerifyAll(c => c.CanCompare(It.IsAny<Type>(), It.IsAny<Type>()), Times.Never())); "And it should not call the inner comparers Compare" .And(() => Inner.VerifyAll(c => c.Compare(Context.Object, value1, value2), Times.Never())); }
public void ComparisonPerformed(Comparison comparison, ComparisonResult outcome) { Assert.Greater(expectedInvocations, invoked); invoked++; Assert.AreEqual(type, comparison.Type); Assert.AreEqual(ComparisonResult.CRITICAL, outcome); if (withXPath) { Assert.AreEqual(controlXPath, comparison.ControlDetails.XPath, "Control XPath"); Assert.AreEqual(testXPath, comparison.TestDetails.XPath, "Test XPath"); } }
private void FireComparisonPerformed(Comparison comp, ComparisonResult outcome) { if (ComparisonListener != null) { ComparisonListener(comp, outcome); } if (outcome == ComparisonResult.EQUAL && MatchListener != null) { MatchListener(comp, outcome); } else if (outcome != ComparisonResult.EQUAL && DifferenceListener != null) { DifferenceListener(comp, outcome); } }