c# इकाई परीक्षण के लिए एक निजी विधि सार्वजनिक बनाना... अच्छा विचार?




java unit-testing (24)

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

इसे ध्यान में रखते हुए मैं आपको परीक्षण पर ध्यान केंद्रित करने का सुझाव देता हूं कि आपका अनुबंध अभी भी कोई फर्क नहीं पड़ता कि आपकी कक्षा में वर्तमान में आंतरिक कार्यान्वयन क्या है। आपके सार्वजनिक एपीआई की संपत्ति आधारित परीक्षण।

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

मुझे कभी-कभी खुद को कक्षा के लोगों में एक निजी विधि बनाने की आवश्यकता होती है ताकि वह इसके लिए कुछ यूनिट परीक्षण लिख सके।

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

क्या अन्य लोग खुद ऐसा कर पाते हैं, क्योंकि मुझे वास्तव में ऐसा करना पसंद नहीं है ?? मैं व्यक्तिगत रूप से सोचता हूं कि बोनस एक विधि बनाने की समस्याओं से अधिक है जो वास्तव में कक्षा के बाहर कोई सेवा प्रदान नहीं करता है ...

अद्यतन करें

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

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


बहुत सारे उत्तरों केवल सार्वजनिक इंटरफ़ेस का परीक्षण करने का सुझाव देते हैं, लेकिन आईएमएचओ यह अवास्तविक है - यदि कोई विधि कुछ कदम उठाती है, तो आप उन पांच चरणों को अलग-अलग परीक्षण करना चाहेंगे, सभी एक साथ नहीं। इसके लिए सभी पांच विधियों का परीक्षण करने की आवश्यकता है, जो (परीक्षण के अलावा) अन्यथा private हो सकते हैं।

"निजी" विधियों का परीक्षण करने का सामान्य तरीका प्रत्येक वर्ग को अपना इंटरफ़ेस देना है, और "निजी" विधियों को public , लेकिन उन्हें इंटरफ़ेस में शामिल नहीं करना है। इस तरह, वे अभी भी परीक्षण किया जा सकता है, लेकिन वे इंटरफ़ेस bloat नहीं है।

हां, इसका परिणाम फाइल- और क्लास-ब्लोट में होगा।

हां, यह public और private विनिर्देशियों को अनावश्यक बनाता है।

हाँ, यह गधे में दर्द है।

दुर्भाग्यवश, कोड टेस्ट करने योग्य बनाने के लिए हम कई बलिदानों में से एक है । शायद भविष्य की भाषा (या सी # / जावा के भविष्य के संस्करण में) कक्षाओं और मॉड्यूल-टेस्टेबिलिटी को और सुविधाजनक बनाने के लिए सुविधाएं होंगी; लेकिन इस बीच, हमें इन हुप्स के माध्यम से कूदना है।

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


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

इसके बजाय आपको "उच्च परीक्षण" करना चाहिए। उस विधि का परीक्षण करें जो निजी विधि को कॉल करता है। लेकिन आपके परीक्षणों को आपके अनुप्रयोगों की जरूरतों का परीक्षण करना चाहिए, न कि आपके "कार्यान्वयन निर्णयों"।

उदाहरण के लिए (यहां बोड छद्म कोड);

   public int books(int a) {
     return add(a, 2);
   }
   private int add(int a, int b) {
     return a+b;
   } 

"Add" का परीक्षण करने का कोई कारण नहीं है, इसके बजाय आप "पुस्तकें" का परीक्षण कर सकते हैं।

अपने परीक्षणों को कभी भी आपके लिए कोड डिज़ाइन निर्णय लेने दें। परीक्षण करें कि आपको अपेक्षित परिणाम मिलते हैं, न कि आपको यह परिणाम कैसे मिलता है।


मैं इस बात से सहमत हूं कि यूनिट होने का बोनस कुछ सदस्यों की दृश्यता बढ़ाने की समस्याओं से अधिक है। थोड़ा सुधार यह संरक्षित और वर्चुअल बनाने के लिए है, फिर इसे बेनकाब करने के लिए इसे टेस्ट क्लास में ओवरराइड करें।

वैकल्पिक रूप से, यदि यह कार्यक्षमता है तो आप अलग से परीक्षण करना चाहते हैं, क्या यह आपके डिज़ाइन से गुम वस्तु का सुझाव नहीं देता है? हो सकता है कि आप इसे एक अलग टेस्टेबल क्लास में डाल सकें ... तो आपकी मौजूदा कक्षा सिर्फ इस नई कक्षा के उदाहरण के लिए प्रतिनिधि है।


एक उपयोगिता वर्ग में स्टैक प्रबंधन एल्गोरिदम क्यों विभाजित नहीं करें? उपयोगिता वर्ग ढेर का प्रबंधन कर सकते हैं और सार्वजनिक एक्सेसर्स प्रदान कर सकते हैं। इसके यूनिट परीक्षण कार्यान्वयन विस्तार पर केंद्रित किया जा सकता है। एल्गोरिदमिक रूप से मुश्किल वर्गों के लिए गहरे परीक्षण किनारे के मामलों को झुर्रियों और कवरेज सुनिश्चित करने में बहुत उपयोगी हैं।

फिर आपकी वर्तमान कक्षा किसी कार्यान्वयन विवरण को उजागर किए बिना उपयोगिता वर्ग में स्पष्ट रूप से प्रतिनिधि हो सकती है। इसके परीक्षण पेजिंग की आवश्यकता से संबंधित होंगे क्योंकि अन्य ने सिफारिश की है।


अलगाव में परीक्षण करने के लिए निजी विधियां एक संकेत हैं कि आपकी कक्षा में एक और "अवधारणा" दफन है। अपनी अवधारणा को "अवधारणा" निकालें और इसे एक अलग "इकाई" के रूप में जांचें।

विषय पर वास्तव में दिलचस्प लेने के लिए इस वीडियो पर एक नज़र डालें।


I usually leave those methods as protected and place the unit test within the same package (but in another project or source folder), where they can access all the protected methods because the class loader will place them within the same namespace.


अद्यतन : मैंने कई अन्य स्थानों पर इस प्रश्न के लिए एक और विस्तारित और अधिक पूर्ण उत्तर जोड़ा है। यह मेरे ब्लॉग पर पाया जा सकता है

अगर मुझे कभी भी इसका परीक्षण करने के लिए कुछ सार्वजनिक करने की ज़रूरत है, तो यह आमतौर पर संकेत देता है कि परीक्षण के तहत प्रणाली एकल अनुपालन सिद्धांत का पालन ​​नहीं कर रही है। इसलिए एक लापता वर्ग है जिसे पेश किया जाना चाहिए। कोड को एक नई कक्षा में निकालने के बाद, इसे सार्वजनिक बनाएं। अब आप आसानी से परीक्षण कर सकते हैं, और आप एसआरपी का पालन कर रहे हैं। आपकी अन्य कक्षा को बस रचना के माध्यम से इस नई कक्षा को आमंत्रित करना है।

विधियों को सार्वजनिक / लैंगेज चालों का उपयोग करना जैसे कि कोड को असेंबली के लिए दृश्यमान कोड के रूप में चिह्नित करना हमेशा एक अंतिम उपाय होना चाहिए।

उदाहरण के लिए:

public class SystemUnderTest
{
   public void DoStuff()
   {
      // Blah
      // Call Validate()
   }

   private void Validate()
   {
      // Several lines of complex code...
   }
}

एक वैधकर्ता वस्तु शुरू करके इसे दोबारा दोहराएं।

public class SystemUnderTest
{
    public void DoStuff()
    {
       // Blah
       validator.Invoke(..)
    }
}

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


नहीं, क्योंकि उस बिल्ली को स्किन करने के बेहतर तरीके हैं।

कुछ इकाई परीक्षण harnesses वर्ग परिभाषा में मैक्रोज़ पर भरोसा करते हैं जो स्वचालित रूप से परीक्षण मोड में बनाया गया है जब हुक बनाने के लिए विस्तार। बहुत सी शैली, लेकिन यह काम करता है।

एक आसान ओओ मुहावरे कुछ भी बनाना है जिसे आप "निजी" के बजाय "संरक्षित" परीक्षण करना चाहते हैं। टेस्ट दोहन परीक्षण के तहत कक्षा से विरासत में मिलता है, और फिर सभी संरक्षित सदस्यों तक पहुंच सकता है।

या आप "दोस्त" विकल्प के लिए जाते हैं। व्यक्तिगत रूप से यह सी ++ की विशेषता है जो कम से कम है क्योंकि यह encapsulation नियमों को तोड़ता है, लेकिन सी ++ कुछ सुविधाओं को लागू करने के लिए यह आवश्यक होता है, तो हे हो।

वैसे भी, यदि आप यूनिट परीक्षण कर रहे हैं तो आपको उन सदस्यों में मूल्यों को इंजेक्ट करने की आवश्यकता है। व्हाइट बॉक्स टेक्स्टिंग पूरी तरह मान्य है। और वह वास्तव में आपके encapsulation तोड़ देगा


In .Net there is a special class called PrivateObject deigned specifically to allow you to access private methods of a class.

See more about it on the MSDN or here on

(I am wondering that no one has mentioned it so far.)

There are situations though which this is not enough, in which case you will have to use reflection.

Still I would adhere to the general recommendation not to test private methods, however as usual there are always exceptions.


निजी तौर पर, निजी तरीकों का परीक्षण करते समय मुझे वही समस्याएं होती हैं और ऐसा इसलिए होता है क्योंकि कुछ परीक्षण उपकरण सीमित हैं। सीमित डिज़ाइन द्वारा आपके डिज़ाइन को संचालित करना अच्छा नहीं है यदि वे आपकी ज़रूरत का जवाब नहीं देते हैं तो उपकरण को डिज़ाइन नहीं बदलते हैं। चूंकि आप सी # के लिए पूछ रहे हैं, मैं अच्छे परीक्षण उपकरण का प्रस्ताव नहीं दे सकता, लेकिन जावा के लिए दो शक्तिशाली उपकरण हैं: टेस्टएनजी और पावरमैक, और आप .NET प्लेटफ़ॉर्म के लिए संबंधित परीक्षण टूल ढूंढ सकते हैं


ध्यान दें:
यह उत्तर मूल रूप से प्रश्न के लिए पोस्ट किया गया था क्या यूनिट परीक्षण अकेले गेटर्स के माध्यम से निजी आवृत्ति चर का पर्दाफाश करने का एक अच्छा कारण है? जिसे इस में विलय कर दिया गया था, इसलिए यह वहां प्रस्तुत किए गए उपयोगकेस के लिए एक विशिष्ट विशिष्ट हो सकता है।

एक सामान्य बयान के रूप में, मैं आम तौर पर परीक्षण के लिए आसान बनाने के लिए "उत्पादन" कोड को पुन: सक्रिय करने के लिए हूं। हालांकि, मुझे नहीं लगता कि यह एक अच्छी कॉल होगी। एक अच्छी इकाई परीक्षण (आमतौर पर) कक्षा के कार्यान्वयन विवरण, केवल इसके दृश्य व्यवहार के बारे में परवाह नहीं करना चाहिए। परीक्षण में आंतरिक ढेर को उजागर करने के बजाय, आप परीक्षण कर सकते हैं कि कक्षा पृष्ठ को पहले क्रम first() या last() कॉल करने के बाद आपके द्वारा अपेक्षित क्रम में लौटाती है।

उदाहरण के लिए, इस छद्म कोड पर विचार करें:

public class NavigationTest {
    private Navigation nav;

    @Before
    public void setUp() {
        // Set up nav so the order is page1->page2->page3 and
        // we've moved back to page2
        nav = ...;
    }

    @Test
    public void testFirst() {
        nav.first();

        assertEquals("page1", nav.getPage());

        nav.next();
        assertEquals("page2", nav.getPage());

        nav.next();
        assertEquals("page3", nav.getPage());
    }

    @Test
    public void testLast() {
        nav.last();

        assertEquals("page3", nav.getPage());

        nav.previous();
        assertEquals("page2", nav.getPage());

        nav.previous();
        assertEquals("page1", nav.getPage());
    }
}

As is extensively noted by others' comments, unit tests should focus on the public API. However, pros/cons and justification aside, you can call private methods in a unit test by using reflection. You would of course need to make sure your JRE security allows it. Calling private methods is something that the Spring Framework employs with it's ReflectionUtils (see the makeAccessible(Method) method).

Here's a small example class with a private instance method.

public class A {
    private void doSomething() {
        System.out.println("Doing something private.");
    }
}

And an example class that executes the private instance method.

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class B {
    public static final void main(final String[] args) {
        try {
            Method doSomething = A.class.getDeclaredMethod("doSomething");
            A o = new A();
            //o.doSomething(); // Compile-time error!
            doSomething.setAccessible(true); // If this is not done, you get an IllegalAccessException!
            doSomething.invoke(o);
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (SecurityException e) {
            e.printStackTrace();
        }
    }
}

Executing B, will print Doing something private. If you really need it, reflection could be used in unit tests to access private instance methods.


मैं अक्सर एक वर्ग को validate , verify , check , इत्यादि जैसी कुछ विधि जोड़ता हूं ताकि इसे किसी ऑब्जेक्ट की आंतरिक स्थिति का परीक्षण करने के लिए बुलाया जा सके।

कभी-कभी यह विधि एक ifdef ब्लॉक में लपेटा जाता है (मैं ज्यादातर सी ++ में लिखता हूं) ताकि इसे रिलीज़ के लिए संकलित नहीं किया जा सके। लेकिन अक्सर रिलीज में उपयोगी होता है ताकि प्रमाणीकरण विधियां प्रदान की जा सकें जो प्रोग्राम की ऑब्जेक्ट पेड़ को चीजों की जांच कर लेती हैं।


मैं आम तौर पर परीक्षा के तहत कक्षाओं के रूप में एक ही परियोजना / असेंबली में परीक्षण कक्षाएं रखता हूं।
इस तरह मुझे कार्यों / कक्षाओं को टेस्ट करने योग्य बनाने के लिए केवल internal दृश्यता की आवश्यकता होती है।

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

यह निश्चित रूप से केवल आपके प्रश्न के सी # / .NET भाग पर लागू होता है


सबसे पहले देखें कि विधि को किसी अन्य वर्ग में निकाला जाना चाहिए और सार्वजनिक किया जाना चाहिए। यदि ऐसा नहीं है, तो इसे पैकेज सुरक्षित और जावा एनोटेट में @VisibleForTesting साथ @VisibleForTesting


जैसा कि अन्य ने कहा है, यह कुछ हद तक यूनिट परीक्षण निजी तरीकों का संदेह है; यूनिट सार्वजनिक इंटरफेस का परीक्षण, निजी कार्यान्वयन विवरण नहीं।

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


इकाई परीक्षण के मामले में, आपको निश्चित रूप से और विधियां नहीं जोड़नी चाहिए; मेरा मानना ​​है कि आप अपने first() विधि के बारे में एक टेस्ट केस बेहतर तरीके से करेंगे, जिसे प्रत्येक टेस्ट से पहले बुलाया जाएगा; तो आप यह देखने के लिए कि क्या परिणाम आपकी अपेक्षा से मेल खाते हैं, कई बार - next() , previous() और last() कॉल कर सकते हैं। मुझे लगता है कि यदि आप अपनी कक्षा में केवल अधिक तरीकों को नहीं जोड़ते हैं (केवल परीक्षण उद्देश्यों के लिए), तो आप परीक्षण के "ब्लैक बॉक्स" सिद्धांत से चिपके रहेंगे;


निजी विधियों को आमतौर पर "सहायक" विधियों के रूप में उपयोग किया जाता है। इसलिए वे केवल बुनियादी मूल्यों को वापस करते हैं और वस्तुओं के विशिष्ट उदाहरणों पर कभी काम नहीं करते हैं।

यदि आप उनका परीक्षण करना चाहते हैं तो आपके पास कुछ विकल्प हैं।

  • प्रतिबिंब का प्रयोग करें
  • विधियों के पैकेज की अनुमति दें

वैकल्पिक रूप से आप एक सार्वजनिक विधि के रूप में सहायक विधि के साथ एक नई कक्षा बना सकते हैं यदि यह एक नई कक्षा के लिए पर्याप्त पर्याप्त उम्मीदवार है।

इस पर एक बहुत अच्छा लेख है


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

  1. ब्लैक बॉक्स परीक्षण

    ब्लैक बॉक्स स्कूल का कहना है कि कक्षा को ब्लैक बॉक्स के रूप में माना जाना चाहिए कि कोई भी इसके अंदर कार्यान्वयन नहीं देख सकता है। इसका परीक्षण करने का एकमात्र तरीका सार्वजनिक एपीआई के माध्यम से है - बस उपयोगकर्ता के वर्ग की तरह इसका उपयोग किया जाएगा।

  2. सफेद बॉक्स परीक्षण।

    श्वेत बॉक्स स्कूल कक्षा के कार्यान्वयन के बारे में ज्ञान का उपयोग करने के लिए स्वाभाविक रूप से सोचता है और फिर वर्ग को यह जानने के लिए परीक्षण करता है कि यह काम करता है जैसा कि यह करना चाहिए।

मैं वास्तव में चर्चा में पक्ष नहीं ले सकता। मैंने सोचा कि यह जानना दिलचस्प होगा कि कक्षा (या पुस्तकालय या जो भी) का परीक्षण करने के दो अलग-अलग तरीके हैं।


इसे पैकेज निजी बनाने के बारे में कैसे? फिर आपका टेस्ट कोड इसे देख सकता है (और आपके पैकेज में अन्य वर्ग भी), लेकिन यह अभी भी आपके उपयोगकर्ताओं से छिपा हुआ है।

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

एक विधि सार्वजनिक बनाना बड़ी प्रतिबद्धता है। एक बार ऐसा करने के बाद, लोग इसका उपयोग करने में सक्षम होंगे, और आप उन्हें अभी और नहीं बदल सकते हैं।


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


यदि आप सी # का उपयोग कर रहे हैं तो आप विधि को आंतरिक बना सकते हैं। इस तरह आप सार्वजनिक एपीआई को प्रदूषित नहीं करते हैं।

फिर डीएलएल में विशेषता जोड़ें

[असेंबली: InternalsVisibleTo ("MyTestAssembly")]

अब आपके MyTestAssembly प्रोजेक्ट में सभी विधियां दिखाई दे रही हैं। शायद सही नहीं है, लेकिन बेहतर है कि निजी विधि को सिर्फ परीक्षण करने के लिए सार्वजनिक करें।


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





unit-testing