मेरी ऑब्जेक्ट वास्तव में धारावाहिक होने पर इकाई परीक्षण कैसे करें?

Question

मैं नुनिट टेस्ट के साथ सी # 2.0 का उपयोग कर रहा हूं। मेरे पास कुछ वस्तु है जिसे क्रमबद्ध करने की आवश्यकता है। ये वस्तुएं काफी जटिल हैं (विभिन्न स्तरों पर विरासत और इसमें कई वस्तुएं, घटनाएं और प्रतिनिधि शामिल हैं)।

यह सुनिश्चित करने के लिए कि मेरा ऑब्जेक्ट सुरक्षित रूप से क्रमबद्ध है, मैं यूनिट टेस्ट कैसे बना सकता हूं?

Answer 1

मैं काम पर यहाँ कुछ इकाई परीक्षण में यह है:

MyComplexObject dto = new MyComplexObject(); 
MemoryStream mem = new MemoryStream(); 
BinaryFormatter b = new BinaryFormatter(); 
try 
{ 
    b.Serialize(mem, dto); 
} 
catch (Exception ex) 
{ 
    Assert.Fail(ex.Message); 
} 

आपकी मदद कर सकता है ... शायद अन्य विधि बेहतर हो सकता है लेकिन यह एक अच्छी तरह से काम करता है।

Answer 2

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

Answer 3

serialize वस्तु (स्मृति या डिस्क के लिए), यह deserialize, उपयोग प्रतिबिंब फिर

इस मानता है कि (बेशक क्रमबद्धता को छोड़कर) दो, तो रन तुलना करने के लिए उस वस्तु के लिए इकाई परीक्षण के सभी अपने इकाई परीक्षण एक लक्ष्य के रूप एक वस्तु स्वीकार कर सकते हैं के बजाय बनाने के लिए अपने स्वयं

Answer 4

यहाँ एक सामान्य तरीका है:

public static Stream Serialize(object source) 
{ 
    IFormatter formatter = new BinaryFormatter(); 
    Stream stream = new MemoryStream(); 
    formatter.Serialize(stream, source); 
    return stream; 
} 

public static T Deserialize<T>(Stream stream) 
{ 
    IFormatter formatter = new BinaryFormatter(); 
    stream.Position = 0; 
    return (T)formatter.Deserialize(stream); 
} 

public static T Clone<T>(object source) 
{ 
    return Deserialize<T>(Serialize(source)); 
} 

Answer 5

यहाँ एक समाधान है कि रिकर्सिवली कि ओब की जाँच करने के IsSerializable का उपयोग करता है जेक्ट और इसकी सभी गुण Serializable हैं।

private static void AssertThatTypeAndPropertiesAreSerializable(Type type) 
    { 
     // base case 
     if (type.IsValueType || type == typeof(string)) return; 

     Assert.IsTrue(type.IsSerializable, type + " must be marked [Serializable]"); 

     foreach (var propertyInfo in type.GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance)) 
     { 
      if (propertyInfo.PropertyType.IsGenericType) 
      { 
       foreach (var genericArgument in propertyInfo.PropertyType.GetGenericArguments()) 
       { 
        if (genericArgument == type) continue; // base case for circularly referenced properties 
        AssertThatTypeAndPropertiesAreSerializable(genericArgument); 
       } 
      } 
      else if (propertyInfo.GetType() != type) // base case for circularly referenced properties 
       AssertThatTypeAndPropertiesAreSerializable(propertyInfo.PropertyType); 
     } 
    } 

Answer 6

दुर्भाग्यवश, आप वास्तव में इसके लिए परीक्षण नहीं कर सकते हैं। इस मामले की कल्पना कीजिए:

[Serializable] 
class Foo { 
    public Bar MyBar { get; set; } 
} 

[Serializable] 
class Bar { 
    int x; 
} 

class DerivedBar : Bar { 
} 

public void TestSerializeFoo() { 
    Serialize(new Foo()); // OK 
    Serialize(new Foo() { MyBar = new Bar() }; // OK 
    Serialize(new Foo() { MyBar = new DerivedBar() }; // Boom 
} 

Answer 7

शायद थोड़ा दिन में देर से, लेकिन अगर आप FluentAssertions पुस्तकालय का उपयोग कर रहे हैं, तो यह एक्सएमएल क्रमबद्धता, द्विआधारी क्रमांकन, और डेटा अनुबंध क्रमबद्धता के लिए कस्टम कथनों है।

theObject.Should().BeXmlSerializable(); 
theObject.Should().BeBinarySerializable(); 
theObject.Should().BeDataContractSerializable(); 

theObject.Should().BeBinarySerializable<MyClass>(
    options => options.Excluding(s => s.SomeNonSerializableProperty));