127

बंद हो गया । इस प्रश्न पर अधिक ध्यान देने की आवश्यकता है । यह वर्तमान में उत्तर स्वीकार नहीं कर रहा है।

इस प्रश्न को सुधारना चाहते हैं? प्रश्न को अपडेट करें ताकि यह इस पोस्ट को संपादित करके केवल एक समस्या पर केंद्रित हो ।

4 साल पहले बंद हुआ ।

इस प्रश्न को सुधारें

C # का उपयोग करते हुए, मुझे एक वर्ग की आवश्यकता होती है जिसे Userएक उपयोगकर्ता नाम, पासवर्ड, सक्रिय ध्वज, पहला नाम, अंतिम नाम, पूरा नाम, इत्यादि कहते हैं।

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

c# unit-testing tdd

— नबर
स्रोत

यह पोस्ट व्यापक प्रश्न को सीमित करने में मदद करेगी: earnestengineer.blogspot.com/2018/03/… आप अपने प्रश्न पर ध्यान केंद्रित करने के लिए इन दिशानिर्देशों को ले सकते हैं

— लिंडसे मोर्सिलो

ध्यान रखें कि पासवर्ड को प्लेनटेक्स्ट के रूप में संग्रहीत नहीं किया जाना चाहिए।

— श्री एंडरसन

131

इस पर कई शानदार प्रतिक्रियाएं मेरे सवाल पर भी हैं: " शुरुआत टीडीडी - चुनौतियां? समाधान? सिफारिशें? "

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

मुझे नहीं पता कहाँ से शुरू करें?

नई शुरुआत करें। जब आप नया कोड लिख रहे हों तो केवल परीक्षण लिखने के बारे में सोचें। यह पुराने कोड, या एक पूरी तरह से नई सुविधा का फिर से काम कर सकता है।

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

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

एक चुनौती के लिए तैयार रहें। परीक्षण में शुरू करना काफी कठिन है। एक चुनौती की अपेक्षा करें, लेकिन याद रखें - चुनौतियों को दूर किया जा सकता है।

आप क्या अपेक्षा के लिए केवल टेस्ट

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

केवल टेस्ट एक बात

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

मुझे उम्मीद है कि इसका मतलब है कि हम "गेटर्स एंड सेवर्स" से आगे बढ़ सकते हैं :)

— रोब कूपर का पता चलता है
स्रोत

2

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

— Corin Blaikie

3

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

— रोब कूपर

4

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

— श्वेर्न ऑक्ट

63

अपने कोड का परीक्षण करें, न कि भाषा का।

एक यूनिट टेस्ट जैसे:

Integer i = new Integer(7);
assert (i.instanceOf(integer));

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

सामान का परीक्षण न करें जिसे आप लागू करने के लिए भाषा पर भरोसा कर सकते हैं। आपके मामले में, मैं आपके प्रमाणीकृत और सहेजने के तरीकों पर ध्यान केंद्रित करूँगा - और मैं ऐसे परीक्षण लिखूंगा, जिनसे यह सुनिश्चित हो सके कि वे किसी भी या उन सभी क्षेत्रों में अशक्त भावों को इनायत से संभाल सकते हैं।

— टिम हावलैंड
स्रोत

1

"डॉन्ट टेस्ट द फ्रेमवर्क" पर अच्छा बिंदु - कुछ ऐसा जो मुझे इस पर नया लगा। + 1'द :)

— रोब कूपर

38

यह मुझे इकाई परीक्षण में मिला और इसने मुझे बहुत खुश किया

हमने सिर्फ यूनिट टेस्टिंग करना शुरू किया। लंबे समय से मुझे पता था कि इसे करना शुरू करना अच्छा होगा लेकिन मुझे नहीं पता था कि कैसे शुरू किया जाए और अधिक महत्वपूर्ण बात यह है कि क्या परीक्षण करना है।

फिर हमें अपने लेखांकन कार्यक्रम में एक महत्वपूर्ण कोड को फिर से लिखना पड़ा। यह हिस्सा बहुत जटिल था क्योंकि इसमें बहुत सारे परिदृश्य शामिल थे। मैं जिस हिस्से के बारे में बात कर रहा हूं वह बिक्री और / या खरीद का भुगतान करने की एक विधि है जो पहले से ही लेखा प्रणाली में दर्ज की गई है।

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

इसलिए मुझे कई संभावनाओं के साथ हल करने के लिए एक बहुत ही जटिल समस्या थी कि एक परिदृश्य पूरी तरह से काम करेगा लेकिन एक अन्य प्रकार के चालान / भुगतान संयोजन पर गलत होगा।

यह वह जगह है जहाँ इकाई परीक्षण बचाव के लिए आया था।

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

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

परीक्षण के बाद, मैं डेटाबेस में जाऊँगा और अगर मुझे उम्मीद थी कि दोबारा जाँच करेगा।

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

मैंने पहला टेस्ट चलाया, एक छोटा बग तय किया जब तक कि मेरा टेस्ट पास नहीं हो जाता।

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

भुगतान छूट के साथ शुद्धता के लिए परीक्षण करते समय, मैंने सरल भुगतान का भी परीक्षण किया। दोनों परीक्षणों को निश्चित रूप से पास होना चाहिए।

तब मैंने अधिक जटिल परिदृश्यों के लिए अपने तरीके से काम किया।

1) एक नए परिदृश्य के बारे में सोचो

2) उस परिदृश्य के लिए एक परीक्षण लिखें

3) यह देखने के लिए कि क्या यह पास होगा, उस एकल परीक्षा को चलाएं

4) अगर यह डिबग नहीं करता और कोड को संशोधित करता, जब तक कि यह पास नहीं हो जाता।

5) कोड को संशोधित करते समय मैं सभी परीक्षण चलाता रहा

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

मुझे यकीन है कि यूनिट परीक्षण का उपयोग करने से मुझे कोडिंग के कुछ दिनों (या सप्ताह) की बचत हुई है और यह मेरी पद्धति की शुद्धता की गारंटी देता है।

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

हां, यहां तक कि परीक्षण किए गए कोड में अभी भी कीड़े हो सकते हैं यदि कोई उपयोगकर्ता उन चीजों को करता है जो आपने नहीं सोचा था या उसे करने से रोका था

नीचे मेरी भुगतान पद्धति का परीक्षण करने के लिए बनाए गए कुछ परीक्षण हैं।

public class TestPayments
{
    InvoiceDiaryHeader invoiceHeader = null;
    InvoiceDiaryDetail invoiceDetail = null;
    BankCashDiaryHeader bankHeader = null;
    BankCashDiaryDetail bankDetail = null;



    public InvoiceDiaryHeader CreateSales(string amountIncVat, bool sales, int invoiceNumber, string date)
    {
        ......
        ......
    }

    public BankCashDiaryHeader CreateMultiplePayments(IList<InvoiceDiaryHeader> invoices, int headerNumber, decimal amount, decimal discount)
    {
       ......
       ......
       ......
    }


    [TestMethod]
    public void TestSingleSalesPaymentNoDiscount()
    {
        IList<InvoiceDiaryHeader> list = new List<InvoiceDiaryHeader>();
        list.Add(CreateSales("119", true, 1, "01-09-2008"));
        bankHeader = CreateMultiplePayments(list, 1, 119.00M, 0);
        bankHeader.Save();

        Assert.AreEqual(1, bankHeader.BankCashDetails.Count);
        Assert.AreEqual(1, bankHeader.BankCashDetails[0].Payments.Count);
        Assert.AreEqual(119M, bankHeader.BankCashDetails[0].Payments[0].PaymentAmount);
        Assert.AreEqual(0M, bankHeader.BankCashDetails[0].Payments[0].PaymentDiscount);
        Assert.AreEqual(0, bankHeader.BankCashDetails[0].Payments[0].InvoiceHeader.Balance);
    }

    [TestMethod]
    public void TestSingleSalesPaymentDiscount()
    {
        IList<InvoiceDiaryHeader> list = new List<InvoiceDiaryHeader>();
        list.Add(CreateSales("119", true, 2, "01-09-2008"));
        bankHeader = CreateMultiplePayments(list, 2, 118.00M, 1M);
        bankHeader.Save();

        Assert.AreEqual(1, bankHeader.BankCashDetails.Count);
        Assert.AreEqual(1, bankHeader.BankCashDetails[0].Payments.Count);
        Assert.AreEqual(118M, bankHeader.BankCashDetails[0].Payments[0].PaymentAmount);
        Assert.AreEqual(1M, bankHeader.BankCashDetails[0].Payments[0].PaymentDiscount);
        Assert.AreEqual(0, bankHeader.BankCashDetails[0].Payments[0].InvoiceHeader.Balance);
    }

    [TestMethod]
    [ExpectedException(typeof(ApplicationException))]
    public void TestDuplicateInvoiceNumber()
    {
        IList<InvoiceDiaryHeader> list = new List<InvoiceDiaryHeader>();
        list.Add(CreateSales("100", true, 2, "01-09-2008"));
        list.Add(CreateSales("200", true, 2, "01-09-2008"));

        bankHeader = CreateMultiplePayments(list, 3, 300, 0);
        bankHeader.Save();
        Assert.Fail("expected an ApplicationException");
    }

    [TestMethod]
    public void TestMultipleSalesPaymentWithPaymentDiscount()
    {
        IList<InvoiceDiaryHeader> list = new List<InvoiceDiaryHeader>();
        list.Add(CreateSales("119", true, 11, "01-09-2008"));
        list.Add(CreateSales("400", true, 12, "02-09-2008"));
        list.Add(CreateSales("600", true, 13, "03-09-2008"));
        list.Add(CreateSales("25,40", true, 14, "04-09-2008"));

        bankHeader = CreateMultiplePayments(list, 5, 1144.00M, 0.40M);
        bankHeader.Save();

        Assert.AreEqual(1, bankHeader.BankCashDetails.Count);
        Assert.AreEqual(4, bankHeader.BankCashDetails[0].Payments.Count);
        Assert.AreEqual(118.60M, bankHeader.BankCashDetails[0].Payments[0].PaymentAmount);
        Assert.AreEqual(400, bankHeader.BankCashDetails[0].Payments[1].PaymentAmount);
        Assert.AreEqual(600, bankHeader.BankCashDetails[0].Payments[2].PaymentAmount);
        Assert.AreEqual(25.40M, bankHeader.BankCashDetails[0].Payments[3].PaymentAmount);

        Assert.AreEqual(0.40M, bankHeader.BankCashDetails[0].Payments[0].PaymentDiscount);
        Assert.AreEqual(0, bankHeader.BankCashDetails[0].Payments[1].PaymentDiscount);
        Assert.AreEqual(0, bankHeader.BankCashDetails[0].Payments[2].PaymentDiscount);
        Assert.AreEqual(0, bankHeader.BankCashDetails[0].Payments[3].PaymentDiscount);

        Assert.AreEqual(0, bankHeader.BankCashDetails[0].Payments[0].InvoiceHeader.Balance);
        Assert.AreEqual(0, bankHeader.BankCashDetails[0].Payments[1].InvoiceHeader.Balance);
        Assert.AreEqual(0, bankHeader.BankCashDetails[0].Payments[2].InvoiceHeader.Balance);
        Assert.AreEqual(0, bankHeader.BankCashDetails[0].Payments[3].InvoiceHeader.Balance);
    }

    [TestMethod]
    public void TestSettlement()
    {
        IList<InvoiceDiaryHeader> list = new List<InvoiceDiaryHeader>();
        list.Add(CreateSales("300", true, 43, "01-09-2008")); //Sales
        list.Add(CreateSales("100", false, 6453, "02-09-2008")); //Purchase

        bankHeader = CreateMultiplePayments(list, 22, 200, 0);
        bankHeader.Save();

        Assert.AreEqual(1, bankHeader.BankCashDetails.Count);
        Assert.AreEqual(2, bankHeader.BankCashDetails[0].Payments.Count);
        Assert.AreEqual(300, bankHeader.BankCashDetails[0].Payments[0].PaymentAmount);
        Assert.AreEqual(-100, bankHeader.BankCashDetails[0].Payments[1].PaymentAmount);
        Assert.AreEqual(0, bankHeader.BankCashDetails[0].Payments[0].InvoiceHeader.Balance);
        Assert.AreEqual(0, bankHeader.BankCashDetails[0].Payments[1].InvoiceHeader.Balance);
    }

— इरोजेन
स्रोत

1

आपकी इकाई परीक्षण में एक बग मिला! आप उनमें से एक में 2 को शामिल करने के बजाय इस पंक्ति को दोहराते हैं:Assert.AreEqual(0, bankHeader.BankCashDetails[0].Payments[3].InvoiceHeader.Balance);

— रयान पेस्केल

2

आप कहते हैं: "परीक्षण के बाद मैं डेटाबेस में जाऊँगा और अगर मुझे उम्मीद थी कि दोबारा जाँच करेगा।" यह आपके सिस्टम के घटकों के बीच एकीकरण परीक्षण का एक अच्छा उदाहरण है - कोड के एक टुकड़े का एक पृथक इकाई परीक्षण नहीं।

— जेट

2

आपने प्रति परीक्षण एक से अधिक एस्टर का नियम भी तोड़ा।

— स्टीव

13

यदि वे वास्तव में तुच्छ हैं, तो परीक्षण को परेशान न करें। जैसे, अगर उन्हें इस तरह से लागू किया जाता है;

public class User
{
    public string Username { get; set; }
    public string Password { get; set; }
}

यदि, दूसरी ओर, आप कुछ चालाक काम कर रहे हैं, (जैसे कि गेटर / सेटर में पासवर्ड एन्क्रिप्ट और डिक्रिप्ट करना) तो इसे टेस्ट दें।

— स्टीव कूपर
स्रोत

10

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

— Slavo
स्रोत

6

यह प्रश्न प्रतीत होता है कि कोई व्यक्ति उन तरीकों पर लाइन खींचता है जो परीक्षण किए जाते हैं और जो नहीं करते हैं।

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

विशेष रूप से अतिरिक्त कार्यक्षमता जोड़ने के लिए परिवर्तन के दौर से गुजरते समय कोड विश्वसनीयता, प्राथमिक लक्ष्य है। मैं किसी को भी पता नहीं है कि परीक्षण पद्धति में बसने वाले / पाने वालों को निकाल दिया गया है, लेकिन मैं निश्चित हूं कि ऐसे लोग मौजूद हैं जो चाहते थे कि उनके पास परीक्षण के तरीके थे जो अंतिम रूप से वे जानते थे या याद कर सकते थे कि वे सरल सेट / रैपर थे लेकिन वह नहीं था अब मामला है।

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

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

मेरी राय है कि यूनिट परीक्षणों के साथ सभी तरीकों को कवर करते हुए "व्यर्थ" समय के कुछ मिनट, यहां तक कि तुच्छ लोग, सड़क के नीचे सिरदर्द के दिनों और पैसे की हानि / व्यवसाय की प्रतिष्ठा और किसी की नौकरी के नुकसान से बचा सकते हैं।

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

जिस तरह से हम कोड करते हैं, और जो अनुशासन हमारे कोड से देखा जा सकता है, वह दूसरों की मदद कर सकता है।

— थॉमस कार्लिस्ले
स्रोत

4

एक और विहित जवाब। मेरा मानना है कि रॉन जेफ्रीज़ से:

केवल उस कोड का परीक्षण करें जिसे आप काम करना चाहते हैं।

— एलआईएम
स्रोत

3

बॉयलरप्लेट कोड का परीक्षण करना समय की बर्बादी है, लेकिन जैसा कि स्लाव कहते हैं, यदि आप अपने गेटर्स / सेटर्स में साइड इफेक्ट जोड़ते हैं, तो आपको उस कार्यक्षमता के साथ एक परीक्षण लिखना चाहिए।

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

— warren_s
स्रोत

3

गेटर्स और सेटर जैसे वास्तव में तुच्छ कोड जो कि एक निजी क्षेत्र को सेट करने की तुलना में कोई अतिरिक्त व्यवहार नहीं है परीक्षण के लिए ओवरकिल है। 3.0 C # में कुछ संश्लिष्ट शर्करा भी है जहाँ संकलक निजी क्षेत्र का ध्यान रखता है ताकि आपको वह प्रोग्राम न करना पड़े।

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

— Mendelt
स्रोत

खुशी है कि तुम .. KISS सिद्धांत का एक अच्छा मुद्दा बनाया मैं अक्सर परीक्षण है कि सचमुच कोड के 2-3 लाइनों, असली छोटे, साधारण परीक्षण की तरह हैं। आसान और कठिन को तोड़ने के लिए :) + 1'ed

— रोब कूपर

3

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

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

— Sklivvz
स्रोत

3

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

— ज़ेप्लिन
स्रोत

2

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

— बॉब किंग
स्रोत

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

— पॉप कैटालिन

2

उनका कहना है कि तर्क को बाद में उनके साथ जोड़ा जा सकता है।

— लीजेंडल्रिक्स

2

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

विरासत पदानुक्रम में, एलएसपी के लिए परीक्षण करना सुनिश्चित करें अनुपालन के ।

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

— रिक
स्रोत

2

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

— pmlarocque
स्रोत

2

विहित उत्तर "कुछ भी परीक्षण करें जो संभवतः टूट सकता है।" यदि आप सुनिश्चित हैं कि गुण नहीं टूटेंगे, तो उनका परीक्षण न करें।

और एक बार कुछ टूटा हुआ पाया जाता है (आप एक बग ढूंढते हैं), जाहिर है इसका मतलब है कि आपको इसे परीक्षण करने की आवश्यकता है। बग को पुन: उत्पन्न करने के लिए एक परीक्षण लिखें, इसे विफल देखें, फिर बग को ठीक करें, फिर परीक्षण पास देखें।

— एरिक नॉर्मैंड
स्रोत

1

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

— ओनोरियो कैटेनिक
स्रोत

1

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

— टॉम वॉकर
स्रोत

1

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

— पीटर बर्नियर
स्रोत

1

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

व्यक्तिगत रूप से मैं Moq का उपयोग एक मॉक ऑब्जेक्ट फ्रेमवर्क के रूप में करता हूं और फिर सत्यापित करता हूं कि मेरी वस्तु आसपास की वस्तुओं को उसी तरह से बुलाती है जिस तरह से इसे करना चाहिए।

— tronda
स्रोत

1

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

साधारण पूर्णांक के मामले में जो लागू होता है - पूर्णांक के बजाय लंबे समय से गुजरने पर क्या होता है? यही कारण है कि आप यूटी के लिए लिखते हैं :)

— m_pGladiator
स्रोत

1

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

— खोजी कुत्ता
स्रोत

1

जहाँ तक हो सके यूनिट परीक्षणों का उपयोग करके आपको "कोड के प्रत्येक गैर-तुच्छ ब्लॉक" का परीक्षण करना चाहिए।

यदि आपके गुण तुच्छ हैं और इसकी संभावना नहीं है कि कोई इसमें बग का परिचय देगा, तो यह सुरक्षित होना चाहिए कि यूनिट परीक्षण न करें।

आपके प्रमाणीकरण () और सहेजें () तरीके परीक्षण के लिए अच्छे उम्मीदवारों की तरह दिखते हैं।

— user7015
स्रोत

1

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

बाद में परीक्षण लिखना बहुत अधिक दर्दनाक है, लेकिन उल्लेखनीय है।

यहाँ मैं आपकी स्थिति में क्या करूँगा:

कोर फ़ंक्शन का परीक्षण करने वाले परीक्षणों का एक मूल सेट लिखें।
NCover प्राप्त करें और इसे अपने परीक्षणों पर चलाएं। इस बिंदु पर आपका परीक्षण कवरेज संभवतः लगभग 50% होगा।
लगभग 80% -90% का कवरेज मिलने तक अपने किनारे-मामलों को कवर करने वाले परीक्षण जोड़ते रहें

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

इस दृष्टिकोण के साथ एकमात्र समस्या यह है कि कोड को डिज़ाइन करना होगा इस तरह से परीक्षण योग्य जाना है। यदि आपने कोई कपलिंग गलतियाँ की हैं, तो आप बहुत आसानी से उच्च कवरेज प्राप्त नहीं कर पाएंगे।

यही कारण है कि कोड लिखने से पहले परीक्षण लिखना वास्तव में महत्वपूर्ण है। यह आपको कोड लिखने के लिए मजबूर करता है जो शिथिल युग्मित है।

— साइमन जॉनसन
स्रोत

1

स्पष्ट रूप से काम (बॉयलरप्लेट) कोड का परीक्षण न करें। इसलिए यदि आपके बसने वाले और पाने वाले सिर्फ "संपत्ति = मूल्य" और "वापसी संपत्ति" हैं, तो इसका परीक्षण करने का कोई मतलब नहीं है।

— erlando
स्रोत

1

यहां तक कि प्राप्त / सेट के विषम परिणाम हो सकते हैं, यह इस बात पर निर्भर करता है कि उन्हें कैसे लागू किया गया है, इसलिए उन्हें तरीकों के रूप में माना जाना चाहिए।

इनमें से प्रत्येक परीक्षण को संपत्तियों के लिए मापदंडों के सेट को निर्दिष्ट करने की आवश्यकता होगी, दोनों स्वीकार्य और अस्वीकार्य गुणों को परिभाषित करते हुए कॉल वापसी सुनिश्चित करने और अपेक्षित तरीके से विफल होने के लिए।

आपको सुरक्षा गोचरों के बारे में भी जानकारी होनी चाहिए, उदाहरण के लिए SQL इंजेक्शन, और इनका परीक्षण करें।

तो हाँ, आपको गुणों के परीक्षण के बारे में चिंता करने की आवश्यकता है।

— CestLaGalere
स्रोत

1

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

— आंद्रेई सावू
स्रोत

1

मैं किसी भी चीज के लिए एक परीक्षण लिखूंगा कि आप उसके लिए कोड लिख रहे हैं जो GUI इंटरफ़ेस के बाहर परीक्षण योग्य है।

आमतौर पर, कोई भी तर्क जो मैं लिखता हूं उसमें कोई भी व्यावसायिक तर्क होता है जिसे मैं किसी अन्य स्तरीय या व्यावसायिक तर्क परत के अंदर रखता हूं।

फिर कुछ के लिए परीक्षण लिखना जो कुछ करता है वह करना आसान है।

सबसे पहले, अपने "बिजनेस लॉजिक लेयर" में प्रत्येक सार्वजनिक पद्धति के लिए एक यूनिट टेस्ट लिखें।

अगर मेरे पास इस तरह एक वर्ग था:

   public class AccountService
    {
        public void DebitAccount(int accountNumber, double amount)
        {

        }

        public void CreditAccount(int accountNumber, double amount)
        {

        }

        public void CloseAccount(int accountNumber)
        {

        }
    }

इससे पहले कि मैं किसी भी कोड को जानने से पहले लिखूंगा कि मेरे पास ये कार्य करने के लिए यूनिट टेस्ट लिखना शुरू करना है।

   [TestFixture]
    public class AccountServiceTests
    {
        [Test]
        public void DebitAccountTest()
        {

        }

        [Test]
        public void CreditAccountTest()
        {

        }

        [Test]
        public void CloseAccountTest()
        {

        }
    }

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

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

तो, कहानी का नैतिक है, किसी भी चीज का परीक्षण करें जो आपके बारे में चिंतित हो सकता है, इकाई परीक्षणों को उन विशिष्ट चीजों का परीक्षण करते रहें जो आकार में छोटे हैं, बहुत सारे परीक्षण अच्छे हैं।

उपयोगकर्ता इंटरफ़ेस परत के बाहर अपने व्यापार तर्क रखें ताकि आप आसानी से उनके लिए परीक्षण लिख सकें, और आप अच्छे होंगे।

मैं TestDriven.Net या ReSharper की सलाह देता हूं क्योंकि दोनों आसानी से विज़ुअल स्टूडियो में एकीकृत हो जाते हैं।

— कोड बंदर
स्रोत

1

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

जैसा कि अन्य लोगों ने कहा है, गेटर्स और सेटर्स के लिए यूनिट टेस्ट ओवरकिल हैं, जब तक कि आपके गेटर्स और सेटर्स में सशर्त लॉजिक नहीं है।

— स्कॉट लॉरेंस
स्रोत

1

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

बहुत सारे परीक्षणों के साथ कोड लेकिन एक छोटी कवरेज का अच्छी तरह से परीक्षण नहीं किया गया है। उस ने कहा, 100% कवरेज के साथ कोड लेकिन सीमा और त्रुटि मामलों का परीक्षण भी महान नहीं है।

आप उच्च कवरेज (90% न्यूनतम) और चर इनपुट डेटा के बीच संतुलन चाहते हैं।

"कचरा" के लिए परीक्षण करना याद रखें!

इसके अलावा, एक इकाई-परीक्षण एक इकाई-परीक्षण नहीं है जब तक कि यह एक विफलता के लिए जाँच नहीं करता है। यूनिट-परीक्षण जिसमें मुखर नहीं होते हैं या ज्ञात अपवादों के साथ चिह्नित होते हैं, बस परीक्षण करेंगे कि कोड चलने पर मर नहीं जाता है!

आपको अपने परीक्षणों को डिज़ाइन करने की आवश्यकता है ताकि वे हमेशा विफलताओं या अप्रत्याशित / अवांछित डेटा की रिपोर्ट करें!

— रे हेस
स्रोत

1

यह हमारे कोड को बेहतर बनाता है ... अवधि!

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

इकाई परीक्षण के लिए सही भावना में, ये परीक्षण मुख्य रूप से हमारे कोड के "परीक्षण" के लिए नहीं हैं ; या 90% -100% बेहतर कोड कवरेज प्राप्त करने के लिए। ये पहले परीक्षण लिखने के सभी फ्रिंज लाभ हैं। बड़ी अदायगी यह है कि हमारे उत्पादन कोड को टीडीडी की प्राकृतिक प्रक्रिया के कारण बहुत बेहतर लिखा जाना चाहिए।

इस विचार को बेहतर ढंग से संप्रेषित करने में मदद करने के लिए, निम्नलिखित पढ़ने में मददगार हो सकता है:

Flawed Theory of Unit टेस्ट्स
पर्पसफुल सॉफ्टवेयर डेवलपमेंट

अगर हमें लगता है कि अधिक यूनिट परीक्षण लिखने का कार्य हमें उच्च गुणवत्ता वाले उत्पाद प्राप्त करने में मदद करता है, तो हम कार्गो टॉवल ऑफ़ टेस्ट ड्रिवेन डेवलपमेंट से पीड़ित हो सकते हैं ।

— स्कॉट साद को दर्शाता है
स्रोत

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

— स्कॉट लॉरेंस

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

— स्कॉट साद

आप कैसे जानते हैं कि इकाई परीक्षण लिखते समय क्या परीक्षण करना है? [बन्द है]

यह हमारे कोड को बेहतर बनाता है ... अवधि!