दिलचस्प पोस्ट
मैं MATLAB में केवल एक ही चरण में समान नाम और / या स्ट्रिंग के साथ 100 फाइल कैसे लोड कर सकता हूं? एज़ुर में वेब जॉब के रूप में फांटोमजेएस मैं पर्ल वेब क्रॉलर में जावास्क्रिप्ट को कैसे नियंत्रित कर सकता हूं? जावा 8 संपत्ति के द्वारा अलग JButton () केवल जब माउस hovers काम कर रहा है एक तालिका में माइक्रोसॉफ्ट एक्सेस एक से अधिक पंक्तियां एकत्रित करता है पांडा: दिए गए कॉलम के लिए राशि डेटाफ्रेम पंक्तियों क्यों JVM अभी भी पूंछ कॉल अनुकूलन का समर्थन नहीं करता है? पैरामीटर नाम को प्रतिबिंबित करना: सी # लैम्ब्डा अभिव्यक्ति या सिंटैक्स प्रतिभा का दुरुपयोग? क्लाइंट का IP पता प्राप्त करना: REMOTE_ADDR, HTTP_X_FORWARDED_FOR, और क्या उपयोगी हो सकता है? एंड्रॉइड 4.3 ब्लूटूथ कम ऊर्जा अस्थिर सभी जांच चेकबॉक्स कैसे प्राप्त करें एंड्रॉइड डिज़ाइन समर्थन लाइब्रेरी विस्तार योग्य फ़्लोटिंग एक्शन बटन (एफएबी) मेन्यू सुपर () को एक व्युत्पन्न वर्ग में बुलाते समय, क्या मैं स्वयं .__ वर्ग__ में पारित कर सकता हूं? मैं पीडीएफ दस्तावेज़ को PHP में एक पूर्वावलोकन छवि में कैसे रूपांतरित कर सकता हूं?

क्या किसी को आंतरिक कार्यान्वयन, या केवल सार्वजनिक व्यवहार का परीक्षण करना चाहिए?

देखते हुए सॉफ्टवेयर …

  • प्रणाली में कुछ उप-प्रणालियां शामिल हैं
  • प्रत्येक सबसिस्टम में कुछ घटकों के होते हैं
  • प्रत्येक घटक कई वर्गों का उपयोग करके कार्यान्वित किया जाता है

… मैं प्रत्येक उपतंत्र या घटक के स्वचालित परीक्षण लिखना चाहता हूं।

मैं एक घटक के प्रत्येक आंतरिक वर्ग के लिए एक परीक्षण नहीं लिखता (सिवाय इसके कि प्रत्येक वर्ग घटक की सार्वजनिक कार्यक्षमता में योगदान देता है और इसलिए घटक के सार्वजनिक एपीआई के माध्यम से बाहर से परीक्षण किया जाता है)।

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

मुझे लगता है कि यह नीति एक दस्तावेज के साथ विरोधाभासी है जैसे रिफ़ैक्टरिंग टेस्ट कोड , जो ऐसी बातें कहता है …

  • "… इकाई का परीक्षण …"
  • "… सिस्टम में हर कक्षा के लिए एक परीक्षण वर्ग …"
  • "… टेस्ट कोड / प्रोडक्शन कोड अनुपात … आदर्श रूप से 1: 1 के अनुपात के लिए माना जाता है …"

… सभी जिनमें से मुझे लगता है कि मैं (या कम से कम अभ्यास नहीं करता) से असहमत हूं।

मेरा सवाल है, अगर आप मेरी नीति से असहमत हैं, तो आप क्यों समझाएंगे? किस परिदृश्य में परीक्षण की डिग्री अपर्याप्त है?

संक्षेप में:

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

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

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

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

फुटनोट: "घटक" द्वारा, मेरा मतलब "एक डीएलएल" या "एक विधानसभा" जैसी कुछ चीज़ है … ऐसी किसी चीज को एक वास्तुकला या सिस्टम के परिनियोजन आरेख पर दिखाई देने के लिए काफी बड़ा है, अक्सर दर्जनों या 100 कक्षाओं का उपयोग करके, और एक सार्वजनिक एपीआई के साथ जिसमें केवल 1 या एक मुट्ठी भर इंटरफेस होता है … जिसे डेवलपर्स की एक टीम को सौंपा जा सकता है (जहां एक अलग घटक एक अलग टीम को सौंपा गया है), और इसलिए कॉनवे के कानून के अनुसार होगा एक अपेक्षाकृत स्थिर सार्वजनिक एपीआई


फुटनोट: आलेख ऑब्जेक्ट-ओरिएंटेड टेस्टिंग: मिथ एंड रियलिटी कहती है,

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

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

मुझे यह कहना चाहिए कि मैं सफ़लबॉक्स कार्यात्मक परीक्षण कर रहा हूं: मुझे कोड (कार्यान्वयन में) दिखाई देता है और मैं विभिन्न कोड शाखाओं (फीचर के कार्यान्वयन का ब्योरा) के लिए कार्यात्मक परीक्षण (जो सार्वजनिक एपीआई चलाता है) लिखता हूं।

वेब के समाधान से एकत्रित समाधान "क्या किसी को आंतरिक कार्यान्वयन, या केवल सार्वजनिक व्यवहार का परीक्षण करना चाहिए?"

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

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

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

यूनिट-टेस्ट यह जांचने के लिए है कि आपके द्वारा लिखी गई 10 लाइनों की लिखी गई लिखित कोड क्या है। यह आपको आपके कोड पर अधिक आत्मविश्वास देता है।

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

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

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

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

यह अलग तरीके से वाक्यांश के लिए, केवल सार्वजनिक व्यवहार का परीक्षण करने के लिए सही है, जब तक कि आप ध्यान दें कि हर सार्वजनिक रूप से दृश्यमान वर्ग में सार्वजनिक व्यवहार होता है

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

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

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

बेशक, इकाई परीक्षण भी गलत हो सकता है, लेकिन अगर आप अपने परीक्षण संबंधी मामलों को अपने कार्यात्मक / तकनीकी विनिर्देशों से विकसित करते हैं (आपके पास एक है, सही?;)), तो आपको बहुत अधिक परेशानी नहीं होनी चाहिए।

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

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

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

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

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

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

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

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

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

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

मैं यहां पर अधिकांश पदों से सहमत हूं, हालांकि मैं इसे जोड़ूंगा:

सार्वजनिक इंटरफेस का परीक्षण करने के लिए प्राथमिक प्राथमिकता है, फिर संरक्षित, फिर निजी

आम तौर पर सार्वजनिक और संरक्षित इंटरफेस निजी और संरक्षित इंटरफेस के संयोजन का सारांश है।

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

मैं खुद संरक्षित भागों का भी परीक्षण करता हूं, क्योंकि वे "सार्वजनिक" से विरासत में हैं …

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

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

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

[मेरे अपने प्रश्न का उत्तर]

हो सकता है कि इनमें से एक वेरिएबल्स में से एक है जो बहुत अलग प्रोग्रामर हैं जो कोडिंग हैं:

  • स्वयंसिद्ध: प्रत्येक प्रोग्रामर को अपने कोड का परीक्षण करना चाहिए

  • इसलिए: यदि कोई प्रोग्रामर लिखता है और एक "इकाई" को बचाता है, तो उन्हें उस यूनिट का परीक्षण भी करना चाहिए, काफी "यूनिट परीक्षण" लिखकर

  • कोरलारी: यदि एक प्रोग्रामर पूरी पैकेज लिखता है, तो प्रोग्रामर के लिए पूरे पैकेज के कार्यात्मक परीक्षण लिखने के लिए पर्याप्त है (पैकेज में इकाइयों के "यूनिट" परीक्षण लिखने की कोई आवश्यकता नहीं है, क्योंकि उन इकाइयां कार्यान्वयन के विवरण हैं जो अन्य प्रोग्रामर कोई सीधी पहुंच / एक्सपोजर नहीं है)

इसी तरह, "नकली" घटकों के निर्माण का अभ्यास जो आप के खिलाफ कर सकते हैं:

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

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

स्वयंसिद्ध: प्रत्येक प्रोग्रामर को अपने कोड का परीक्षण करना चाहिए

मुझे नहीं लगता कि यह सार्वभौमिक सत्य है।

क्रिप्टोग्राफ़ी में, एक प्रसिद्ध कहावत है: "एक सिफर बनाना बहुत आसान है, आपको नहीं पता कि यह कैसे खुद को तोड़ना है।"

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

आपका विश्वास आपको कम सतर्क परीक्षक बना देगा जो कोड के साथ आपके अनुभव को साझा नहीं करता है, उसे कोई समस्या नहीं होगी।

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

इसके अतिरिक्त, एक तर्क है कि एक अच्छा प्रोग्रामर होने के लिए आपको किनारे के मामलों की चिंता होनी चाहिए, लेकिन एक अच्छा परीक्षक बनने के लिए आपको चिंता है 😉 भी, परीक्षक सस्ता हो सकते हैं, इसलिए यह अलग होने के लायक हो सकता है उस कारण के लिए टेस्ट टीम

मुझे लगता है कि अत्यधिक सवाल यह है: सॉफ्टवेयर में कीड़े ढूंढने में कौन सी पद्धति सबसे अच्छी है? मैंने हाल ही में एक वीडियो देखा है (कोई लिंक, खेद नहीं) यह बताते हुए कि यादृच्छिक परीक्षण मानव निर्मित परीक्षणों के मुकाबले सस्ता और प्रभावी है।

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

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

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

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

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

मुझे लगता है यह testability के लिए डिजाइनिंग और परेशान नहीं करने के बीच प्रमुख अंतर है।

क्या आप अभी भी इस दृष्टिकोण का अनुसरण कर रहे हैं? मुझे यह भी विश्वास है कि यह सही दृष्टिकोण है आपको केवल सार्वजनिक इंटरफेस का परीक्षण करना चाहिए अब सार्वजनिक इंटरफ़ेस एक सेवा या कुछ घटक हो सकता है जो किसी भी प्रकार की UI या किसी अन्य स्रोत से इनपुट लेता है।

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

निर्णय लेने के लिए केवल संतुलित निर्णय लिया जाना चाहिए जो एक बड़ी सेवा या घटक को कुछ छोटी सेवाओं और घटक में तोड़ने का है जिसे पुन: उपयोग किया जा सकता है। यदि आप दृढ़ता से मानते हैं कि परियोजनाओं में एक घटक पुन: उपयोग किया जा सकता है तब उस घटक के लिए स्वचालित परीक्षण लिखे जाने चाहिए। लेकिन फिर बड़ी सेवा या घटक के लिए लिखे गए परीक्षणों को एक घटक के रूप में कार्यात्मक रूप से पहले से ही परीक्षण किया जाना चाहिए।

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

मुझे बताएं अगर आपने किसी अच्छी प्रक्रिया को विकसित किया है जो आपके लिए काम करता है ..

अमीत का संबंध है