Nunit: पकड़ने का दावा 3.10 के बाद से परीक्षण विफल रहता है।

आपका परीक्षण दो प्रस्तावों का परीक्षण कर रहा है कि NUnit कैसे काम करता है:

1. यह कि सभी अभिकथन विफलताएँ एक AssertionException को फेंक देती हैं।
2. अपवाद को पकड़ना त्रुटि को रिपोर्ट होने से रोकता है।

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

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

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

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

मैं उत्सुक हूं कि क्या यह परिवर्तन जानबूझकर किया गया था, उस स्थिति में मुझे पता है कि मुझे चीजों को बदलना होगा।

Warn.If ठीक काम करता है ... __ छोड़कर__ टेस्ट एक्सप्लोरर के तहत। समस्या यह है कि टेस्ट एक्सप्लोरर पास और फेल के बारे में जानता है, लेकिन चेतावनी नहीं। हमें अपने चेतावनी परिणामों का अनुवाद किसी ऐसी चीज़ में करना था जिसे वे तब तक समझ सकें जब तक कि वे चेतावनी परिणाम स्थिति को लागू नहीं कर देते। एफडब्ल्यूआईडब्ल्यू हमें अपने अनिर्णायक परिणाम राज्य के साथ एक समान समस्या है।

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

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

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

@svanimpelen क्या आपने अपने परतदार परीक्षणों के लिए Retry विशेषता का उपयोग करने का प्रयास किया है? यह आपको उन्हें पास करने के लिए उन्हें कई बार चलाने की अनुमति देगा।

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

हमारे कई तरीकों का दस्तावेज है कि एपीआई विफलता पर AssertionException फेंकता है:

https://github.com/nunit/nunit/blob/d03e93c8f25170a8ff48e80863a3fe6fd294613a/src/NUnitFramework/framework/Assert.That.cs#L40 -L43

क्या यह दस्तावेज़ीकरण, साथ ही NUnit के लंबे समय से व्यवहार, 3.10 में एक महत्वपूर्ण परिवर्तन नहीं है?
जब तक मुझे कुछ याद नहीं आ रहा है, हमें कम से कम अब-गलत दस्तावेज़ों को हटा देना चाहिए।

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

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

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

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

मुझे XML दस्तावेज़ों से AssertionException के सभी संदर्भों को हटाने और लोगों को AssertionException का उपयोग न करने की चेतावनी देने वाला विकी पेज बनाने का विचार पसंद है।

यदि AssertionException को पकड़ना हमेशा एक बग होता है, तो क्या हम उस प्रकार को आंतरिक बनाने पर विचार कर सकते हैं?

@ जेएनएम2.

मैं आपके साथ XML दस्तावेज़ों के महत्व पर सहमत हूँ लेकिन तथ्य यह है कि वे दस्तावेज़ __not__ हैं जिस तरह से हम अब तक अनुबंध के हिस्से को संप्रेषित करते रहे हैं। मुझे वास्तव में लगता है कि आप इसका सुझाव देने वाले पहले व्यक्ति हो सकते हैं और मुझे लगता है कि यह एक अच्छा विचार है।

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

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

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

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

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

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

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

क्या हमें डॉक्स फिक्स को ट्रैक करने के लिए एक नया मुद्दा शुरू करना चाहिए?

नया क्यों?

शीर्षक कुछ ऐसा दिखता है जिसे हम ठीक करने के बजाय उत्तर दिए गए प्रश्न के रूप में बंद कर देंगे। क्या हम आम तौर पर शीर्षक बदलते हैं और दस्तावेज़ परिवर्तन को ट्रैक करने के लिए इस समस्या का उपयोग करते हैं?

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

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

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

मैं वर्तमान में उसी समस्या का सामना कर रहा हूं क्योंकि 3.10 में अपग्रेड करने के बाद मेरे परीक्षण विफल होने लगे। अब यहाँ मेरी समस्या है:
मेरे पास कस्टम परीक्षण दावा विधियां हैं। वे आंतरिक रूप से NUnit.Assert कहते हैं। मैं इन अभिकथन विधियों का परीक्षण यह सुनिश्चित करने के लिए करता हूं कि जब मैं उनसे असफल होने की अपेक्षा करता हूं तो वे वास्तव में विफल हो जाते हैं।
वर्तमान में मेरे परीक्षण AssertionException को यह सत्यापित करने के लिए पकड़ते हैं कि कस्टम अभिकथन विधि के कारण परीक्षण विफल हो जाएगा, लेकिन उन सभी परीक्षणों को अपग्रेड करने के बाद उपरोक्त कारणों से विफल होना शुरू हो जाता है।

3.10 के साथ परीक्षण करने का अनुशंसित तरीका क्या है?

धन्यवाद।

सबसे आसान तरीका Assert.Throws का उपयोग अपवाद को पकड़ने के लिए स्वयं करने के बजाय करना है। Assert.Throws NUnit इंटर्नल को समझता है और यह सुनिश्चित करता है कि विफलता की सूचना न दी जाए।

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

तो मुझे लगता है कि मैं उचित एनयूनीट दावे नहीं फेंक सकता, या उपयोगकर्ता के लिए कठिन कार्यों को निष्पादित करके त्वरित परीक्षण विकास में सहायता करने के उद्देश्य से पुस्तकालय कोड में Assert.That का उपयोग नहीं कर सकता?

मैं पूर्व के बयानों से सहमत हूं कि यदि उपयोगकर्ता द्वारा अपवाद का उपभोग नहीं किया जा सकता है, तो यह उपयोगकर्ता को फेंकने के लिए उपलब्ध नहीं होना चाहिए; हालांकि यह उस मुद्दे को हल नहीं करता है जहां मेरे पास उपभोक्ता के लिए Assert.That कोड है और यह साबित करने के लिए परीक्षण करता है कि वे थ्रो फेल हो जाते हैं क्योंकि कोड वह करता है जो इसे माना जाता है: नूनिट अभिकथन के साथ विफल।

शायद हमें कुछ परिणाम एपीआई का उत्पादन करना चाहिए?

@fluffynuts अगर मैं आपको सही ढंग से समझता हूं, तो catch क्लॉज आपके टेस्ट कोड में है, न कि आपके यूजर लाइब्रेरी के कोड में। (यदि यह उपयोगकर्ता पुस्तकालय में भी है, तो हम इसके बारे में बात कर सकते हैं, लेकिन मुद्दे थोड़े अलग हैं।)

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

रक्षा की पहली पंक्ति Assert.Throws । परीक्षण विफलता व्यवहार के अधिकांश मामलों में, आप try / catch(AssertionException) को सीधे Assert.Throws<AssertionException> हैं। आंतरिक रूप से Assert.Throws एक अलग TestExecutionContext Assert.Throws बनाता है ताकि आपके वास्तविक परीक्षा परिणाम उस त्रुटि से प्रदूषित न हों जिसका आप परीक्षण कर रहे हैं।

कुछ मामलों में, आपको अपना अलग संदर्भ बनाने की आवश्यकता हो सकती है। आप Assert.Throws के कोड की जांच करके देख सकते हैं कि यह कैसे करना है।

हालाँकि, NUnit के स्वयं के अधिकांश विफलता परीक्षण वास्तव में एक अलग दृष्टिकोण का उपयोग करते हैं। हमारे पास परीक्षणों के साथ एक अलग असेंबली है जो हमारे अपने परीक्षण कार्यक्रमों द्वारा चलाए जाते हैं। हम परिणाम पर कब्जा करते हैं और फिर इसकी जांच कर सकते हैं। यह अधिक काम है लेकिन हमारे परीक्षणों में एनयूनीट के बारे में बहुत अधिक कार्यान्वयन विवरण डालने से बचाता है। ऐसा करने वाली अधिकांश विधियां हमारे परीक्षण उपयोगिताओं असेंबली में पाई जाती हैं। मुझे लगता है कि @ jnm2 इसका जिक्र कर रहा है।

इसके बारे में अधिक सहायता के लिए आपके कोई भी प्रश्न पोस्ट करें या मुझसे ऑफ़लाइन संपर्क करें।

जानकारी के लिए धन्यवाद। हां, परीक्षण कोड के भीतर अभिकथन पकड़े जाते हैं। Assert.Throws सामान्य रूप से चाल चलेंगे, लेकिन प्रश्न में विशिष्ट परीक्षण पुस्तकालय कोड को "बहुत कम" के साथ चलाता है जो एक डेटाटाइम मान का परीक्षण करने के लिए अनुमत एक डेल्टा है जिसे डाला जाना चाहिए और उन्हें डेटाबेस से पुनर्प्राप्त किया जाना चाहिए। ज्यादातर समय, स्थानीय डीबी में इसके लिए अनुभव किया गया बहाव 1ms है, लेकिन कभी-कभी यह उच्च हो जाता है - और इस परीक्षण का उद्देश्य केवल यह दावा करना है कि "कभी-कभी" होता है। इसलिए, फिलहाल, मैं कोड को 4 समानांतर थ्रेड्स में 10 बार चलाता हूं और कम से कम एक विफलता की अपेक्षा करता हूं। Assert.Throws, दुर्भाग्य से, इस मामले के लिए बहुत नियतात्मक है, इसलिए मुझे या तो नूनिट अपवादों (या लाइब्रेरी कोड के भीतर Assert) का उपयोग बंद करने की आवश्यकता है, या मुझे उस फू को सीखने की आवश्यकता है जिसका आप लोग उपयोग करते हैं। मैं किसी भी संकेत की सराहना करता हूं - यदि आप चाहें तो ऑफ़लाइन हो सकता है।

हे, मुझे अभी एहसास हुआ कि मेरे AsyncVoidVerificationScope के लिए संदेश पंप परीक्षण विफलताएं जो मैं देख रहा हूं, ठीक वही समस्या है जैसे @fluffynuts में है। असल में एनयूनीट 3.10 अपग्रेड के कारण, मेरी [असेंबली: पुनर्स्थापना सिंक्रनाइज़ेशन कॉन्टेक्स्ट] ITestAction नहीं। एक साथ कई काम करते हुए उन्हें अनदेखा करने के लिए मेरी सेवा करता है। :डी

वैसे भी, ऐसा लगता है कि मैं अपने प्रतिनिधि आमंत्रण को using (new TestExecutionContext.IsolatedContext()) में लपेटना चाहता हूं जैसे Assert.Throws करता है।

Assert.Throws और Assert.ThrowsAsync हालांकि एसिंक्स प्रतिनिधियों को आमंत्रित करने से पहले अलग-अलग संदर्भ स्थापित नहीं करते हैं। ऐसा क्यों है?

@fluffynuts बहुत समय पहले, जब मैंने पहली बार Assert.Catch लिखा था, तो उसने केवल कोई अपवाद पकड़ा और यदि कोई अपवाद नहीं फेंका गया तो कोई त्रुटि उत्पन्न नहीं हुई। दुर्भाग्य से, यह बदल गया है और अब हमारे पास Assert.Throws बराबर "तटस्थ" नहीं है। हालाँकि, आप एक लिख सकते हैं। यहां Assert.Throws में कोड के आधार पर एक परीक्षण न किया गया संस्करण है। यह केवल सिंक्रोनस कोड को संभालता है लेकिन आप Assert.Throws से अतिरिक्त कोड का उपयोग करके इसे आसानी से एसिंक्स के लिए बढ़ा सकते हैं।

```सी#
सार्वजनिक स्थैतिक शून्य अपवाद SafelyCatchAnNUnitException (TestDelegate कोड)
{
अपवाद पकड़ा अपवाद = शून्य;

using (new TestExecutionContext.IsolatedContext())
{
    try
    {
        code();
    }
    catch (Exception ex)
    {
        caughtException = ex;
    }

    return caughtException;
}

}
```

विधि फेंके गए किसी भी अपवाद को वापस कर देगी, NUnit के मुखर तरीकों द्वारा छोड़ी गई त्रुटि के किसी भी अवशेष को साफ कर देगी। यदि कोई अपवाद नहीं फेंका जाता है, तो यह अशक्त हो जाता है।

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