मुझे यकीन है कि आप में से अधिकांश बहुत सारे स्वचालित परीक्षण लिख रहे हैं और यह कि आप इकाई परीक्षण के दौरान कुछ सामान्य नुकसानों में भाग चुके हैं।
मेरा प्रश्न है कि क्या आप भविष्य में समस्याओं से बचने के लिए परीक्षण लिखने के लिए किसी भी तरह के आचरण का पालन करते हैं? अधिक विशिष्ट होने के लिए: अच्छी इकाई परीक्षणों के गुण क्या हैं या आप अपने परीक्षण कैसे लिखते हैं?
भाषा अज्ञेय सुझावों को प्रोत्साहित किया जाता है।
जवाबों:
मुझे प्लग-इन स्रोतों से शुरू करने दें - जावा में प्रोगैमैटिक यूनिट टेस्टिंग विथ जेयूनाइट (इसमें सी # के साथ एक वर्जन भी है -न्यूनिट भी है .. लेकिन मेरे पास यह एक है .. अधिकांश भाग के लिए इसका अज्ञेय अनुशंसित है।)
अच्छे टेस्ट ए ट्रिप होने चाहिए ( ए ब्रीफ काफी चिपचिपा नहीं है - मेरे पास किताब में चीटशीट का एक प्रिंटआउट है जिसे मुझे यह सुनिश्चित करने के लिए बाहर निकालना पड़ा कि मुझे यह अधिकार मिला है ..)
व्यावसायिक : लंबे समय में आपके पास उत्पादन के रूप में अधिक से अधिक परीक्षण कोड होंगे (यदि अधिक नहीं), इसलिए अपने परीक्षण कोड के लिए अच्छे डिजाइन के समान मानक का पालन करें। मंशा-प्रकट नाम, कोई दोहराव, अच्छे नामों के साथ परीक्षण आदि के साथ अच्छी तरह से फैक्टरेड तरीके-कक्षाएं।
अच्छे टेस्ट फास्ट भी चलते हैं । किसी भी परीक्षा को चलाने में आधा सेकंड से अधिक समय लगता है .. इस पर काम करने की आवश्यकता है। परीक्षण सूट एक रन के लिए अधिक समय लेता है .. कम बार इसे चलाया जाएगा। जितने अधिक बदलाव देव रन के बीच में घुसने की कोशिश करेंगे .. अगर कुछ भी टूटता है .. तो यह पता लगाने में अधिक समय लगेगा कि कौन सा बदलाव अपराधी था।
अद्यतन 2010-08:
इनके अलावा, अधिकांश अन्य ऐसे दिशानिर्देश हैं जो कम-लाभ वाले कार्यों में कटौती करते हैं: उदाहरण के लिए 'कोड का परीक्षण न करें जो आपके पास नहीं है' (जैसे तृतीय-पक्ष DLL)। परीक्षण गेटर्स और सेटर के बारे में मत जाना। लागत-से-लाभ अनुपात या दोष संभावना पर नज़र रखें।
यहां अधिकांश उत्तर वास्तव में परीक्षण को लिखने के बजाय सामान्य (जब, कहां, क्यों और क्या) में सर्वोत्तम प्रथाओं के यूनिट परीक्षण को संबोधित करते प्रतीत होते हैं। चूंकि प्रश्न "कैसे" भाग पर बहुत विशिष्ट लगता था, मैंने सोचा कि मैं इसे पोस्ट करूंगा, "ब्राउन बैग" प्रस्तुति से लिया गया जिसे मैंने अपनी कंपनी में आयोजित किया था।
1. लंबे, वर्णनात्मक परीक्षण विधि नामों का उपयोग करें।
- Map_DefaultConstructorShouldCreateEmptyGisMap()
- ShouldAlwaysDelegateXMLCorrectlyToTheCustomHandlers()
- Dog_Object_Should_Eat_Homework_Object_When_Hungry()
2. अपने परीक्षणों को एक अरेंज / एक्ट / एसर शैली में लिखें ।
3. हमेशा अपने असर्स के साथ एक विफलता संदेश प्रदान करें।
Assert.That(x == 2 && y == 2, "An incorrect number of begin/end element
processing events was raised by the XElementSerializer");
4. परीक्षण का कारण टिप्पणी करें - व्यवसाय की धारणा क्या है?
/// A layer cannot be constructed with a null gisLayer, as every function
/// in the Layer class assumes that a valid gisLayer is present.
[Test]
public void ShouldNotAllowConstructionWithANullGisLayer()
{
}
5. प्रत्येक परीक्षण को हमेशा किसी भी संसाधन की स्थिति को वापस लेना चाहिए जिसे वह छूता है
इन लक्ष्यों को ध्यान में रखें (पुस्तक XUnit टेस्ट पैटर्न से Meszaros द्वारा अनुकूलित)
इसे आसान बनाने के लिए कुछ बातें:
यह मत भूलो कि आप अपने एक्सयूनिट ढांचे के साथ इंटरग्रेशन परीक्षण भी कर सकते हैं लेकिन इंटरग्रेशन टेस्ट और यूनिट टेस्ट अलग रखें
टेस्ट को अलग-थलग किया जाना चाहिए। एक परीक्षण दूसरे पर निर्भर नहीं होना चाहिए। आगे भी, एक परीक्षण को बाहरी प्रणालियों पर भरोसा नहीं करना चाहिए। दूसरे शब्दों में, अपने कोड का परीक्षण करें , न कि आपके कोड पर निर्भर करता है। आप उन इंटरैक्शन को अपने एकीकरण या कार्यात्मक परीक्षणों के हिस्से के रूप में परीक्षण कर सकते हैं।
महान इकाई परीक्षणों के कुछ गुण:
जब एक परीक्षण विफल हो जाता है, तो यह तुरंत स्पष्ट होना चाहिए कि समस्या कहाँ है। यदि आपको समस्या को ट्रैक करने के लिए डीबगर का उपयोग करना है, तो आपके परीक्षण पर्याप्त रूप से दानेदार नहीं हैं। प्रति परीक्षण बिल्कुल एक दावे के बाद यहाँ मदद मिलती है।
जब आप रिफ्लेक्टर करते हैं, तो कोई भी परीक्षण विफल नहीं होना चाहिए।
टेस्ट इतनी तेजी से चलने चाहिए कि आप उन्हें चलाने में कभी संकोच न करें।
सभी परीक्षण हमेशा पास होने चाहिए; कोई गैर-नियतात्मक परिणाम नहीं।
यूनिट टेस्ट आपके प्रोडक्शन कोड की तरह ही अच्छी तरह से होने चाहिए।
@Alotor: यदि आप सुझाव दे रहे हैं कि एक पुस्तकालय को केवल अपने बाहरी एपीआई में इकाई परीक्षण होना चाहिए, तो मैं असहमत हूं। मैं प्रत्येक वर्ग के लिए यूनिट परीक्षण चाहता हूं, जिसमें वे कक्षाएं शामिल हैं जिन्हें मैं बाहरी कॉल करने वालों के लिए उजागर नहीं करता हूं। (हालांकि, अगर मुझे निजी तरीकों के लिए परीक्षण लिखने की आवश्यकता महसूस होती है, तो मुझे रिफ्लेक्टर करने की आवश्यकता है। )
संपादित करें: "प्रति परीक्षण एक जोर" के कारण दोहराव के बारे में एक टिप्पणी थी। विशेष रूप से, यदि आपके पास परिदृश्य सेट करने के लिए कुछ कोड हैं, और फिर इसके बारे में कई दावे करना चाहते हैं, लेकिन प्रति परीक्षण केवल एक जोर है, तो आप कई परीक्षणों में सेटअप दोहरा सकते हैं।
मैं वह तरीका नहीं अपनाता। इसके बजाय, मैं प्रति परिदृश्य परीक्षण फिक्स्चर का उपयोग करता हूं । यहाँ एक मोटा उदाहरण है:
[TestFixture]
public class StackTests
{
[TestFixture]
public class EmptyTests
{
Stack<int> _stack;
[TestSetup]
public void TestSetup()
{
_stack = new Stack<int>();
}
[TestMethod]
[ExpectedException (typeof(Exception))]
public void PopFails()
{
_stack.Pop();
}
[TestMethod]
public void IsEmpty()
{
Assert(_stack.IsEmpty());
}
}
[TestFixture]
public class PushedOneTests
{
Stack<int> _stack;
[TestSetup]
public void TestSetup()
{
_stack = new Stack<int>();
_stack.Push(7);
}
// Tests for one item on the stack...
}
}
परीक्षण के बाद कक्षा के व्यवहारों के परिसीमन के बाद आप क्या कर रहे हैं।
मूल आशय वर्ग के व्यवहार में आपके आत्मविश्वास को बढ़ा रहा है।
यह विशेष रूप से तब उपयोगी होता है जब आप अपने कोड को रीक्रिएट करके देखते हैं। मार्टिन फाउलर का अपनी वेब साइट पर परीक्षण के संबंध में एक दिलचस्प लेख है ।
HTH।
चियर्स,
लूटना
टेस्ट मूल रूप से फेल होना चाहिए। फिर आपको उस कोड को लिखना चाहिए जो उन्हें पास करता है, अन्यथा आप एक परीक्षण लिखने का जोखिम चलाते हैं जो कि खराब है और हमेशा गुजरता है।
मुझे राइट BICEP की पूर्वोक्त व्यावहारिक इकाई परीक्षण पुस्तक से संक्षिप्तता पसंद है :
व्यक्तिगत रूप से मुझे लगता है कि आप जाँच करके बहुत दूर निकल सकते हैं कि आपको सही परिणाम मिलें (1 + 1 को अतिरिक्त फ़ंक्शन में 2 वापस करना चाहिए), आप उन सभी सीमाओं की कोशिश कर सकते हैं जो आप सोच सकते हैं (जैसे कि दो संख्याओं का उपयोग करना जिनमें से योग ऐड फंक्शन में पूर्णांक अधिकतम मान से अधिक है) और नेटवर्क विफलता जैसी त्रुटि की स्थिति को मजबूर करता है।
अच्छे परीक्षणों को बनाए रखने की आवश्यकता है।
मुझे पता नहीं चला कि जटिल वातावरण के लिए यह कैसे करना है।
जैसे ही आपका कोड आधार 1000 या लाखों की संख्या में कोड तक पहुँचना शुरू होता है, सभी पाठ्यपुस्तकों को अनियंत्रित होना शुरू हो जाता है।
अच्छा आर्किटेक्चर कुछ इंटरैक्शन विस्फोट को नियंत्रित कर सकता है, लेकिन अनिवार्य रूप से सिस्टम अधिक जटिल हो जाता है क्योंकि स्वचालित परीक्षण प्रणाली इसके साथ बढ़ती है।
यह वह जगह है जहाँ आप व्यापार-नापसंद से निपटने के लिए शुरू करते हैं:
आपको यह भी तय करना होगा:
आप अपने कोड आधार में परीक्षण मामलों को कहाँ संग्रहीत करते हैं?
मैं हमेशा के लिए जा सकता था, लेकिन मेरी बात यह है कि:
टेस्ट को बरकरार रखने की जरूरत है।
मैंने इस MSDN पत्रिका लेख में कुछ समय पहले इन सिद्धांतों को कवर किया था जो मुझे लगता है कि किसी भी डेवलपर के लिए पढ़ना महत्वपूर्ण है।
जिस तरह से मैं "अच्छा" इकाई परीक्षणों को परिभाषित करता हूं, अगर वे निम्नलिखित तीन गुणों को रखते हैं:
जे फील्ड्स में यूनिट टेस्ट लिखने के बारे में बहुत अच्छी सलाह है और एक पोस्ट है जहां वह सबसे महत्वपूर्ण सलाह को सारांशित करता है । वहां आप पढ़ेंगे कि आपको अपने संदर्भ के बारे में गंभीर रूप से सोचना चाहिए और सलाह देना चाहिए कि क्या सलाह आपके लायक है। आपको यहाँ अद्भुत उत्तर दिए जा सकते हैं, लेकिन यह तय करना है कि आपके संदर्भ के लिए सबसे अच्छा क्या है। उन्हें आज़माएं और सिर्फ रिफ्लेक्टिंग करें अगर यह आपके लिए ख़राब है।
सधन्यवाद
कभी नहीं मानें कि एक तुच्छ 2 लाइन विधि काम करेगी। एक त्वरित इकाई परीक्षण लिखना, लापता नल परीक्षण को रोकने का एकमात्र तरीका है, गलत माइनस साइन और / या सूक्ष्म काटने की त्रुटि आपको काटने से रोकती है, अनिवार्य रूप से जब आपके पास अब से निपटने के लिए कम समय है।
मैं "A TRIP" का उत्तर देता हूं, सिवाय इसके कि परीक्षण एक-दूसरे पर भरोसा करते हैं !!!
क्यों?
DRY - खुद को दोहराएं - परीक्षण पर भी लागू होता है! टेस्ट निर्भरता 1) सेटअप समय बचाने में मदद कर सकती है, 2) स्थिरता संसाधनों को बचा सकती है, और 3) विफलताओं को इंगित करता है। बेशक, केवल यह देखते हुए कि आपका परीक्षण ढांचा प्रथम श्रेणी की निर्भरता का समर्थन करता है। अन्यथा, मैं मानता हूं, वे बुरे हैं।
Http://www.iam.unibe.ch/~scg/Research/JExample/ का अनुसरण करें
अक्सर यूनिट परीक्षण मॉक ऑब्जेक्ट या मॉक डेटा पर आधारित होते हैं। मुझे तीन तरह के यूनिट टेस्ट लिखना पसंद है:
बिंदु यह है कि हर कार्य को जांचने में सक्षम होने के लिए सब कुछ फिर से करने से बचें ।
2 प्रकार के परीक्षण के बारे में सोचें और उन्हें अलग तरह से व्यवहार करें - कार्यात्मक परीक्षण और प्रदर्शन परीक्षण।
प्रत्येक के लिए अलग-अलग इनपुट और मेट्रिक्स का उपयोग करें। आपको प्रत्येक प्रकार के परीक्षण के लिए विभिन्न सॉफ्टवेयर का उपयोग करने की आवश्यकता हो सकती है।
मैं रॉय ओशेरोव के यूनिट टेस्ट नामकरण मानकों द्वारा वर्णित एक सुसंगत परीक्षण नामकरण सम्मेलन का उपयोग करता हूं , किसी दिए गए टेस्ट केस क्लास में प्रत्येक विधि में निम्नलिखित नामकरण शैली MethodUnderTest_Scenario_ExpectedResult है।
प्रत्येक अनुभाग अपर कैमल केस का उपयोग करता है और इसे एक अंडर स्कोर द्वारा सीमांकित किया जाता है।
मुझे यह उपयोगी लगा जब मैंने परीक्षण को चलाया तो परीक्षण को परीक्षण के तहत विधि के नाम से वर्गीकृत किया गया। और एक सम्मेलन में अन्य डेवलपर्स को परीक्षण के इरादे को समझने की अनुमति मिलती है।
यदि मैं परीक्षण के तहत विधि अतिभारित कर दिया गया है, तो मैं विधि नाम के मापदंडों को भी जोड़ता हूं।