दिलचस्प पोस्ट
सीएसएस मीडिया प्रश्नों की चौड़ाई और न्यूनतम-डिवाइस चौड़ाई परस्पर विरोधी है? कैसे const_iterator की constness को हटाने के लिए? मैं स्थानीय रूप से कुछ फाइलों को अनदेखा करने के लिए कैसे git कॉन्फ़िगर करूं? हमें वीपीसी में निजी सबनेट की आवश्यकता क्यों है? क्या मैं एक एंड्रॉइड डिवाइस की एलईडी तीव्रता बदल सकता हूँ? मौजूदा गीट काम के पेड़ से स्थानीय (अनट्रैकेड) फ़ाइलों को कैसे निकालना है? 'अनपैक करने के लिए बहुत अधिक मूल्य', एक डिक्ट पर फिर से चलना कुंजी => स्ट्रिंग, मान => सूची Google ने गुलाबी रंग में खोज क्षेत्रों को उजागर करना शुरू कर दिया है क्या यह सुविधा Google Maps API 3 में उपलब्ध है? XML फ़ाइल का निर्माण XDocument में सी # का उपयोग करता है जावा: आधार और एक्सटेंशन में फ़ाइल नाम को विभाजित करना * ngFor का उपयोग करके वस्तु की कुंजी और मूल्य का उपयोग लम्बा लूप में चर कैप्चर – यहाँ क्या होता है? क्या आपने कभी किसी भी प्रोजेक्ट में फँटम रिफरेंस का उपयोग किया है? अन्य ऐप से फेसबुक ऐप लॉन्च करें प्राधिकरण सर्वर समापन बिंदु कॉन्फ़िगर करें

एनयूनिट में दो वस्तुओं के बीच समानता की तुलना करें

मैं यह दावा करने की कोशिश कर रहा हूं कि एक ऑब्जेक्ट दूसरे ऑब्जेक्ट के लिए "बराबर" है।

ऑब्जेक्ट्स सिर्फ एक क्लास के उदाहरण हैं जो कि सार्वजनिक गुणों का एक समूह है। क्या NUnit संपत्तियों के आधार पर समानता का दावा करने का एक आसान तरीका है?

यह मेरा वर्तमान समाधान है, लेकिन मुझे लगता है कि कुछ बेहतर हो सकता है:

Assert.AreEqual(LeftObject.Property1, RightObject.Property1) Assert.AreEqual(LeftObject.Property2, RightObject.Property2) Assert.AreEqual(LeftObject.Property3, RightObject.Property3) ... Assert.AreEqual(LeftObject.PropertyN, RightObject.PropertyN) 

जो संग्रह के लिए मैं जा रहा हूं, वह उसी संग्रह में होगा, जैसा संग्रह संग्रह, जिसमें एनयूआईएनटी यह पुष्टि करता है कि दो संग्रह की सामग्री समान हैं।

वेब के समाधान से एकत्रित समाधान "एनयूनिट में दो वस्तुओं के बीच समानता की तुलना करें"

ओवरराइड। अपने ऑब्जेक्ट के लिए और यूनिट टेस्ट में परीक्षाएं तो आप बस ऐसा कर सकते हैं:

 Assert.AreEqual(LeftObject, RightObject); 

बेशक, इसका मतलब यह हो सकता है कि आप सभी अलग-अलग तुलना एक्स्प्लोर विधि में ले जाएं, लेकिन इससे आपको कई परीक्षणों के लिए कार्यान्वयन का पुन: उपयोग करने की अनुमति मिलेगी, और संभवत: यह समझने में सक्षम होगा कि क्या वस्तुओं को खुद भाई-बहनों के साथ तुलना करने में सक्षम होना चाहिए।

यदि आप किसी भी कारण के बराबर ओवरराइड नहीं कर सकते हैं, तो आप एक सहायक पद्धति का निर्माण कर सकते हैं, जो प्रत्येक संपत्ति के प्रति प्रतिबिंब के माध्यम से सार्वजनिक संपत्तियों के माध्यम से दोहराता है। कुछ इस तरह:

 public static class AssertEx { public static void PropertyValuesAreEquals(object actual, object expected) { PropertyInfo[] properties = expected.GetType().GetProperties(); foreach (PropertyInfo property in properties) { object expectedValue = property.GetValue(expected, null); object actualValue = property.GetValue(actual, null); if (actualValue is IList) AssertListsAreEquals(property, (IList)actualValue, (IList)expectedValue); else if (!Equals(expectedValue, actualValue)) Assert.Fail("Property {0}.{1} does not match. Expected: {2} but was: {3}", property.DeclaringType.Name, property.Name, expectedValue, actualValue); } } private static void AssertListsAreEquals(PropertyInfo property, IList actualList, IList expectedList) { if (actualList.Count != expectedList.Count) Assert.Fail("Property {0}.{1} does not match. Expected IList containing {2} elements but was IList containing {3} elements", property.PropertyType.Name, property.Name, expectedList.Count, actualList.Count); for (int i = 0; i < actualList.Count; i++) if (!Equals(actualList[i], expectedList[i])) Assert.Fail("Property {0}.{1} does not match. Expected IList with element {1} equals to {2} but was IList with element {1} equals to {3}", property.PropertyType.Name, property.Name, expectedList[i], actualList[i]); } } 

परीक्षण प्रयोजनों के लिए बराबर नहीं ओवरराइड करें यह थकाऊ है और डोमेन तर्क को प्रभावित करता है बजाय,

वस्तु के डेटा की तुलना करने के लिए JSON का उपयोग करें

आपकी वस्तुओं पर कोई अतिरिक्त तर्क नहीं है परीक्षण के लिए कोई अतिरिक्त कार्य नहीं

बस इस सरल विधि का उपयोग करें:

 public static void AreEqualByJson(object expected, object actual) { var serializer = new System.Web.Script.Serialization.JavaScriptSerializer(); var expectedJson = serializer.Serialize(expected); var actualJson = serializer.Serialize(actual); Assert.AreEqual(expectedJson, actualJson); } 

यह महान बाहर काम करने के लिए लगता है टेस्ट रनर परिणाम जानकारी JSON स्ट्रिंग तुलना (ऑब्जेक्ट ग्राफ़) को दिखाएगी, ताकि आप सीधे गलत क्या देखते हैं।

यह भी ध्यान दें! यदि आपके पास बड़ी जटिल ऑब्जेक्ट हैं और आप उन हिस्सों की तुलना करना चाहते हैं, तो आप ( अनुक्रम डेटा के लिए LINQ का उपयोग कर सकते हैं) उपरोक्त विधि के साथ उपयोग करने के लिए अनाम वस्तुएं बना सकते हैं।

 public void SomeTest() { var expect = new { PropA = 12, PropB = 14 }; var sut = loc.Resolve<SomeSvc>(); var bigObjectResult = sut.Execute(); // This will return a big object with loads of properties AssExt.AreEqualByJson(expect, new { bigObjectResult.PropA, bigObjectResult.PropB }); } 

FluentAssertions लाइब्रेरी आज़माएं:

 dto.ShouldHave(). AllProperties().EqualTo(customer); 

http://www.fluentassertions.com/

यह NuGet का उपयोग करके भी इंस्टॉल किया जा सकता है

मैं परीक्षण को सक्षम करने के लिए बस बराबर नहीं करना चाहता। यह मत भूलो कि यदि आप ओवरराइड कर देते हैं तो आप वास्तव में GetHashCode को ओवरराइड कर सकते हैं या आप अनपेक्षित परिणाम प्राप्त कर सकते हैं यदि आप उदाहरण के लिए एक शब्दकोश में अपनी ऑब्जेक्ट का उपयोग कर रहे हैं।

मैं ऊपर प्रतिबिंब दृष्टिकोण की तरह करता हूं क्योंकि यह भविष्य में गुणों के अतिरिक्त के लिए पूरा करता है

एक त्वरित और सरल समाधान के लिए, इसके लिए सबसे आसान आसान या तो एक सहायक पद्धति का निर्माण होता है जो परीक्षण करता है यदि ऑब्जेक्ट समान होते हैं, या किसी क्लासिक पर आईईक्वैलिटी कॉम्पैयरर को कार्यान्वित करते हैं तो आप अपने परीक्षणों के लिए निजी बनाते हैं। IqualityComparer समाधान का उपयोग करते समय आपको GetHashCode के कार्यान्वयन से परेशान होने की आवश्यकता नहीं है उदाहरण के लिए:

 // Sample class. This would be in your main assembly. class Person { public string Name { get; set; } public int Age { get; set; } } // Unit tests [TestFixture] public class PersonTests { private class PersonComparer : IEqualityComparer<Person> { public bool Equals(Person x, Person y) { if (x == null && y == null) { return true; } if (x == null || y == null) { return false; } return (x.Name == y.Name) && (x.Age == y.Age); } public int GetHashCode(Person obj) { throw new NotImplementedException(); } } [Test] public void Test_PersonComparer() { Person p1 = new Person { Name = "Tom", Age = 20 }; // Control data Person p2 = new Person { Name = "Tom", Age = 20 }; // Same as control Person p3 = new Person { Name = "Tom", Age = 30 }; // Different age Person p4 = new Person { Name = "Bob", Age = 20 }; // Different name. Assert.IsTrue(new PersonComparer().Equals(p1, p2), "People have same values"); Assert.IsFalse(new PersonComparer().Equals(p1, p3), "People have different ages."); Assert.IsFalse(new PersonComparer().Equals(p1, p4), "People have different names."); } } 

मैंने यहां उल्लेख कई तरीकों की कोशिश की है। अधिकांश में आपकी वस्तुओं को क्रमबद्ध करना और स्ट्रिंग की तुलना करना तुलना करना शामिल है। जबकि सुपर आसान और आम तौर पर बहुत ही प्रभावी, मैंने पाया है कि जब आपको कोई असफलता मिलती है और कुछ ऐसा हो जाता है तो यह थोड़ा कम आता है:

 Expected string length 2326 but was 2342. Strings differ at index 1729. 

पता लगाना कि अंतर कहां से कम है, यह कहने के लिए एक दर्द है।

FluentAssertions के साथ ' ऑब्जेक्ट ग्राफ़ तुलना (यानी a.ShouldBeEquivalentTo(b) ), आपको यह वापस मिलता है:

 Expected property Name to be "Foo" but found "Bar" 

यह बहुत अच्छा है अब फ्लुएन्टएस्सेरशन प्राप्त करें , आप बाद में आनंद लेंगे (और यदि आप इसे ऊपर उठाते हैं, तो कृपया डीकेएल के उत्तर को भी ऊपर उठाना दें जहां फ़्लुएंटएस्सेरशन का पहला सुझाव दिया गया था)।

मैं ChrisYoxall से सहमत हूं – अपने मुख्य कोड में परीक्षण के उद्देश्यों के लिए समान रूप से लागू करना अच्छा नहीं है

यदि आप बराबर लागू कर रहे हैं, क्योंकि कुछ अनुप्रयोग तर्क के लिए यह आवश्यक है, तो यह ठीक है, लेकिन सामान को क्लैटर करने से शुद्ध परीक्षण-केवल कोड को रखें (परीक्षण के लिए भी जाँच की सिमेंटिक आपके एप की आवश्यकता से भिन्न हो सकते हैं)।

संक्षेप में, अपने क्लास से केवल-परीक्षण कोड रखें।

प्रतिभा का उपयोग करते हुए गुणों की सरल उथले तुलना अधिकांश कक्षाओं के लिए पर्याप्त होनी चाहिए, यद्यपि आपको अवशोषित करने की आवश्यकता हो सकती है अगर आपके ऑब्जेक्ट में जटिल गुण हैं यदि निम्नलिखित संदर्भ, परिपत्र संदर्भ या इसी तरह से सावधान रहें

धूर्त

अधिकतम Wikstrom के JSON समाधान (ऊपर) मुझे सबसे अधिक समझ में आता है, यह कम, साफ है और सबसे महत्वपूर्ण यह काम करता है। व्यक्तिगत रूप से हालांकि मैं एक अलग विधि के रूप में JSON रूपांतरण को लागू करना पसंद करता हूं और इस तरह से यूनिट टेस्ट के अंदर वापस आना चाहता हूं …

हेल्पर विधि:

 public string GetObjectAsJson(object obj) { System.Web.Script.Serialization.JavaScriptSerializer oSerializer = new System.Web.Script.Serialization.JavaScriptSerializer(); return oSerializer.Serialize(obj); } 

अध्याय परीक्षा :

 public void GetDimensionsFromImageTest() { Image Image = new Bitmap(10, 10); ImageHelpers_Accessor.ImageDimensions expected = new ImageHelpers_Accessor.ImageDimensions(10,10); ImageHelpers_Accessor.ImageDimensions actual; actual = ImageHelpers_Accessor.GetDimensionsFromImage(Image); /*USING IT HERE >>>*/ Assert.AreEqual(GetObjectAsJson(expected), GetObjectAsJson(actual)); } 

एफवाईआई – आपको अपने समाधान में सिस्टम। वेब के एक्सटेंशन को संदर्भ जोड़ना पड़ सकता है।

एनयूनिट 2.4.2 में जोड़ा गया संपत्ति की कमी , ओपी के मूल एक से अधिक पठनीय समाधान प्रदान करते हैं, और इससे बेहतर विफलता संदेश उत्पन्न होता है। यह किसी भी तरह से सामान्य नहीं है, लेकिन अगर आपको इसे बहुत अधिक वर्गों के लिए करने की आवश्यकता नहीं है, तो यह बहुत ही पर्याप्त समाधान है।

 Assert.That(ActualObject, Has.Property("Prop1").EqualTo(ExpectedObject.Prop1) & Has.Property("Prop2").EqualTo(ExpectedObject.Prop2) & Has.Property("Prop3").EqualTo(ExpectedObject.Prop3) // ... 

Equals को कार्यान्वित करने के लिए सामान्य उद्देश्य के रूप में नहीं बल्कि यह बहुत बेहतर विफलता संदेश देता है

 Assert.AreEqual(ExpectedObject, ActualObject); 

एक अन्य विकल्प NUnit सार Constraint कक्षा को लागू करने के द्वारा एक कस्टम बाधा लिखना है। थोड़ा वाक्यविन्यास चीनी प्रदान करने के लिए एक सहायक वर्ग के साथ, परिणामी परीक्षा कोड सुखद रूप से संक्षिप्त और पठनीय उदा

 Assert.That( LeftObject, PortfolioState.Matches( RightObject ) ); 

एक चरम उदाहरण के लिए, क्लास पर विचार करें जिसमें 'केवल-पढ़ने योग्य' सदस्य हैं, ये IEquatable नहीं है, और आप परीक्षण के तहत वर्ग को नहीं बदल सकते, भले ही आप चाहते थे:

 public class Portfolio // Somewhat daft class for pedagogic purposes... { // Cannot be instanitated externally, instead has two 'factory' methods private Portfolio(){ } // Immutable properties public string Property1 { get; private set; } public string Property2 { get; private set; } // Cannot be accessed externally public string Property3 { get; private set; } // Cannot be accessed externally // 'Factory' method 1 public static Portfolio GetPortfolio(string p1, string p2, string p3) { return new Portfolio() { Property1 = p1, Property2 = p2, Property3 = p3 }; } // 'Factory' method 2 public static Portfolio GetDefault() { return new Portfolio() { Property1 = "{{NONE}}", Property2 = "{{NONE}}", Property3 = "{{NONE}}" }; } } 

Constraint वर्ग के लिए अनुबंध के लिए एक Matches और WriteDescriptionTo ओवरराइड करने की आवश्यकता होती है (एक बेमेल के मामले में, अपेक्षित मूल्य के लिए एक कथन), लेकिन WriteActualValueTo (वास्तविक मान के लिए कथा) को ओवरराइड भी समझ में आता है:

 public class PortfolioEqualityConstraint : Constraint { Portfolio expected; string expectedMessage = ""; string actualMessage = ""; public PortfolioEqualityConstraint(Portfolio expected) { this.expected = expected; } public override bool Matches(object actual) { if ( actual == null && expected == null ) return true; if ( !(actual is Portfolio) ) { expectedMessage = "<Portfolio>"; actualMessage = "null"; return false; } return Matches((Portfolio)actual); } private bool Matches(Portfolio actual) { if ( expected == null && actual != null ) { expectedMessage = "null"; expectedMessage = "non-null"; return false; } if ( ReferenceEquals(expected, actual) ) return true; if ( !( expected.Property1.Equals(actual.Property1) && expected.Property2.Equals(actual.Property2) && expected.Property3.Equals(actual.Property3) ) ) { expectedMessage = expected.ToStringForTest(); actualMessage = actual.ToStringForTest(); return false; } return true; } public override void WriteDescriptionTo(MessageWriter writer) { writer.WriteExpectedValue(expectedMessage); } public override void WriteActualValueTo(MessageWriter writer) { writer.WriteExpectedValue(actualMessage); } } 

प्लस सहायक वर्ग:

 public static class PortfolioState { public static PortfolioEqualityConstraint Matches(Portfolio expected) { return new PortfolioEqualityConstraint(expected); } public static string ToStringForTest(this Portfolio source) { return String.Format("Property1 = {0}, Property2 = {1}, Property3 = {2}.", source.Property1, source.Property2, source.Property3 ); } } 

उदाहरण उपयोग:

 [TestFixture] class PortfolioTests { [Test] public void TestPortfolioEquality() { Portfolio LeftObject = Portfolio.GetDefault(); Portfolio RightObject = Portfolio.GetPortfolio("{{GNOME}}", "{{NONE}}", "{{NONE}}"); Assert.That( LeftObject, PortfolioState.Matches( RightObject ) ); } } 

मैं @ जुआनमा के उत्तर पर निर्माण करेगा हालांकि, मेरा मानना ​​है कि इसे यूनिट परीक्षण दावे के साथ लागू नहीं किया जाना चाहिए। यह एक ऐसी सुविधा है जो गैर-परीक्षण कोड द्वारा कुछ परिस्थितियों में बहुत अच्छी तरह से उपयोग किया जा सकता है।

मैंने इस मामले पर एक लेख लिखा था http://timoch.com/blog/2013/06/unit-test-equality-is-not-domain-equality/

मेरा प्रस्ताव इस प्रकार है:

 /// <summary> /// Returns the names of the properties that are not equal on a and b. /// </summary> /// <param name="a"></param> /// <param name="b"></param> /// <returns>An array of names of properties with distinct /// values or null if a and b are null or not of the same type /// </returns> public static string[] GetDistinctProperties(object a, object b) { if (object.ReferenceEquals(a, b)) return null; if (a == null) return null; if (b == null) return null; var aType = a.GetType(); var bType = b.GetType(); if (aType != bType) return null; var props = aType.GetProperties(); if (props.Any(prop => prop.GetIndexParameters().Length != 0)) throw new ArgumentException("Types with index properties not supported"); return props .Where(prop => !Equals(prop.GetValue(a, null), prop.GetValue(b, null))) .Select(prop => prop.Name).ToArray(); } 

NUnit के साथ इसका उपयोग करना

 Expect(ReflectionUtils.GetDistinctProperties(tile, got), Empty); 

बेमेल पर निम्न संदेश पैदा करता है

 Expected: <empty> But was: < "MagmaLevel" > at NUnit.Framework.Assert.That(Object actual, IResolveConstraint expression, String message, Object[] args) at Undermine.Engine.Tests.TileMaps.BasicTileMapTests.BasicOperations() in BasicTileMapTests.cs: line 29 

https://github.com/kbilsted/StatePrinter विशेष रूप से लिखित रूप से ऑब्जेक्ट ग्राफ को डंप करने के लिए आसान इकाई परीक्षण लिखने के उद्देश्य से स्ट्रिंग प्रतिनिधित्व के लिए लिखा गया है।

  • यह विचित्र रूप से आता है कि तरीके को ठीक करने के लिए परीक्षण को सही ढंग से बचने के लिए स्ट्रिंग आसान प्रति-पेस्ट आउटपुट करता है।
  • यह स्वत: पुन: लिखित होने की अनुमति देता है
  • यह सभी इकाई परीक्षण चौखटे के साथ एकीकृत करता है
  • JSON सीरियलाइजेशन के विपरीत, परिपत्र संदर्भ समर्थित हैं
  • आप आसानी से फिल्टर कर सकते हैं, इसलिए प्रकारों के केवल भागों को छोड़ दिया जाता है

दिया हुआ

 class A { public DateTime X; public DateTime Y { get; set; } public string Name; } 

आप एक प्रकार की सुरक्षित तरीके से कर सकते हैं, और दृश्य स्टूडियो के स्वत: पूर्ण होने में फ़ील्ड शामिल या बाहर कर सकते हैं।

  var printer = new Stateprinter(); printer.Configuration.Projectionharvester().Exclude<A>(x => xX, x => xY); var sut = new A { X = DateTime.Now, Name = "Charly" }; var expected = @"new A(){ Name = ""Charly""}"; printer.Assert.PrintIsSame(expected, sut); 

बस Nuget से ExpectedObjects स्थापित करें, आप आसानी से दो ऑब्जेक्ट्स की प्रॉपर्टी वैल्यू, संग्रह के प्रत्येक ऑब्जेक्ट वैल्यू, दो संगठित ऑब्जेक्ट का मान और आंशिक संपत्ति मान की तुलना अज्ञात प्रकार से कर सकते हैं।

मेरे पास गिथूब के कुछ उदाहरण हैं: https://github.com/hatelove/CompareObjectEquals

यहां कुछ उदाहरण दिए गए हैं जिनमें ऑब्जेक्ट की तुलना करने के परिदृश्य शामिल हैं:

  [TestMethod] public void Test_Person_Equals_with_ExpectedObjects() { //use extension method ToExpectedObject() from using ExpectedObjects namespace to project Person to ExpectedObject var expected = new Person { Id = 1, Name = "A", Age = 10, }.ToExpectedObject(); var actual = new Person { Id = 1, Name = "A", Age = 10, }; //use ShouldEqual to compare expected and actual instance, if they are not equal, it will throw a System.Exception and its message includes what properties were not match our expectation. expected.ShouldEqual(actual); } [TestMethod] public void Test_PersonCollection_Equals_with_ExpectedObjects() { //collection just invoke extension method: ToExpectedObject() to project Collection<Person> to ExpectedObject too var expected = new List<Person> { new Person { Id=1, Name="A",Age=10}, new Person { Id=2, Name="B",Age=20}, new Person { Id=3, Name="C",Age=30}, }.ToExpectedObject(); var actual = new List<Person> { new Person { Id=1, Name="A",Age=10}, new Person { Id=2, Name="B",Age=20}, new Person { Id=3, Name="C",Age=30}, }; expected.ShouldEqual(actual); } [TestMethod] public void Test_ComposedPerson_Equals_with_ExpectedObjects() { //ExpectedObject will compare each value of property recursively, so composed type also simply compare equals. var expected = new Person { Id = 1, Name = "A", Age = 10, Order = new Order { Id = 91, Price = 910 }, }.ToExpectedObject(); var actual = new Person { Id = 1, Name = "A", Age = 10, Order = new Order { Id = 91, Price = 910 }, }; expected.ShouldEqual(actual); } [TestMethod] public void Test_PartialCompare_Person_Equals_with_ExpectedObjects() { //when partial comparing, you need to use anonymous type too. Because only anonymous type can dynamic define only a few properties should be assign. var expected = new { Id = 1, Age = 10, Order = new { Id = 91 }, // composed type should be used anonymous type too, only compare properties. If you trace ExpectedObjects's source code, you will find it invoke config.IgnoreType() first. }.ToExpectedObject(); var actual = new Person { Id = 1, Name = "B", Age = 10, Order = new Order { Id = 91, Price = 910 }, }; // partial comparing use ShouldMatch(), rather than ShouldEqual() expected.ShouldMatch(actual); } 

संदर्भ:

  1. अपेक्षित ऑब्जेक्ट्स गिथूब
  2. अपेक्षित ऑब्जेक्ट्स का परिचय

यह एक बहुत पुरानी धागा है, लेकिन मैं सोच रहा था कि अगर कोई कारण है तो कोई जवाब नहीं प्रस्तावित NUnit.Framework.Is.EqualTo और NUnit.Framework.Is.NotEqualTo ?

जैसे कि:

 Assert.That(LeftObject, Is.EqualTo(RightObject)); 

तथा

 Assert.That(LeftObject, Is.Not.EqualTo(RightObject)); 

दोनों वर्गों को दोहराना, और एक स्ट्रिंग की तुलना करें।

संपादित करें: पूरी तरह से काम करता है, यह वह उत्पादन है जिसे मैं एनयूआईआईटी से प्राप्त करता हूं;

 Test 'Telecom.SDP.SBO.App.Customer.Translator.UnitTests.TranslateEaiCustomerToDomain_Tests.TranslateNew_GivenEaiCustomer_ShouldTranslateToDomainCustomer_Test("ApprovedRatingInDb")' failed: Expected string length 2841 but was 5034. Strings differ at index 443. Expected: "...taClasses" />\r\n <ContactMedia />\r\n <Party i:nil="true" /..." But was: "...taClasses" />\r\n <ContactMedia>\r\n <ContactMedium z:Id="..." ----------------------------------------------^ TranslateEaiCustomerToDomain_Tests.cs(201,0): at Telecom.SDP.SBO.App.Customer.Translator.UnitTests.TranslateEaiCustomerToDomain_Tests.Assert_CustomersAreEqual(Customer expectedCustomer, Customer actualCustomer) TranslateEaiCustomerToDomain_Tests.cs(114,0): at Telecom.SDP.SBO.App.Customer.Translator.UnitTests.TranslateEaiCustomerToDomain_Tests.TranslateNew_GivenEaiCustomer_ShouldTranslateToDomainCustomer_Test(String custRatingScenario) 

दो संपादित करें: दो ऑब्जेक्ट समान हो सकते हैं, लेकिन क्रम में क्रमबद्ध किए गए क्रम समान नहीं हैं। इसलिए XML अलग है DOH!

तीन संपादित करें: यह काम करता है मैं इसे अपने परीक्षणों में प्रयोग कर रहा हूं लेकिन आपको उन वस्तुओं को संग्रह के गुणों में जोड़ना होगा जिनके तहत परीक्षण के तहत उन्हें जोड़ा गया है।

निम्नलिखित लिंक को देखें यह कोड परियोजना से एक समाधान है और मैंने इसका इस्तेमाल भी किया है। वस्तुओं की तुलना करने के लिए यह ठीक काम करता है

http://www.codeproject.com/Articles/22709/Testing-Equality-of-Two-Objects?msg=5189539#xx5189539xx

स्ट्रिंग और दो स्ट्रिंग्स की तुलना करें

आश्वस्त करें। पूर्वार्द्ध (JSON.Stringify (LeftObject), JSON.stringify (RightObject))

मैंने एक सरल अभिव्यक्ति फ़ैक्टरी लिखना समाप्त कर दिया है:

 public static class AllFieldsEqualityComprision<T> { public static Comparison<T> Instance { get; } = GetInstance(); private static Comparison<T> GetInstance() { var type = typeof(T); ParameterExpression[] parameters = { Expression.Parameter(type, "x"), Expression.Parameter(type, "y") }; var result = type.GetProperties().Aggregate<PropertyInfo, Expression>( Expression.Constant(true), (acc, prop) => Expression.And(acc, Expression.Equal( Expression.Property(parameters[0], prop.Name), Expression.Property(parameters[1], prop.Name)))); var areEqualExpression = Expression.Condition(result, Expression.Constant(0), Expression.Constant(1)); return Expression.Lambda<Comparison<T>>(areEqualExpression, parameters).Compile(); } } 

और बस इसका इस्तेमाल करें:

 Assert.That( expectedCollection, Is.EqualTo(actualCollection) .Using(AllFieldsEqualityComprision<BusinessCategoryResponse>.Instance)); 

यह बहुत उपयोगी है क्योंकि मुझे ऐसे ऑब्जेक्ट्स के संग्रह की तुलना करना है। और आप इस तुलना कहीं और का उपयोग कर सकते हैं 🙂

यहां उदाहरण के साथ सारांश दिया गया है: https://gist.github.com/Pzixel/b63fea074864892f9aba8ffde312094f