c# तकन गहरी क्लोनिंग के लिए इकाई परीक्षण




पशु क्लोनिंग (5)

वास्तव में एक स्पष्ट समाधान है जो लगभग उतना काम नहीं लेता है:

  1. ऑब्जेक्ट को एक बाइनरी प्रारूप में क्रमबद्ध करें।
  2. ऑब्जेक्ट क्लोन करें
  3. क्लोन को बाइनरी प्रारूप में क्रमबद्ध करें
  4. बाइट्स की तुलना करें

मान लें कि सीरियलाइजेशन काम करता है - और यह बेहतर है क्योंकि आप इसे क्लोन करने के लिए उपयोग कर रहे हैं - यह बनाए रखना आसान होना चाहिए वास्तव में, यह परिवर्तन से आपके वर्ग की संरचना को पूरी तरह से समझाया जाएगा।

मान लीजिए मेरे पास एक जटिल .NET वर्ग है, जिसमें बहुत से एरेज़ और अन्य वर्ग ऑब्जेक्ट सदस्य हैं। मुझे इस ऑब्जेक्ट का एक गहरा क्लोन उत्पन्न करने में सक्षम होना चाहिए - इसलिए मैं एक क्लोन () विधि लिखूंगा, और इसे एक साधारण बाइनरीफॉर्मर सीरियललाइज़ / डिसेराइलाइज़ के साथ लागू करूँगा- या शायद मैं कुछ अन्य तकनीक का इस्तेमाल करके गहरे क्लोन कर रहा हूं जो कि अधिक त्रुटि प्रवण है और मुझे यह सुनिश्चित करना है कि परीक्षण किया गया है।

ठीक है, तो अब (ठीक है, मुझे पहले यह करना चाहिए था) मैं परीक्षण लिखना चाहूंगा जो क्लोनिंग को कवर करते हैं। वर्ग के सभी सदस्य निजी होते हैं, और मेरी वास्तुकला इतनी अच्छी (!) है कि मुझे सैकड़ों सार्वजनिक संपत्तियों या अन्य एक्सेसर्स लिखने की जरूरत नहीं है। क्लास IComparable या IEquatable नहीं है, क्योंकि यह एप्लिकेशन द्वारा आवश्यक नहीं है। मेरा इकाई परीक्षण उत्पादन कोड के लिए एक अलग विधानसभा में है।

क्लोन ऑब्जेक्ट एक अच्छी प्रतिलिपि है, इसका परीक्षण करने के लिए लोग क्या सोचते हैं? क्या आप क्लास के लिए अपने सभी यूनिट टेस्ट लिखते हैं (या फिर एक बार आप को क्लोन की आवश्यकता की खोज करते हैं) ताकि वे एक 'कुंवारी' ऑब्जेक्ट या उसके क्लोन के साथ लाया जा सके? क्लोनिंग का हिस्सा गहरा पर्याप्त नहीं था, तो आप कैसे परीक्षण करेंगे - क्योंकि यह केवल ऐसी समस्या है जो बाद में घृणित-से-ढूँढें बग्स दे सकती है?


मैं आमतौर पर गहराई में दो ऑब्जेक्ट की तुलना करने के लिए Equals() को क्रियान्वित करता हूं I हो सकता है कि आपको अपने उत्पादन कोड में इसकी ज़रूरत न हो, लेकिन यह बाद में भी उपयोगी हो सकती है और परीक्षण कोड बहुत क्लीनर है।


यह एक नमूना है कि मैंने कुछ समय पहले इसे कैसे कार्यान्वित किया था, हालांकि इसे परिदृश्य के अनुरूप बनाया जाना आवश्यक है। इस मामले में हमारे पास एक बुरा ऑब्जेक्ट श्रृंखला थी जो आसानी से बदल सकती थी और क्लोन को एक बहुत ही महत्वपूर्ण प्रोटोटाइप के कार्यान्वयन के रूप में इस्तेमाल किया गया था और इसलिए मुझे इस परीक्षण को एक साथ पैच (हैक) करना था।

public static class TestDeepClone
    {
        private static readonly List<long> objectIDs = new List<long>();
        private static readonly ObjectIDGenerator objectIdGenerator = new ObjectIDGenerator();

        public static bool DefaultCloneExclusionsCheck(Object obj)
        {
            return
                obj is ValueType ||
                obj is string ||
                obj is Delegate ||
                obj is IEnumerable;
        }

        /// <summary>
        /// Executes various assertions to ensure the validity of a deep copy for any object including its compositions
        /// </summary>
        /// <param name="original">The original object</param>
        /// <param name="copy">The cloned object</param>
        /// <param name="checkExclude">A predicate for any exclusions to be done, i.e not to expect IPolicy items to be cloned</param>
        public static void AssertDeepClone(this Object original, Object copy, Predicate<object> checkExclude)
        {
            bool isKnown;
            if (original == null) return;
            if (copy == null) Assert.Fail("Copy is null while original is not", original, copy);

            var id = objectIdGenerator.GetId(original, out isKnown); //Avoid checking the same object more than once
            if (!objectIDs.Contains(id))
            {
                objectIDs.Add(id);
            }
            else
            {
                return;
            }

            if (!checkExclude(original))
            {
                Assert.That(ReferenceEquals(original, copy) == false);
            }

            Type type = original.GetType();
            PropertyInfo[] propertyInfos = type.GetProperties(BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Public);
            FieldInfo[] fieldInfos = type.GetFields(BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Public);

            foreach (PropertyInfo memberInfo in propertyInfos)
            {
                var getmethod = memberInfo.GetGetMethod();
                if (getmethod == null) continue;
                var originalValue = getmethod.Invoke(original, new object[] { });
                var copyValue = getmethod.Invoke(copy, new object[] { });
                if (originalValue == null) continue;
                if (!checkExclude(originalValue))
                {
                    Assert.That(ReferenceEquals(originalValue, copyValue) == false);
                }

                if (originalValue is IEnumerable && !(originalValue is string))
                {
                    var originalValueEnumerable = originalValue as IEnumerable;
                    var copyValueEnumerable = copyValue as IEnumerable;
                    if (copyValueEnumerable == null) Assert.Fail("Copy is null while original is not", new[] { original, copy });
                    int count = 0;
                    List<object> items = copyValueEnumerable.Cast<object>().ToList();
                    foreach (object o in originalValueEnumerable)
                    {
                        AssertDeepClone(o, items[count], checkExclude);
                        count++;
                    }
                }
                else
                {
                    //Recurse over reference types to check deep clone success
                    if (!checkExclude(originalValue))
                    {
                        AssertDeepClone(originalValue, copyValue, checkExclude);
                    }

                    if (originalValue is ValueType && !(originalValue is Guid))
                    {
                        //check value of non reference type
                        Assert.That(originalValue.Equals(copyValue));
                    }
                }

            }

            foreach (FieldInfo fieldInfo in fieldInfos)
            {
                var originalValue = fieldInfo.GetValue(original);
                var copyValue = fieldInfo.GetValue(copy);
                if (originalValue == null) continue;
                if (!checkExclude(originalValue))
                {
                    Assert.That(ReferenceEquals(originalValue, copyValue) == false);
                }

                if (originalValue is IEnumerable && !(originalValue is string))
                {
                    var originalValueEnumerable = originalValue as IEnumerable;
                    var copyValueEnumerable = copyValue as IEnumerable;
                    if (copyValueEnumerable == null) Assert.Fail("Copy is null while original is not", new[] { original, copy });
                    int count = 0;
                    List<object> items = copyValueEnumerable.Cast<object>().ToList();
                    foreach (object o in originalValueEnumerable)
                    {
                        AssertDeepClone(o, items[count], checkExclude);
                        count++;
                    }
                }
                else
                {
                    //Recurse over reference types to check deep clone success
                    if (!checkExclude(originalValue))
                    {
                        AssertDeepClone(originalValue, copyValue, checkExclude);
                    }
                    if (originalValue is ValueType && !(originalValue is Guid))
                    {
                        //check value of non reference type
                        Assert.That(originalValue.Equals(copyValue));
                    }
                }
            }
        }
    }

मुझे यूनिट परीक्षण लिखना पसंद है जो मूल और क्लोन ऑब्जेक्ट पर निर्मित सीरियलइज़र का उपयोग करता है और फिर समानता के लिए सीरियलकृत प्रस्तुतीकरण (एक बाइनरी फॉर्मेटर के लिए, मैं सिर्फ बाइट सरणियों की तुलना कर सकता हूँ) की जांच करता हूं। यह उन मामलों में महान काम करता है जहां ऑब्जेक्ट अभी भी सीरियलज योग्य है, और मैं केवल perf कारणों के लिए कस्टम गहरे क्लोन में बदल रहा हूं I

इसके अलावा, मैं इस तरह से कुछ का उपयोग करके अपने सभी क्लोन कार्यान्वयनों में डीबग मोड चेक जोड़ना चाहता हूं

[Conditional("DEBUG")]
public static void DebugAssertValueEquality<T>(T current, T other, bool expected, 
                                               params string[] ignoredFields) {
    if (null == current) 
    { throw new ArgumentNullException("current"); }
    if (null == ignoredFields)
    { ignoredFields = new string[] { }; }

    FieldInfo lastField = null;
    bool test;
    if (object.ReferenceEquals(other, null))
    { Debug.Assert(false == expected, "The other object was null"); return; }
    test = true;
    foreach (FieldInfo fi in current.GetType().GetFields(BindingFlags.Instance)) {
        if (test = false) { break; }
        if (0 <= Array.IndexOf<string>(ignoredFields, fi.Name))
        { continue; }
        lastField = fi;
        object leftValue = fi.GetValue(current);
        object rightValue = fi.GetValue(other);
        if (object.ReferenceEquals(null, leftValue)) {
            if (!object.ReferenceEquals(null, rightValue))
            { test = false; }
        }
        else if (object.ReferenceEquals(null, rightValue))
        { test = false; }
        else {
            if (!leftValue.Equals(rightValue))
            { test = false; }
        }
    }
    Debug.Assert(test == expected, string.Format("field: {0}", lastField));
}

यह विधि किसी भी नेस्टेड सदस्यों के बराबर के सटीक क्रियान्वयन पर निर्भर करती है, लेकिन मेरे मामले में जो भी क्लोन करने योग्य है वह भी समान है


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

अपने विशिष्ट सवालों का जवाब देने के लिए:

क्या आप क्लास के लिए अपने सभी यूनिट टेस्ट लिखते हैं (या फिर आप को क्लोन की आवश्यकता की खोज करने के बाद दोबारा लिखना) ताकि उन्हें 'कुंवारी' ऑब्जेक्ट या उसके क्लोन से जोड़ा जा सके?

आपके पास सभी तरीकों के लिए परीक्षण होना चाहिए जो मूल और क्लोन दोनों वस्तुओं पर किया जा सकता है। ध्यान दें कि प्रत्येक टेस्ट के लिए मैन्युअल रूप से तर्क को अद्यतन करने के बिना इसका समर्थन करने के लिए सरल परीक्षण डिज़ाइन सेट करना बहुत आसान होना चाहिए।

क्लोनिंग का हिस्सा गहरा पर्याप्त नहीं था, तो आप कैसे परीक्षण करेंगे - क्योंकि यह केवल ऐसी समस्या है जो बाद में घृणित-से-ढूँढें बग्स दे सकती है?

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





unit-testing