🎅🏽 👨‍👦 👨🏾‍🔧 एकता में इकाई परीक्षण का परिचय 🈷️ 👨🏼‍🎓 👩🏿‍⚖️

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

यह क्या है
इसका लाभ
फायदे और नुकसान
यह टेस्ट रनर का उपयोग करके एकता में कैसे काम करता है
यूनिट परीक्षणों को कैसे लिखना और निष्पादित करना है जिनका परीक्षण किया जाएगा

नोट : यह ट्यूटोरियल मानता है कि आप C # भाषा और एकता में विकास की मूल बातें से परिचित हैं। यदि आप एकता के लिए नए हैं, तो पहले इस इंजन पर अन्य ट्यूटोरियल देखें ।

एक इकाई परीक्षण क्या है?

कोड में देरी करने से पहले, यह समझना महत्वपूर्ण है कि इकाई परीक्षण क्या है। सीधे शब्दों में कहें तो यूनिट टेस्टिंग टेस्टिंग है ... यूनिट्स।

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

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

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

 public string name = "" public void UpdateNameWithCharacter(char: character) { // 1 if (!Char.IsLetter(char)) { return; } // 2 if (name.Length > 10) { return; } // 3 name += character; }

यहाँ क्या हो रहा है:

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

इस इकाई का परीक्षण किया जा सकता है, क्योंकि यह प्रदर्शन किए गए कार्य का "मॉड्यूल" है। इकाई परीक्षण विधि तर्क को लागू करते हैं।

यूनिट टेस्ट उदाहरण

UpdateNameWithCharacter विधि के लिए हम यूनिट टेस्ट कैसे लिखते हैं?

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

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

UpdateNameDoesntAllowCharacterAddingToNameIfNameIsTenOrMoreCharactersInLength

UpdateNameAllowsLettersToBeAddedToName

UpdateNameDoesntAllowNonLettersToBeAddedToName

परीक्षण विधियों के इन नामों से, हम देखते हैं कि हम वास्तव में जाँचते हैं कि क्या कार्य की "इकाई" UpdateNameWithCharacter विधि द्वारा UpdateNameWithCharacter जाता है। ये परीक्षण नाम बहुत लंबे और विस्तृत लग सकते हैं, लेकिन यह हमारे लिए अच्छा है।

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

खेल का शुभारंभ

क्रैशरॉइड्स स्टार्टर प्रोजेक्ट खोलें (आप इसे यहां से डाउनलोड कर सकते हैं ), और फिर एसेट्स / आरडब्ल्यू / दृश्यों फ़ोल्डर से गेम दृश्य खोलें।

क्रैशरॉयड लॉन्च करने के लिए प्ले पर क्लिक करें, और फिर स्टार्ट गेम बटन पर क्लिक करें। कीबोर्ड पर बाएँ और दाएँ तीर के साथ स्पेसशिप ले जाएँ।

लेजर बीम को आग लगाने के लिए, स्पेसबार को दबाएं। यदि बीम क्षुद्रग्रह को मारता है, तो स्कोर एक से बढ़ जाएगा। यदि कोई क्षुद्रग्रह जहाज से टकराता है, तो जहाज फट जाता है और खेल समाप्त हो जाता है (फिर से शुरू करने की क्षमता के साथ)।

थोड़ा खेलने की कोशिश करें और सुनिश्चित करें कि जहाज के साथ क्षुद्रग्रह की टक्कर के बाद शिलालेख गेम ओवर दिखाई देता है।

एकता टेस्ट रनर के साथ शुरू हो रही है

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

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

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

एनयूनिट और टेस्ट फोल्डर्स तैयार करना

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

परीक्षणों को चलाने के लिए, हमें सबसे पहले एक परीक्षण फ़ोल्डर बनाना होगा जिसमें परीक्षण कक्षाएं संग्रहीत की जाएंगी।

प्रोजेक्ट विंडो में , RW फ़ोल्डर का चयन करें। टेस्ट रनर विंडो पर एक नज़र डालें और सुनिश्चित करें कि PlayMode का चयन किया गया है।

Create PlayMode Test विधानसभा फ़ोल्डर नामक बटन पर क्लिक करें। आपको आरडब्ल्यू फ़ोल्डर में एक नया फ़ोल्डर दिखाई देगा। हम मानक नाम टेस्ट से संतुष्ट हैं, इसलिए आप केवल एंटर दबा सकते हैं।

आप सोच रहे होंगे कि टेस्ट रनर के अंदर ये दो अलग-अलग टैब क्या हैं।

PlayMode टैब का उपयोग प्ले मोड (जब गेम वास्तविक समय में चल रहा हो) में किए गए परीक्षणों के लिए किया जाता है। EditMode टैब पर परीक्षण प्ले मोड के बाहर चलाए जाते हैं , जो इंस्पेक्टर में कस्टम व्यवहार जैसी चीजों के परीक्षण के लिए सुविधाजनक है।

इस ट्यूटोरियल में, हम PlayMode परीक्षणों को कवर करेंगे। लेकिन जब आप सहज हो जाते हैं, तो आप EditMode में परीक्षण के साथ प्रयोग करने का प्रयास कर सकते हैं। इस ट्यूटोरियल में टेस्ट रनर के साथ काम करते समय, हमेशा सुनिश्चित करें कि PlayMode टैब चुना गया है ।

टेस्ट सूट में क्या है?

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

टेस्ट रनर सभी टेस्ट क्लास फाइल्स को बायपास करता है और उनसे यूनिट टेस्ट करता है। एक यूनिट फ़ाइल जिसमें यूनिट टेस्ट होते हैं, टेस्ट सूट कहलाता है।

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

टेस्ट असेंबली और टेस्ट सूट तैयार करना

टेस्ट फ़ोल्डर चुनें और टेस्ट रनर विंडो में करेंट फोल्डर बटन में टेस्ट स्क्रिप्ट बनाएं पर क्लिक करें। नई TestSuite फ़ाइल का नाम दें।

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

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

टेस्ट कोड के लिए गेम कक्षाओं तक पहुंच के लिए, हम क्लास कोड की एक असेंबली बनाएंगे और टेस्ट असेंबली में लिंक सेट करेंगे। इसे चुनने के लिए लिपियों फ़ोल्डर पर क्लिक करें। इस फ़ोल्डर पर राइट-क्लिक करें और Create ▸ विधानसभा परिभाषा चुनें ।

फ़ाइल का नाम GameAssembly नाम दें ।

टेस्ट फ़ोल्डर पर क्लिक करें, और फिर टेस्ट परिभाषा फ़ाइल का निर्माण करते हैं। इंस्पेक्टर में, विधानसभा परिभाषा संदर्भ शीर्षक के तहत प्लस बटन पर क्लिक करें।

आपको गुम संदर्भ क्षेत्र दिखाई देगा। चयन विंडो खोलने के लिए इस फ़ील्ड के बगल में स्थित डॉट पर क्लिक करें। GameAssembly फ़ाइल का चयन करें।

आपको लिंक अनुभाग में GameAssembly असेंबली फ़ाइल को देखना चाहिए। इन परिवर्तनों को सहेजने के लिए लागू करें बटन पर क्लिक करें ।

यदि आप इन चरणों का पालन नहीं करते हैं, तो आप यूनिट टेस्ट फाइलों के अंदर गेम की क्लास फाइलों को संदर्भित नहीं कर पाएंगे। इससे निपटने के बाद, आप कोड के लिए आगे बढ़ सकते हैं।

हम पहली इकाई परीक्षण लिखते हैं

कोड संपादक में इसे खोलने के लिए TestSuite स्क्रिप्ट पर डबल-क्लिक करें। इसके साथ सभी कोड बदलें:

 using UnityEngine; using UnityEngine.TestTools; using NUnit.Framework; using System.Collections; public class TestSuite { }

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

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

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

 private Game game; // 1 [UnityTest] public IEnumerator AsteroidsMoveDown() { // 2 GameObject gameGameObject = MonoBehaviour.Instantiate(Resources.Load<GameObject>("Prefabs/Game")); game = gameGameObject.GetComponent<Game>(); // 3 GameObject asteroid = game.GetSpawner().SpawnAsteroid(); // 4 float initialYPos = asteroid.transform.position.y; // 5 yield return new WaitForSeconds(0.1f); // 6 Assert.Less(asteroid.transform.position.y, initialYPos); // 7 Object.Destroy(game.gameObject); }

कोड की केवल कुछ पंक्तियाँ हैं, लेकिन वे बहुत सारी चीज़ें करते हैं। तो चलो बंद करो और प्रत्येक भाग से निपटें:

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

पासिंग टेस्ट

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

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

यह एक अस्थायी दृश्य बनाएगा और परीक्षण चलाएगा। पूरा होने पर, आपको देखना चाहिए कि परीक्षण पास हो गया।

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

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

एकीकरण परीक्षणों का उपयोग करना

इकाई परीक्षणों के खरगोश छेद में गहराई से जाने से पहले, यह बताने का समय है कि एकीकरण परीक्षण क्या हैं और वे इकाई परीक्षण से कैसे भिन्न हैं।

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

मान लीजिए कि आपने एक युद्ध खेल बनाया जहां एक खिलाड़ी राक्षसों को मारता है। आप यह सुनिश्चित करने के लिए एक एकीकरण परीक्षण बना सकते हैं कि जब कोई खिलाड़ी 100 दुश्मनों को मारता है, तो एक उपलब्धि ("उपलब्धि") खोली जाती है।

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

एकीकरण परीक्षण 100 राक्षसों को मारने वाले खिलाड़ी का अनुकरण करेगा और जांच करेगा कि क्या उपलब्धि अनलॉक की गई है। यह इकाई परीक्षण से बहुत अलग है क्योंकि यह बड़े कोड घटकों का परीक्षण करता है जो एक साथ काम करते हैं।

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

एक परीक्षण सूट में एक परीक्षण जोड़ना

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

 [UnityTest] public IEnumerator GameOverOccursOnAsteroidCollision() { GameObject gameGameObject = MonoBehaviour.Instantiate(Resources.Load<GameObject>("Prefabs/Game")); Game game = gameGameObject.GetComponent<Game>(); GameObject asteroid = game.GetSpawner().SpawnAsteroid(); //1 asteroid.transform.position = game.GetShip().transform.position; //2 yield return new WaitForSeconds(0.1f); //3 Assert.True(game.isGameOver); Object.Destroy(game.gameObject); }

हमने पिछले परीक्षण में इस कोड को पहले ही देखा था, लेकिन कुछ अंतर हैं:

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

टेस्ट रनर विंडो पर लौटें और आप देखेंगे कि वहां एक नई यूनिट टेस्ट दिखाई दी है।

इस बार हम इसे पूरे टेस्ट सूट के बजाय चलाएंगे। GameOverOccursOnAsteroidCollision पर क्लिक करें, और फिर रन चयनित बटन पर।

और वोइला, हमने एक और परीक्षा पास की।

ट्यूनिंग और विनाश के चरणों

आपने देखा होगा कि हमारे दो परीक्षणों में बार-बार कोड होता है: जहां गेम ऑब्जेक्ट बनाया जाता है और जहां गेम स्क्रिप्ट का लिंक सेट किया जाता है:

 GameObject gameGameObject = MonoBehaviour.Instantiate(Resources.Load<GameObject>("Prefabs/Game")); game = gameGameObject.GetComponent<Game>();

आप यह भी देखेंगे कि गेम ऑब्जेक्ट के विनाश में एक दोहराव है:

 Object.Destroy(game.gameObject);

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

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

यह सेटअप को स्थानांतरित करके और विशेष तरीकों से कोड को फाड़ने के द्वारा हमारे जीवन को सरल बनाने का समय है। कोड संपादक खोलें और पहले [UnityTest] विशेषता के ठीक पहले TestSuite फ़ाइल की शुरुआत में निम्नलिखित कोड जोड़ें:

 [SetUp] public void Setup() { GameObject gameGameObject = MonoBehaviour.Instantiate(Resources.Load<GameObject>("Prefabs/Game")); game = gameGameObject.GetComponent<Game>(); }

SetUp विशेषता इंगित करती है कि प्रत्येक परीक्षण के SetUp से पहले इस पद्धति को कहा जाता है।

फिर निम्न विधि जोड़ें और फ़ाइल को सहेजें:

 [TearDown] public void Teardown() { Object.Destroy(game.gameObject); }

TearDown विशेषता इंगित करती है कि प्रत्येक परीक्षण के TearDown बाद इस विधि को कहा जाता है।

सेटअप और विनाश कोड तैयार करने के बाद, इन विधियों में मौजूद कोड की पंक्तियों को हटा दें और उन्हें कॉल के साथ संगत विधियों में बदल दें। उसके बाद, कोड इस तरह दिखेगा:

 public class TestSuite { private Game game; [SetUp] public void Setup() { GameObject gameGameObject = MonoBehaviour.Instantiate(Resources.Load<GameObject>("Prefabs/Game")); game = gameGameObject.GetComponent<Game>(); } [TearDown] public void Teardown() { Object.Destroy(game.gameObject); } [UnityTest] public IEnumerator AsteroidsMoveDown() { GameObject asteroid = game.GetSpawner().SpawnAsteroid(); float initialYPos = asteroid.transform.position.y; yield return new WaitForSeconds(0.1f); Assert.Less(asteroid.transform.position.y, initialYPos); } [UnityTest] public IEnumerator GameOverOccursOnAsteroidCollision() { GameObject asteroid = game.GetSpawner().SpawnAsteroid(); asteroid.transform.position = game.GetShip().transform.position; yield return new WaitForSeconds(0.1f); Assert.True(game.isGameOver); } }

परीक्षण गेम ओवर और लेजर शूटिंग

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

 [UnityTest] public IEnumerator NewGameRestartsGame() { //1 game.isGameOver = true; game.NewGame(); //2 Assert.False(game.isGameOver); yield return null; }

यह आपको पहले से ही जाना जाना चाहिए, लेकिन निम्नलिखित उल्लेख के लायक है:

कोड का यह टुकड़ा gameOver बूलियन ध्वज के सत्य होने के लिए इस परीक्षण को तैयार करता है। NewGame पद्धति को कॉल करते NewGame , इसे फिर से ध्वज को false सेट करना होगा।
यहाँ हम तर्क देते हैं कि बूल isGameOver false , जो एक नए गेम को लागू करते समय सही होना चाहिए।

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

लेजर बीम स्टेटमेंट

अगला परीक्षण यह परीक्षण जोड़ना है कि जहाज द्वारा निकाल दिया गया लेजर बीम ऊपर उड़ रहा है (पहली इकाई परीक्षण के समान)। संपादक में TestSuite फ़ाइल खोलें। निम्न विधि जोड़ें और फ़ाइल को सहेजें:

 [UnityTest] public IEnumerator LaserMovesUp() { // 1 GameObject laser = game.GetShip().SpawnLaser(); // 2 float initialYPos = laser.transform.position.y; yield return new WaitForSeconds(0.1f); // 3 Assert.Greater(laser.transform.position.y, initialYPos); }

यहाँ है कि यह कोड क्या करता है:

जहाज से निकलने वाली उत्पन्न लेजर बीम का लिंक मिलता है।
प्रारंभिक स्थिति दर्ज की जाती है ताकि हम यह सत्यापित कर सकें कि यह बढ़ रहा है।
यह कथन AsteroidsMoveDown इकाई परीक्षण के बयान के अनुरूप है, केवल अब हम दावा करते हैं कि मूल्य अधिक है (यानी, लेजर ऊपर बढ़ता है)।

फ़ाइल को सहेजें और टेस्ट रनर पर लौटें। LaserMovesUp परीक्षण चलाएं और देखें कि यह कैसे गुजरता है:

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

सत्यापित करना कि लेजर क्षुद्रग्रहों को नष्ट कर देता है

अगला, हम यह सुनिश्चित करेंगे कि हिट होने पर, लेजर क्षुद्रग्रह को नष्ट कर देता है। संपादक खोलें और TestSuite के अंत में निम्नलिखित परीक्षण जोड़ें , और फिर फ़ाइल सहेजें:

 [UnityTest] public IEnumerator LaserDestroysAsteroid() { // 1 GameObject asteroid = game.GetSpawner().SpawnAsteroid(); asteroid.transform.position = Vector3.zero; GameObject laser = game.GetShip().SpawnLaser(); laser.transform.position = Vector3.zero; yield return new WaitForSeconds(0.1f); // 2 UnityEngine.Assertions.Assert.IsNull(asteroid); }

यहां बताया गया है कि यह कैसे काम करता है:

हम एक क्षुद्रग्रह और एक लेजर बीम बनाते हैं, और टकराव को ट्रिगर करने के लिए उन्हें एक ही स्थिति प्रदान करते हैं।
यह एक महत्वपूर्ण अंतर के साथ एक विशेष परीक्षण है। देखें कि हम इस परीक्षण के लिए स्पष्ट रूप से UnityEngine.Assertions का उपयोग करते हैं ? ऐसा इसलिए है क्योंकि एकता में एक विशेष अशक्त वर्ग है जो "नियमित" अशक्त वर्ग से अलग है। नल के लिए यूनिटी चेक में NUnit फ्रेमवर्क स्टेटमेंट Assert.IsNull() काम नहीं करेगा । एकता में अशक्तता की जाँच करते समय, आपको स्पष्ट रूप से यूनिटी एंजाइन का उपयोग करना चाहिए।

टेस्ट रनर पर लौटें और एक नया टेस्ट चलाएं। आप एक हरे रंग का आइकन हमें प्रसन्न करते देखेंगे।

परीक्षण करना या न करना - यही प्रश्न है

इकाई परीक्षणों से चिपके रहने का निर्णय एक आसान निर्णय नहीं है और इसे हल्के में नहीं लिया जाना चाहिए। हालांकि, परीक्षणों का लाभ प्रयास के लायक है। यहां तक कि एक विकास कार्यप्रणाली, कहा जाता है परीक्षण चालित विकास (टेस्ट प्रेरित विकास, TDD)।

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

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

: — , . , . «» , , . , . , . , , .

परीक्षण एक बड़ा निवेश हो सकता है, इसलिए अपनी परियोजना में इकाई परीक्षण जोड़ने के फायदे और नुकसान पर विचार करें:

यूनिट परीक्षण लाभ

यूनिट परीक्षण के कई महत्वपूर्ण फायदे हैं, जिनमें निम्न शामिल हैं:

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

यूनिट परीक्षण नुकसान

हालाँकि, आपके पास इकाई परीक्षण के लिए समय या बजट नहीं हो सकता है। यहाँ इस पर विचार करने के अपने नुकसान हैं:

परीक्षण लिखने में कोड की तुलना में अधिक समय लग सकता है।
.
.
, .
, -.
( ), .
- .
UI .
.
.

,

अंतिम परीक्षा लिखने का समय आ गया है। कोड संपादक खोलें, नीचे कोड को TestSuite फ़ाइल के अंत में जोड़ें और इसे सहेजें:

 [UnityTest] public IEnumerator DestroyedAsteroidRaisesScore() { // 1 GameObject asteroid = game.GetSpawner().SpawnAsteroid(); asteroid.transform.position = Vector3.zero; GameObject laser = game.GetShip().SpawnLaser(); laser.transform.position = Vector3.zero; yield return new WaitForSeconds(0.1f); // 2 Assert.AreEqual(game.score, 1); }

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

हम एक क्षुद्रग्रह और एक लेजर बीम बनाते हैं, और उन्हें एक स्थिति में रखते हैं। इसके कारण, एक टकराव पैदा होता है जो स्कोर में वृद्धि को ट्रिगर करता है।
यह कथन कि game.score अब 1 है (और 0 नहीं, जैसा कि यह शुरुआत में था)।

कोड को सहेजें और इस अंतिम परीक्षण को चलाने के लिए टेस्ट रनर पर वापस जाएं और देखें कि क्या यह गेम चलाता है:

बहुत खूब! सभी टेस्ट पास कर लिए।

आगे कहाँ जाना है?

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

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

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

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

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

लिए NUnit प्रलेखन भी पढ़ें ।

और अपने विचारों और सवालों को मंचों पर साझा करने के लिए स्वतंत्र महसूस करें।

सफल परीक्षण!

एकता में इकाई परीक्षण का परिचय