Nunit: समानांतर में एक स्थिरता के भीतर परीक्षण विधियों को चलाएँ

अपडेट: यह टिप्पणी और निम्नलिखित दोनों एक व्यक्ति के जवाब में थे, जिन्होंने स्पष्ट रूप से अपनी टिप्पणियों को हटा दिया था। मैं अपने जवाब छोड़ रहा हूँ।

वैसे यह कल्पना में है और पोस्ट-3.0 कार्यान्वयन के लिए निर्धारित है। अगर यह इतना आसान होता, तो हम शायद कर लेते। सुनिश्चित नहीं हैं कि आप mbunit के साथ क्या संबंध देखते हैं। तथ्य यह है कि उनके पास यह हमारी मदद नहीं करता है।

यह थोड़ा थकाऊ हो रहा है। कुछ बिंदु, पहले ही कहा जा चुका है लेकिन जाहिर तौर पर छूट गया है ...

1. आप जो मांग रहे हैं उसे लागू करने की योजना है।
2. हमने एक टीम के रूप में इसे एक निश्चित बिंदु पर शेड्यूल करने का फैसला किया।
3. जब इसे शेड्यूल किया जाता है तो यह मुख्य रूप से अन्य सुविधाओं की तुलना में सुविधा के मूल्य के हमारे आकलन से संबंधित होता है।
4. NUnit टीम में कई लोग हैं जो इस सुविधा को लागू कर सकते हैं।
5. वे प्राथमिकताओं के आधार पर इसे अपने दिमाग से लागू करने में सक्षम होंगे और इसे कहीं से भी कॉपी करने की आवश्यकता नहीं होगी।

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

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

रिवर्स इंजीनियरिंग के लिए, यहाँ वास्तव में कोई फायदा नहीं है। NUnit काम करता है
एमबीयूनीट की तुलना में पूरी तरह से अलग। हम नियत समय में इस मुद्दे पर पहुंचेंगे,
लेकिन सावधानी से संपर्क कर रहे हैं क्योंकि अन्य समान मुद्दे बदल सकते हैं
जिस तरह से हमें इसे या यहां तक ​​कि संघर्ष को लागू करने की आवश्यकता है।
अप्रैल 19, 2015 2:45 पूर्वाह्न पर, "चार्लीपूल" नोटिफिकेशन @github.com ने लिखा:

यह थोड़ा थकाऊ हो रहा है। कुछ बिंदु, पहले ही कहा जा चुका है लेकिन
जाहिरा तौर पर चूक गए ...

1.

आप जो मांग रहे हैं उसे लागू करने की योजना है।
2.

हमने एक टीम के रूप में इसे एक निश्चित बिंदु पर शेड्यूल करने का फैसला किया।
3.

जब यह निर्धारित किया जाता है तो इसका मुख्य रूप से हमारे मूल्यांकन के साथ क्या करना है
अन्य सुविधाओं की तुलना में सुविधा का मूल्य।
4.

NUnit टीम में कई लोग हैं जो इसे लागू कर सकते हैं
विशेषता।
5.

वे प्राथमिकताओं के आधार पर इसे लागू करने में सक्षम होंगे
उनके सिर और इसे कहीं से भी कॉपी करने की आवश्यकता नहीं होगी।

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

-
इस ईमेल का सीधे उत्तर दें या इसे GitHub पर देखें
https://github.com/nunit/nunit/issues/164#issuecomment -94244650।

मेरी तुलना में बहुत अधिक चतुर टिप्पणी!

समानांतर निष्पादन की दुनिया में हमारी वर्तमान प्राथमिकताएं हैं:

1. समानांतर प्रक्रिया निष्पादन
2. बहिष्करण समूह
3. समानांतर विधि (एक स्थिरता में) निष्पादन।

ऐसा लगता है कि यह उपयोगकर्ताओं के लिए सबसे बड़ी उपयोगिता के क्रम का प्रतिनिधित्व करता है।

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

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

मैं इसे किसी भी समय एक विकल्प बनाने का पक्ष लेता हूं, लेकिन मुझे यकीन नहीं है कि यह एक रन विकल्प है या एक स्थिरता-दर-स्थिरता (जिम्मेदार) विकल्प या दोनों है।

नमस्ते!
इस सुविधा को NUnit के अगले संस्करण में जोड़ना बहुत अच्छा होगा, क्योंकि यह एकमात्र ऐसी चीज़ है जो मुझे NUnit में जाने से रोकती है। क्या यह सुविधा अभी भी 3.4 के लिए नियोजित है?

@julianhaslinger NUnit 3.4 महीने के अंत में बाहर हो जाएगा, इसलिए नहीं, इस सुविधा को शामिल नहीं किया जाएगा।

FYI करें, यह मुद्दा 3.4 के बजाय हमारे बैकलॉग मील के पत्थर (या छद्म मील का पत्थर) में है क्योंकि हम प्रत्येक क्रमांकित मील के पत्थर में केवल एक छोटी संख्या को परिभाषित करने वाले मुद्दों को पहले से जोड़ने की प्रथा का पालन कर रहे हैं।

अगला मील का पत्थर, 3.6, 3 और महीनों में कम होने वाला है, जो शायद आपको हतोत्साहित करने वाला लगता है। :-( हालांकि, यदि आप इस मुद्दे को मास्टर में विलय होते हुए देखते हैं, तो आप हमारे MyGet फ़ीड से पहले की एक बूंद प्राप्त कर सकेंगे।

@julianhaslinger यह 3.4 में नहीं होगा जो शायद एक हफ्ते में खत्म हो गया है, लेकिन यह वह है जिसे मैं जल्द ही देखना चाहता हूं, इसलिए आपका वोट मदद करता है: +1:

एक तरफ, आप किस परीक्षण ढांचे का उपयोग कर रहे हैं जो समांतर विधि निष्पादन का समर्थन करता है? मैंने सोचा कि एक्सयूनीट ने केवल कक्षा स्तर के समानांतर परीक्षण चलाने की अनुमति दी है। क्या मैं गलत हूँ? मैं XUnit का अधिक उपयोग नहीं करता: मुस्कान:

@CharliePoole उत्तर के लिए धन्यवाद! ठीक है, यह थोड़ा हतोत्साहित करने वाला लगता है, हालाँकि। हालांकि, मैं अगली रिलीज (या पहले की बूंदों) की प्रतीक्षा करूंगा। कृपया (अभी भी) अगले संस्करण (3.6) में इस सुविधा पर विचार करें।

@rprouse मैं अभी गैलियो का उपयोग कर रहा हूं। परियोजना काफी हद तक मर गई और अब मैं एनयूनीट पर स्विच करने जा रहा हूं।

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

@CharliePoole बिल्कुल, हमारी वास्तविक समस्या परीक्षण मामलों का चलने का समय है। हम अपने स्वचालित/प्रतिगमन परीक्षणों (सेलेनियम/वेबड्राइवर समेत) के लिए एनयूनीट का उपयोग करना चाहते हैं और चूंकि हमारे कुछ परीक्षण वर्गों में 200+ परीक्षण मामले हैं, इसलिए वर्तमान में एनयूनीट के साथ पूरे परीक्षण सूट को निष्पादित करना एक वास्तविक दर्द है।

तुलना (हमारे प्रतिगमन परीक्षणों के एक छोटे परीक्षण सेट के भीतर) ने दिखाया है कि एक संभावित NUnit समाधान लगभग 1,5 घंटों में निष्पादित किया जाएगा जबकि वर्तमान MBunit समाधान 0,5 घंटों (उसी परीक्षण सेट) में निष्पादित किया जाएगा।

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

@julianhaslinger - बस पुष्टि करने के लिए, क्या आप सुनिश्चित हैं कि आप समय चल रहे हैं CPU बाध्य है, और स्मृति बाध्य नहीं है?

हमने उसी समस्या का अनुभव किया जब हमने पहली बार NUnit 3 पर स्विच करने का प्रयास किया - रन टाइम काफी लंबा हो गया। यह उपलब्ध मेमोरी को अधिकतम करने के कारण NUnit के कारण था - वर्तमान संस्करण के साथ एक समस्या है जो परीक्षण चलाने के पूरा होने तक सभी परीक्षण वस्तुओं पर रहती है। हम वर्तमान में आंतरिक रूप से एक पैच संस्करण चला रहे हैं - मैं 3.4 के लिए एक पीआर प्राप्त करना चाहता था, लेकिन मुझे यकीन नहीं था कि मेरे पास इस समय समय होगा। :-(

क्षमा करें अगर यह नहीं है, लेकिन सोचा कि यह उल्लेखनीय था, क्योंकि सेलेनियम स्मृति के उचित हिस्से का उपयोग कर सकता है। :-)

@ChrisMaddock इनपुट के लिए धन्यवाद! :+1: हम इसे जल्द ही देखेंगे और फिर मैं आपके पास वापस आऊंगा।

@ChrisMaddock मुझे 3.4 में आपकी मेमोरी फिक्स देखना अच्छा लगेगा। यदि आप एक पीआर लगाना चाहते हैं, तो हम इसे साफ करने में आपकी मदद कर सकते हैं यदि यह अभी तक उत्पादन के लिए तैयार नहीं है: +1:

@rprouse - यह प्रारंभिक प्रतिबद्धता https://github.com/nunit/nunit/pull/1367/commits/5f98ae51025f7af8244abd4367d1f47260874dfc पीआर #1367 में हमारे लिए एक पैच v3.0.1 में चीजों को ठीक से मुक्त करता है।

आप पीआर में देखेंगे कि विलय से पहले इसे OneTimeTearDown में स्थानांतरित कर दिया गया था - मुझे अभी तक पता नहीं है कि क्या उस कदम के कारण यह v3.2.1 में काम नहीं कर रहा था, या यदि कोई अन्य परिवर्तन काम कर रहा था जिसने पुन: प्रस्तुत किया प्रतिधारण - हो सकता है कि मैंने आगे बढ़ने के बाद पुन: परीक्षण नहीं किया हो।

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

@ChrisMadock मैंने रिग्रेशन टेस्ट रन के दौरान मेमोरी खपत पर एक नज़र

@julianhaslinger ने जो कहा, उसे जोड़ने के लिए, मैंने सेलेनियम परीक्षणों के साथ NUnit का उपयोग करने में बिल्कुल वही समस्या देखी है। मुझे एक कस्टम रैपर लिखना था जो एक एकल परीक्षण के खिलाफ nunit-console.exe के अलग-अलग उदाहरण चलाता है जैसा कि एक पास असेंबली से स्क्रैप किया गया है ताकि मैं अभी के लिए समानांतर परीक्षण चला सकूं। हालांकि यह आदर्श नहीं है क्योंकि इसके परिणामस्वरूप एक .xml आउटपुट के बजाय कई .xml आउटपुट फाइलें (प्रत्येक टेस्ट रन के लिए एक) उत्पन्न होती हैं और इसका मतलब यह भी है कि मैं _OneTimeSetUp_ और टियरडाउन विधियों का उपयोग नहीं कर सकता और इसके बजाय बाहरी सेमाफोर पर भरोसा करना चाहिए और पर्यावरण चर निष्पादन प्रवाह को नियंत्रित करने के लिए जहां मैं केवल एक बार चीजों को चलाना चाहता हूं। मैं लंबे समय (वर्षों) के लिए एनयूनीट में समानांतर निष्पादन के वादे का पालन कर रहा हूं और 3.0 में इस सुविधा को कैसे शुरू किया गया था, इस पर बहुत निराश था (केवल आंशिक रूप से समर्थित और मुद्दों में कुछ वास्तविक खुदाई की आवश्यकता थी और नोट्स जारी करना पता लगाएं कि सब कुछ वास्तव में समर्थित नहीं था)। मैंने यहां तक ​​जांच की कि इसे आगे बढ़ाने में क्या शामिल होगा, लेकिन दुर्भाग्य से ऐसा प्रतीत होता है कि एनयूनीट का डिजाइन परीक्षण विधि स्तर पर समानांतर निष्पादन के कार्यान्वयन के खिलाफ काम कर रहा है, मुझे नहीं पता कि आप वास्तव में कैसे पसंद करेंगे गैर-थ्रेडसेफ कोड की क्षमता को संभालने के लिए (यानी इसे एनयूनीट का उपयोग करने वाले व्यक्ति को समानांतर में छोड़ दिया जाना चाहिए ताकि यह सुनिश्चित किया जा सके कि सभी परीक्षण विधियां किसी भी बाहरी को थ्रेडसेफ तरीके से सही तरीके से संदर्भित करती हैं या एनयूनीट स्वयं अपने डोमेन में प्रत्येक विधि के निष्पादन को संभालती है जबकि किसी भी तरह अभी भी केवल एक बार केवल एक बार सेटअप और टियरडाउन प्रकार के तरीकों को चलाने की कोशिश कर रहा है) और चूंकि मेरे पास पहले से ही एक वर्कअराउंड है, इसलिए मैं खुद इस सुविधा को लागू करने में समय को सही नहीं ठहरा सकता (जो शायद सबसे अच्छा है क्योंकि मुझे पहले जला दिया गया है जब समानांतर निष्पादन को लागू करने में मदद करने के लिए GitHub पर टीमों के साथ काम करना)। वैसे भी ... जुआ के लिए खेद है ... मैं समझता हूं कि सी # कोड के यूनिट परीक्षण की प्राथमिकता शायद विधि-स्तर समांतरता पर निर्भर नहीं है, लेकिन कृपया यह जान लें कि सेलेनियम-आधारित परीक्षणों के लिए एनयूनीट का उपयोग करने वालों के लिए यह एक बहुत बड़ा सुधार होगा। अग्रिम में धन्यवाद! :मुस्कुराओ:

आपकी टिप्पणियों के लिए आभार। मुझे लगता है कि मैं यहाँ अपने आप पर थोड़ा ध्यान दूँगा ...

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

अपने कामकाज के संबंध में ... क्या आपने अलग परीक्षण असेंबली का उपयोग करने पर विचार किया? NUnit प्रत्येक को समानांतर में एक अलग प्रक्रिया में चलाने में प्रसन्नता होगी। बेशक यह फाइलों जैसी चीजों तक पहुंच को सिंक्रनाइज़ करने की आवश्यकता को समाप्त नहीं करता है।

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

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

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

अनिवार्य रूप से, आप कल्पना कर सकते हैं कि एक असेंबली में 10 परीक्षण हो सकते हैं और
अन्य १०० परीक्षण, लेकिन १० के साथ असेंबली में १० मिनट लगते हैं
प्रत्येक जबकि 100 के साथ बैठक में 1 मिनट का समय लगता है। अगर मुझे
110 समानांतर धागे चलाने में सक्षम एक मशीन है (जो वास्तव में है
हमारे बुनियादी ढांचे के डिजाइन का हिस्सा) तो मुझे उम्मीद है कि परीक्षण समाप्त हो जाएंगे
१० मिनट में, १०० मिनट में नहीं।

उम्मीद है कि यह समझाने में मदद करता है ... क्षमा करें यदि चीजें अभी भी पूरी तरह से स्पष्ट नहीं हैं,
लेकिन समग्र बिंदु यह है कि विधि स्तर समांतरता कुछ ऐसा है जो मैंने किया है
अन्य परीक्षण पुस्तकालयों में गायब देखा गया (उदाहरण के लिए रूबी में prspec) और कब
इसे जोड़कर प्रदर्शन सुधारों का विश्लेषण करना i
पाया कि यह एक बड़ा सकारात्मक बदलाव हो सकता है। निम्नलिखित को एक उदाहरण के रूप में देखें:
https://github.com/bicarbon8/rspec-parallel/wiki/Examples
1 जुलाई 2016 00:45 को, "चार्लीपूल" नोटिफिकेशन @github.com ने लिखा:

आपकी टिप्पणियों के लिए आभार। मुझे लगता है कि मैं यहाँ अपने आप पर थोड़ा ध्यान दूँगा ...

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

अपने कामकाज के संबंध में ... क्या आपने अलग परीक्षण का उपयोग करने पर विचार किया?
असेंबली? NUnit प्रत्येक को समानांतर में एक अलग में चलाने में प्रसन्नता होगी
प्रक्रिया। बेशक यह एक्सेस को सिंक्रनाइज़ करने की आवश्यकता को समाप्त नहीं करता है
फाइलों जैसी चीजें।

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

-
आप इसे प्राप्त कर रहे हैं क्योंकि आपने टिप्पणी की थी।
इस ईमेल का सीधे उत्तर दें, इसे GitHub पर देखें
https://github.com/nunit/nunit/issues/164#issuecomment -229819324, या म्यूट करें
सूत्र
https://github.com/notifications/unsubscribe/ACNsyoczCUV9L7kbF2SHB7lLsyBKlrv9ks5qRFUJgaJpZM4CUZ8r
.

जानकारी के लिए धन्यवाद... विभिन्न दृष्टिकोणों को देखना सहायक होता है।

मेरे 5 सेंट।

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

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

इनपुट के लिए धन्यवाद ... यह एक ऐसा क्षेत्र है जिसे हम अगली रिलीज में संबोधित करने जा रहे हैं, साथ ही यह सुनिश्चित करने के प्रतिस्पर्धी लेकिन पूरक मुद्दे के साथ कि कुछ परीक्षण एक दूसरे के समानांतर नहीं चलते हैं!

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

@CharliePoole बहुत अच्छी खबर है! बहुत - बहुत धन्यवाद!

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

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

@pablomxnl बिल्कुल सहमत। एक कोच या प्रोजेक्ट लीड के रूप में, मैंने हमेशा उस विचार को बहुत कठिन तरीके से आगे बढ़ाया है। हालाँकि, मैंने यहाँ इनमें से कोई भी टोपी नहीं पहनी है। मैं उन उपयोगकर्ताओं के साथ एक सॉफ्टवेयर प्रदाता हूं जो चीजें मांगते हैं। अगर वे वास्तव में गंभीर सामान मांगते हैं, तो मैं सिर्फ ना कहता हूं। लेकिन अगर वे ऐसी चीजें मांगते हैं जो कुछ संदर्भों में उचित हैं, लेकिन अन्य नहीं - यहां तक ​​​​कि सबसे ज्यादा नहीं - तो मैं इस पर विचार करता हूं।

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

वैसे भी, यह जानना हमेशा दिलचस्प होता है कि लोग वास्तव में आपके सॉफ़्टवेयर का उपयोग कैसे करते हैं।

@CharliePoole , कृपया मुझे यह पूछकर गलत न

जबकि मैं भविष्य की भविष्यवाणी करने का दिखावा कर सकता था, यह केवल सितंबर तक आपको संतुष्ट करेगा। :-)

मुझे यह बताकर उत्तर दें कि हम "शेड्यूल" कैसे करते हैं।

हम वर्तमान में (वर्ष की शुरुआत से) एक दृष्टिकोण की कोशिश कर रहे हैं जिसमें प्रति तिमाही एक बार रिलीज हो रही है। जैसे-जैसे हम रिलीज करने में बेहतर होते जाएंगे, हम गति बढ़ा सकते हैं। अंततः, हम निरंतर परिनियोजन करने में सक्षम हो सकते हैं।

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

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

इसलिए, हम जो करते हैं उसका सकारात्मक पक्ष यह है कि हम वस्तुतः गारंटी दे सकते हैं कि रिलीज समय पर आ जाएगी। नकारात्मक पक्ष यह है कि हम आपको यह नहीं बता सकते कि इसमें क्या होगा। :-(

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

क्षमा करें, कोई और निश्चित उत्तर नहीं है लेकिन ऐसा उत्तर अनिवार्य रूप से झूठ होगा!

@CharliePoole क्या इस सुविधा को ध्यान में रखते हुए कोई अपडेट है?

@tomersss हमने अभी तक इस पर काम शुरू नहीं किया है और उम्मीद है कि 3.5 कुछ हफ्तों में बाहर हो जाएंगे, इसलिए अगली रिलीज में इसकी संभावना नहीं होगी। हम इस सुविधा को जल्द ही जोड़ना चाहते हैं, लेकिन हम इस सप्ताह अपने भंडार और कोड आधार को पुनर्गठित करने में काफी व्यस्त हैं। हालांकि इसे उच्च प्राथमिकता के रूप में चिह्नित किया गया है, इसलिए यह हमारे रडार पर है।

@CharliePoole क्या इस मुद्दे पर कोई अपडेट है?

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

ज़ेनहब के गैर-उपयोगकर्ताओं के लिए, आप यह बता पाएंगे कि कोई व्यक्ति इसे कब उठाता है, यह देखकर कि इस मुद्दे को किसे सौंपा गया है।

@CharliePoole @rprouse

नमस्ते!

क्या इस मुद्दे के अनुसार कोई खबर है?
क्या यह अगली रिलीज़ में होगी या यदि यह आगामी मील के पत्थर में से एक में नियोजित है?

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

जल्द ही आपके उत्तर की आशा में

@GitSIPA आप किस परीक्षण ढांचे का उपयोग कर रहे हैं जो आपको समानांतर में परीक्षण विधियों को चलाने की अनुमति देता है?

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

+1, @GitSIPA से सहमत हैं। यह वास्तव में महत्वपूर्ण कार्यक्षमता है

@GitSIPA +1
@rprouse हम mbunit का उपयोग कर रहे हैं, लेकिन यह ढांचा अब समर्थन नहीं कर रहा है। और हमारे पास एमबुनिट के साथ कुछ मुद्दे हैं।

@rprouse हम इस समय इसलिए हमने

मुद्दे #1921 पर @jnm2 ने पूछा, "हमारे बीच क्या खड़ा है और पैरामीटरयुक्त परीक्षण मामले समानांतर में चल रहे हैं? क्या मैं योगदान कर सकता हूं?"

दूसरा प्रश्न पहला: निश्चित रूप से! हमें आपकी मदद पसंद आएगी।

और पहले प्रश्न के लिए:

1. हम "WorkItems" निष्पादित करते हैं, जो वर्तमान में परीक्षणों के लिए एक-से-एक मैप करता है। मुझे लगता है कि हमें एक प्रारंभिक चरण के रूप में अलग-अलग वर्कआइटम के रूप में एक स्थिरता के लिए वनटाइमसेटअप और वनटाइमटियरडाउन का इलाज करने की आवश्यकता है। अंक #1096 इससे संबंधित है।

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

3. उन दो चीजों के साथ, हम मुख्य मुद्दे पर ही काम करना शुरू कर सकते हैं: परीक्षण को उसी थ्रेड पर चलाने के बजाय चलाने के लिए शेड्यूल करना, जिसने स्थिरता के लिए वनटाइमसेटअप किया था।

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

अब तक क्या योजना बनाई गई है?
सीपीयू को संतृप्त करने के लिए समानांतर में पर्याप्त टेस्टकेससोर्स मामलों को चलाने की मेरी ज़रूरत है। मेरे पास कोई सेटअप, टियरडाउन या ऑर्डरिंग आवश्यकताएं नहीं हैं। हालांकि अन्य लोगों को उन पर ध्यान देने की आवश्यकता होगी।

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

संपादित करें: रेस कंडीशन पर टिप्पणी करना। हम पहले से ही अच्छी शुरुआत कर रहे हैं! मैं

मैं एक कहानी दोहराऊंगा जो मुझे हाल ही में बहुत कुछ बतानी है। :मुस्कुराओ:

NUnit पहले परीक्षण लोड करता है (उर्फ पता चलता है, खोज करता है) और फिर धावक के प्रकार के आधार पर उन्हें एक या अधिक बार निष्पादित करता है।

आपके TestCaseSource का उपयोग परीक्षणों को लोड करने में किया जाता है, उन्हें चलाने में नहीं, और हम इसे आपके परीक्षण के भाग के रूप में भी नहीं मानते हैं - हालाँकि आपके पास यह आपके परीक्षण के समान कक्षा में हो सकता है।

IOW, आपके परीक्षण मामले आपके टेस्टकेस स्रोत का "उपयोग" नहीं करते हैं, बल्कि NUnit परीक्षण मामलों को बनाने के लिए स्रोत का उपयोग करता है। बेशक, वे बनाए जाने तक कुछ नहीं कर सकते। सही बात?

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

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

फिक्स्चर में परीक्षणों के समानांतरकरण की अनुमति देने के लिए यह एक दिलचस्प प्रयोग होगा जहां कोई वनटाइम टीयरडाउन नहीं है (मुझे लगता है कि वनटाइमसेटअप ठीक है)। यह आसानी से काम कर सकता है यदि आप उस दृढ़ संकल्प को सही ढंग से कर सकते हैं। हालाँकि, आप जितना सोचेंगे, उससे कहीं अधिक कठिन है, क्योंकि OneTimeTearDown में विरासत में मिली विधियाँ और वैश्विक ActionAttributes दोनों शामिल हो सकते हैं।

@ jnm2 क्या आपके पास पहले से ही इस विशिष्ट मुद्दे से निपटने का मौका है?

@julianhaslinger नहीं। यह मेरे दो और तात्कालिक मुद्दों, 1885 और 1933 के बाद मेरी सूची में है। यदि आप इससे निपटना चाहते हैं, तो और भी बेहतर!

@julianhaslinger चूंकि हम एक दूसरे को नहीं जानते हैं, कृपया मुझे यह कहने के लिए क्षमा करें कि यह कठिन है। सुनिश्चित करें कि आप इस बात में खुदाई करते हैं कि चीजें अभी कैसे की जा रही हैं और क्यों - बाद वाला हमेशा स्पष्ट नहीं होता है मुझे डर है। मेरी टिप्पणी https://github.com/nunit/nunit/issues/164#issuecomment -265267804 पर अलग-अलग पीआर में टूटने के लिए देखें जिसे मैं इसे ठीक करने के लिए देखना चाहता हूं। यदि आप एक सरल दृष्टिकोण के साथ आते हैं, तो इसे कोडिंग करने से पहले इसके बारे में पोस्ट करें, ताकि हम भविष्य की भविष्यवाणी करने में शामिल स्पष्ट YAGNI के खिलाफ भविष्य के विचारों का वजन कर सकें।

@CharliePoole @ jnm2 हाय लोग!

ऐसा नहीं है कि मैं इस लापता विशेषता को लागू करना शुरू करना चाहता था, बल्कि केवल इसकी प्रगति के बारे में जानना चाहता था। जैसा कि मैं आपके उत्तरों (उपरोक्त) से बता सकता हूं, इस विशेष सुविधा अनुरोध के संबंध में कोई प्रगति (?) नहीं हुई है।

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

इसका एक समाधान यह होगा कि प्रत्येक वर्कइटम टेस्ट क्लास के एक नए उदाहरण पर काम करे, लेकिन यह संभवतः जटिल होगा कि फिक्स्चर सेटअप कैसे व्यवहार करता है क्योंकि अब स्थिरता का एक भी उदाहरण नहीं होगा

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

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

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

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

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

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

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

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

उसके लिए मुझे गिनें।

मैं भी!

शनिवार, 14 जनवरी 2017 को सुबह 3:58 बजे, जोसेफ मुसर नोटिफिकेशन @github.com
लिखा था:

>
>
>
>

[छवि: बॉक्सबे] https://www.boxbe.com/overview

स्वचालित सफाई: पिछले 1 ईमेल रखें ([email protected])

नियम संपादित करें
https://www.boxbe.com/popup?url=https%3A%2F%2Fwww.boxbe.com%2Fcleanup%3Fkey%3Dwa43L7bW5j4V5ymh5QXh%252FNXk%252F0KVSSFJSqwHw2yu4No%253D%26token%3DjkWoQ96YyOE%252FHA7PvZA8g%252FOAgpOQMZdIE7ophiWCxqx1y6zZCFJ%252FKSZ2WZELsWD3YQoDEdjwb%252BWo6wGi4xiUEkGngbggedv8iYBxU7zk% 252FJamyOuVtPzie4dhQJXQkQQ%252BtolspNKBzqBxtH6H%252FhqnTQ%253D%253D&tc_serial=28420100882&tc_rand=128339648&utm_source=stf&utm_medium_contenta और

| नियम हटाएं
https://www.boxbe.com/popup?url=https%3A%2F%2Fwww.boxbe.com%2Fcleanup%3Fkey%3Dwa43L7bW5j4V5ymh5QXh%252FNXk%252F0KVSSFJSqwHw2yu4No%253D%26token%3DjkWoQ96YyOE%252FHA7PvZA8g%252FOAgpOQMZdIE7ophiWCxqx1y6zZCFJ%252FKSZ2WZELsWD3YQoDEdjwb%252BWo6wGi4xiUEkGngbggedv8iYBxU7zk% 252FJamyOuVtPzie4dhQJXQkQQ%252BtolspNKBzqBxtH6H%252FhqnTQ%253D%253D&tc_serial=28420100882&tc_rand=128339648&utm_source=stf&utm_num_campaign=AN001&utm_medium_contenta और

| महत्वपूर्ण चिह्नित करें
https://www.boxbe.com/popup?url=https%3A%2F%2Fwww.boxbe.com%2Fcleanup%3Fkey%3Dwa43L7bW5j4V5ymh5QXh%252FNXk%252F0KVSSFJSqwHw2yu4No%253D%26token%3DjkWoQ96YyOE%252FHA7PvZA8g%252FOAgpOQMZdIE7ophiWCxqx1y6zZCFJ%252FKSZ2WZELsWD3YQoDEdjwb%252BWo6wGi4xiUEkGngbggedv8iYBxU7zk% 252FJamyOuVtPzie4dhQJXQkQQ%252BtolspNKBzqBxtH6H%252FhqnTQ%253D%253D%26महत्वपूर्ण%3Dtrue%26emlId%3D54854949581&tc_serial=2842010 और कैंप_एनओ

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

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

फिर भी, मुझे लगता है कि यह कुछ करने का समय है। मैं इसे लेने जा रहा हूँ
पहली तिमाही के लिए, कम से कम कुछ प्रयोग चलाने की हद तक
और संभवत: उन कार्यों के एक समझदार टूटने के साथ आ रहा है जो दूसरे कर सकते हैं
मेरे साथ साथ करो।

उसके लिए मुझे गिनें।

-
आप इसे प्राप्त कर रहे हैं क्योंकि आपने टिप्पणी की थी।
इस ईमेल का सीधे उत्तर दें, इसे GitHub पर देखें
https://github.com/nunit/nunit/issues/164#issuecomment-२७२४८८६५५ , या मूक
सूत्र
https://github.com/notifications/unsubscribe-auth/AAHNVlwVps8pQ93UIwZw6zY7TOyHO0a6ks5rR61EgaJpZM4CUZ8r
.

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

यहाँ बात है: यदि कोई विधि पूरी तरह से गैर-समानांतर है, तो इसका मतलब है कि यह __किसी अन्य विधि__ के साथ समानांतर में नहीं चल सकती है। ओटीओएच, अगर यह केवल इसकी स्थिरता के भीतर गैर-समानांतर है तो यह उसी स्थिरता में __ किसी अन्य विधि के समानांतर नहीं चल सकता है।__

मेरा प्रस्ताव है कि हम इस भेद को इस प्रकार संभालें:

1. यदि एक परीक्षण विधि में कोई समानांतर विशेषता नहीं है, तो इसे उसी थ्रेड पर चलाना चाहिए जिसमें इसकी स्थिरता शामिल है, बशर्ते कोई अन्य विशेषता (जैसे अपार्टमेंट) इसे किसी भिन्न थ्रेड पर चलाने के लिए कॉल न करे

2. यदि इसमें स्वयं के दायरे के साथ समानांतर विशेषता है, या यदि उच्च स्तरीय सूट बच्चों के दायरे को निर्दिष्ट करता है, तो परीक्षण विधि अन्य विधियों के साथ समानांतर में चलती है।

विचार @ नूनिट/कोर-टीम?

ऊपर छोड़ दिया:

1. यदि इसमें किसी के दायरे के साथ समानांतर विशेषता नहीं है, तो यह गैर-समानांतर कतार पर चलता है।

@CharliePoole - आपके तीन बिंदु समझ में आते हैं, हालांकि मैं इस बात पर स्पष्ट नहीं हूं कि विकल्प क्या होगा कि आप सुझाव दे रहे हैं कि हम ऐसा नहीं करते हैं। क्या आप स्पष्ट कर सकते हैं?

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

पीआर #2011 इस सुविधा को लागू करने की दिशा में कुछ प्रारंभिक कदम उठाता है लेकिन इसमें एक #define होता है जो परीक्षण मामलों को उनके युक्त स्थिरता के धागे पर चलाने के लिए मजबूर करता है। यह टिप्पणी उस सीमा को दूर करने के लिए मेरे विचार से जो कुछ करने की आवश्यकता है उसका दस्तावेजीकरण करती है।

वर्तमान में, एक फ़िक्स्चर का OneTimeTearDown उस थ्रेड पर चलता है जिसका उपयोग निष्पादित अंतिम परीक्षण केस को समाप्त करने के लिए किया गया था। यदि परीक्षण मामले समानांतर में चलते हैं, तो हम यह अनुमान नहीं लगा सकते कि कौन सा परीक्षण मामला होगा। यह स्थिरता के लिए आवश्यक विशेषताओं से भिन्न विशेषताओं वाला एक धागा हो सकता है। उदाहरण के लिए, यदि अंतिम परीक्षण समाप्त करने के लिए STA में चल रहा है, तो वही OneTimeTearDown को चलाने के लिए उपयोग किया जाएगा, भले ही OneTimeSetUp MTA में चला हो। कई मामलों में, इससे कोई समस्या नहीं हो सकती है लेकिन कुछ में यह हो सकता है।

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

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

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

http://cpntr.codeplex.com/

अग्रिम रूप से क्षमा करें @CharliePoole यदि यह संदेश इस धागे पर हाल की चर्चाओं के लिए थोड़ा ऑर्थोगोनल है, लेकिन अगर कोई और पिछले ३ वर्षों से इस सुविधा के लिए इंतजार कर रहा है, तो NUnit ३ के लिए निर्धारित वादों के आधार पर (जिस तरह से जल्दी में वापस आ गया है) दिन), मुझे लगता है कि यह एक समाधान की पेशकश कर सकता है जब तक कि आप लोग डिजाइन के मुद्दों को हल करने का प्रबंधन नहीं करते (लगता है जैसे आप समाधान पर बंद कर रहे हैं)।

@ चार्लीपूल

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

क्या हमें डिस्पैचर को लंबित टियरडाउन आइटम के बारे में जानने की आवश्यकता है, या क्या हम उन्हें उपलब्ध होने पर भेज सकते हैं? अधिक ठोस रूप से, जहां CompositeWorkItem वर्तमान में PerformOneTimeTearDown को कॉल करता है, क्या हम डिस्पैचर का उपयोग कार्य की एक नई इकाई को सही कार्य शिफ्ट पर भेजने के लिए कर सकते हैं?

@ क्रिस-स्मिथ-ज़ोकडोक हाँ, ठीक यही मैं कर रहा हूँ। मैंने एक नया प्रकार का कार्य आइटम बनाया, OneTimeTearDownWorkItem , जो CompositeWorkItem में नेस्टेड है और अंतिम चाइल्ड टेस्ट चलने पर भेजा जाता है। बाद में, हम कुछ दक्षताओं को देख सकते हैं जब OneTimeSetUp और सभी परीक्षण एक ही थ्रेड पर चलाए गए हों।

सब कुछ बहुत ध्यान से नहीं पढ़ा है, लेकिन इस सुविधा के हिस्से के रूप में मैं एक बात का अनुरोध करना चाहता हूं कि समांतरता "स्मार्ट" हो, खासकर I/O बाध्य परीक्षणों के लिए। उदाहरण के लिए, यदि आपके पास १० थ्रेड्स १०० समानांतर परीक्षणों को निष्पादित कर रहे हैं, तो ऐसा नहीं होना चाहिए कि १० थ्रेड बैठें और अगले १० परीक्षणों पर जाने से पहले पहले १० परीक्षणों के पूरा होने की प्रतीक्षा करें। यदि पहले 10 परीक्षण बहुत लंबे समय तक चलने वाले I/O कार्यों की प्रतीक्षा करना शुरू करते हैं, तो थ्रेड अन्य परीक्षणों पर जाने के लिए स्वतंत्र होना चाहिए। जब I/O कार्य पूरा हो जाता है, तो थ्रेड्स थ्रेड के खाली होने पर प्रतीक्षारत परीक्षण फिर से शुरू कर देंगे।

मूल रूप से, मैं I/O बाध्य परीक्षणों के लिए स्मार्ट थ्रूपुट प्रबंधन के लिए कह रहा हूं जो async/प्रतीक्षा का व्यापक उपयोग करता है। यह अब तक परीक्षणों में हमारी नंबर एक बाधा है।

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

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

क्या कोई मुझे समझा सकता है कि यह कैसे काम करता है?
मेरे पास एक टेस्ट क्लास है
जब मैं समानांतर में नहीं इस वर्ग में परीक्षण चलाता हूं - सभी परीक्षण पास हो जाते हैं
लेकिन जब मैं उन्हें [समानांतर (समानांतरस्कोप। बच्चे)] के साथ चलाता हूं।
तो वे समानांतर में चलते हैं (एक ही कक्षा में कई विधियां)
लेकिन किसी कारण से कुछ परीक्षण विफल हो रहे हैं।
मेरे पास इस वर्ग में उदाहरण फ़ील्ड हैं जिनका उपयोग परीक्षणों में किया जाता है और ऐसा लगता है कि उन क्षेत्रों को धागे के बीच साझा किया जाता है
क्या मैं सही हूँ?
क्या आप उस वर्ग का केवल 1 उदाहरण बनाते हैं और इस एकल वस्तु पर एक साथ विधियों को कॉल करते हैं?
चार्लीपूल

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

उस ने कहा, यदि आपके पास जुड़नार का एक अच्छा अनुपात है, तो केवल समानांतर में जुड़नार चलाना आपको अच्छा प्रदर्शन दे सकता है।

में [समानांतर (समानांतरस्कोप। बच्चे)] होना संभव है
असेंबलीइन्फो.सीएस फ़ाइल?

क्या किसी ने इसे काम करते देखा है?

14 जून 2017 को 01:37 बजे, चार्लीपूल नोटिफिकेशन @github.com ने लिखा:

[छवि: Boxbe] https://www.boxbe.com/overview स्वचालित सफाई: रखें
पिछले 1 ईमेल ([email protected]) नियम संपादित करें
https://www.boxbe.com/popup?url=https%3A%2F%2Fwww.boxbe.com%2Fcleanup%3Fkey%3DCCP9ir0TebdbdQOWVtGMQyr2TETYOrzfkbItPzUTgDk%253D%26token%3D0PvYtf1G2B%252FJ2FNN3b7MTSmP1zvs6x3Cu8z6LaAB8%252BJm73uy8ZNUCnQcknlgWKxRQ5zjE%252BY30Xkv1W1Gue9gGnpyi72YUTaHP2h6wvuEpTXe1WoQDoSHpUGDQefgQu6LDH0rRhsEvF%252FW%252BhysbMtsDw%253D% 253D&tc_serial=30872123699&tc_rand=2087335475&utm_source=stf&utm_medium=email&utm_campaign=ANNO_CLEANUP_EDIT&utm_content=001
| नियम हटाएं
https://www.boxbe.com/popup?url=https%3A%2F%2Fwww.boxbe.com%2Fcleanup%3Fkey%3DCCP9ir0TebdbdQOWVtGMQyr2TETYOrzfkbItPzUTgDk%253D%26token%3D0PvYtf1G2B%252FJ2FNN3b7MTSmP1zvs6x3Cu8z6LaAB8%252BJm73uy8ZNUCnQcknlgWKxRQ5zjE%252BY30Xkv1W1Gue9gGnpyi72YUTaHP2h6wvuEpTXe1WoQDoSHpUGDQefgQu6LDH0rRhsEvF%252FW%252BhysbMtsDw%253D% 253D&tc_serial=30872123699&tc_rand=2087335475&utm_source=stf&utm_medium=email&utm_campaign=ANNO_CLEANUP_EDIT&utm_content=001
| महत्वपूर्ण चिह्नित करें
https://www.boxbe.com/popup?url=https%3A%2F%2Fwww.boxbe.com%2Fcleanup%3Fkey%3DCCP9ir0TebdbdQOWVtGMQyr2TETYOrzfkbItPzUTgDk%253D%26token%3D0PvYtf1G2B%252FJ2FNN3b7MTSmP1zvs6x3Cu8z6LaAB8%252BJm73uy8ZNUCnQcknlgWKxRQ5zjE%252BY30Xkv1W1Gue9gGnpyi72YUTaHP2h6wvuEpTXe1WoQDoSHpUGDQefgQu6LDH0rRhsEvF%252FW%252BhysbMtsDw%253D% 253D%26महत्वपूर्ण%3Dtrue%26emlId%3D61187554820&tc_serial=30872123699&tc_rand=2087335475&utm_source=stf&utm_medium=email&utm_campaign=ANNO_CLEANUP_EDIT&utm_content=001

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

उस ने कहा, यदि आपके पास जुड़नार का एक अच्छा अनुपात है, तो बस चल रहा है
समानांतर में जुड़नार आपको अच्छा प्रदर्शन दे सकते हैं।

-
आप इसे प्राप्त कर रहे हैं क्योंकि आपने टिप्पणी की थी।
इस ईमेल का सीधे उत्तर दें, इसे GitHub पर देखें
https://github.com/nunit/nunit/issues/164#issuecomment-308157832 , या म्यूट करें
सूत्र
https://github.com/notifications/unsubscribe-auth/AAHNVuK-J-X74mlAA_eT7OX7dxs7MpoRks5sDqzLgaJpZM4CUZ8r
.

@aray हां, वास्तव में यही एकमात्र कारण है कि मेरे पास अब

हाय जोसेफ,

आप अपनी असेंबलीइन्फो.सीएस फ़ाइल में कौन सी समानता रेखा जोड़ रहे हैं?

मुझे यह जानना अच्छा लगेगा कि क्या काम करता है।

चीयर्स,

एंड्रयू

बुधवार, 14 जून 2017 को शाम 4:17 बजे, जोसेफ मुसर सूचनाएं @github.com
लिखा था:

[छवि: Boxbe] https://www.boxbe.com/overview स्वचालित सफाई: रखें
पिछले 1 ईमेल ([email protected]) नियम संपादित करें
https://www.boxbe.com/popup?url=https%3A%2F%2Fwww.boxbe.com%2Fcleanup%3Fkey%3DnRGYOf%252FKR68McP8RTipuFTLF9WUvAkSKSh6OYJYvJ2w%253D%26token%3DDcwWzMT9yPtQLckdXD3BLhW5xAB%252BMpc9XdsrbBlwdQJZC%252Bjo3SjsyMVC8vese%252BCNRw2IyucWqEcHR5Is7CK7nx01VuSQESvjG4ZUj%252B2Cfcwg51yUFFQJSwrmTVxqAk4%252BTVGDSrnutdAuqiJ3kTaYQA% 253D%253D&tc_serial=30882364582&tc_rand=1974513896&utm_source=stf&utm_medium=email&utm_campaign=ANNO_CLEANUP_EDIT&utm_content=001
| नियम हटाएं
https://www.boxbe.com/popup?url=https%3A%2F%2Fwww.boxbe.com%2Fcleanup%3Fkey%3DnRGYOf%252FKR68McP8RTipuFTLF9WUvAkSKSh6OYJYvJ2w%253D%26token%3DDcwWzMT9yPtQLckdXD3BLhW5xAB%252BMpc9XdsrbBlwdQJZC%252Bjo3SjsyMVC8vese%252BCNRw2IyucWqEcHR5Is7CK7nx01VuSQESvjG4ZUj%252B2Cfcwg51yUFFQJSwrmTVxqAk4%252BTVGDSrnutdAuqiJ3kTaYQA% 253D%253D&tc_serial=30882364582&tc_rand=1974513896&utm_source=stf&utm_medium=email&utm_campaign=ANNO_CLEANUP_EDIT&utm_content=001
| महत्वपूर्ण चिह्नित करें
https://www.boxbe.com/popup?url=https%3A%2F%2Fwww.boxbe.com%2Fcleanup%3Fkey%3DnRGYOf%252FKR68McP8RTipuFTLF9WUvAkSKSh6OYJYvJ2w%253D%26token%3DDcwWzMT9yPtQLckdXD3BLhW5xAB%252BMpc9XdsrbBlwdQJZC%252Bjo3SjsyMVC8vese%252BCNRw2IyucWqEcHR5Is7CK7nx01VuSQESvjG4ZUj%252B2Cfcwg51yUFFQJSwrmTVxqAk4%252BTVGDSrnutdAuqiJ3kTaYQA% 253D%253D%26महत्वपूर्ण%3Dtrue%26emlId%3D612147070592&tc_serial=30882364582&tc_rand=1974513896&utm_source=stf&utm_medium=email&utm_campaign=ANNO_CLEANUP_EDIT&utm_content

@array https://github.com/array हां, वास्तव में यही एकमात्र कारण है I
अब एक AssemblyInfo.cs है।

-
आप इसे प्राप्त कर रहे हैं क्योंकि आपने टिप्पणी की थी।
इस ईमेल का सीधे उत्तर दें, इसे GitHub पर देखें
https://github.com/nunit/nunit/issues/164#issuecomment-308325726 , या म्यूट करें
सूत्र
https://github.com/notifications/unsubscribe-auth/AAHNVghNAX8CJkqAy-qhAz8bXNhZcFOQks5sD3NigaJpZM4CUZ8r
.

@agray जिसके बारे में आपने पूछा था:

c# [Parallelizable(ParallelScope.Children)]

लक्ष्य मत भूलना

[assembly: Parallelizable(ParallelScope.Children)]

@LirazShay मैं सेलेनियम परीक्षणों को चलाने के लिए NUnit का उपयोग

 public class TestFactory : IDisposable
    {
    // Instantiate a new SafeHandle instance.
    private readonly System.Runtime.InteropServices.SafeHandle handle = new Microsoft.Win32.SafeHandles.SafeFileHandle(IntPtr.Zero, true);

    // Flag: Has Disposed been called?
    private bool disposed = false;

    public TestFactory()
    {
        this.UserRepository = new List<UserAccount>();
        this.DU = new DataUtility();
    }

    // A list of users created for this test
    public List<UserAccount> UserRepository { get; private set; }

    // A very simple data layer utility that uses Dapper to interact with the database in my application 
    public DataUtility DU { get; private set; }

    // Gets a new user and adds it to the repository
    public UserAccount GetNewUser()
    {
        var ua = new UserAccount();
        this.UserRepository.Add(ua);
        return ua;
    }


    public void Dispose()
    {
        this.Dispose(true);
        GC.SuppressFinalize(this);
    }

    protected virtual void Dispose(bool disposing)
    {
        if (this.disposed)
        {
            return;
        }

        if (disposing)
        {
            // Deletes all user accounts created during the test
            foreach (UserAccount ua in this.UserRepository)
            {
                try
                {
                    ua.Delete();
                }
                catch (Exception)
                {
                    // Take no action if delete fails.
                }
            }

            this.DU.DeleteNullLoginFailures(); // Cleans up the database after tests
            Thread.Sleep(1500);
        }

        this.disposed = true;
    }
}

फिर, एक परीक्षण के भीतर मैं यह कर सकता हूं:

[TestFixture]
public class UserConfigureTests
{
    [Test]
    public void MyExampleTest()
    {
        using (TestFactory tf = new TestFactory())
        {
            var testUser = tf.GetNewUser();

    tf.DU.DoSomethingInTheDatabase(myParameter);

    // Test actions go here, and when we exit this using block the TestFactory cleans
    // up after itself using the Dispose method which calls whatever cleanup logic you've written into it
        }
    }
}

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

@tparikka मैं अत्यधिक अनुशंसा करता हूं कि वह स्वयं से संपर्क करें।

मेरे पास मेरी असेंबलीइन्फो फ़ाइल में निम्न है:

[विधानसभा: समानांतर (समानांतरस्कोप। बच्चे)]
[विधानसभा: LevelOfParallelism(16)]

क्या मुझे अब LevelOfParallelism विशेषता की भी आवश्यकता है?

१५ जून २०१७ को ०४:३७ बजे, जोसफ मुसर नोटिफिकेशन @github.com ने लिखा:

[छवि: Boxbe] https://www.boxbe.com/overview स्वचालित सफाई: रखें
पिछले 1 ईमेल ([email protected]) नियम संपादित करें
https://www.boxbe.com/popup?url=https%3A%2F%2Fwww.boxbe.com%2Fcleanup%3Fkey%3Doth%252FFbAPG%252FhDbtUlS0i2PDDdQ0lP4dBi8o7QQmkLEMQ%253D%26token%3DHe7HfTrm%252Fiba3yIDazaBx8JO9NrmoL8p5TWtDB1hUxq0qp%252BhCRCB3OSl7sUQ6wDshc2I5LQhbR2jszLWr6FnRy%252FZUrCqghZIIilbDWKszT7pkI44xp9vaL6cszH9Sgg1YPCAHdVWqccZYxYXGW174A%253D% 253D&tc_serial=30894750852&tc_rand=1847060911&utm_source=stf&utm_medium=email&utm_campaign=ANNO_CLEANUP_EDIT&utm_content=001
| नियम हटाएं
https://www.boxbe.com/popup?url=https%3A%2F%2Fwww.boxbe.com%2Fcleanup%3Fkey%3Doth%252FFbAPG%252FhDbtUlS0i2PDDdQ0lP4dBi8o7QQmkLEMQ%253D%26token%3DHe7HfTrm%252Fiba3yIDazaBx8JO9NrmoL8p5TWtDB1hUxq0qp%252BhCRCB3OSl7sUQ6wDshc2I5LQhbR2jszLWr6FnRy%252FZUrCqghZIIilbDWKszT7pkI44xp9vaL6cszH9Sgg1YPCAHdVWqccZYxYXGW174A%253D% 253D&tc_serial=30894750852&tc_rand=1847060911&utm_source=stf&utm_medium=email&utm_campaign=ANNO_CLEANUP_EDIT&utm_content=001
| महत्वपूर्ण चिह्नित करें
https://www.boxbe.com/popup?url=https%3A%2F%2Fwww.boxbe.com%2Fcleanup%3Fkey%3Doth%252FFbAPG%252FhDbtUlS0i2PDDdQ0lP4dBi8o7QQmkLEMQ%253D%26token%3DHe7HfTrm%252Fiba3yIDazaBx8JO9NrmoL8p5TWtDB1hUxq0qp%252BhCRCB3OSl7sUQ6wDshc2I5LQhbR2jszLWr6FnRy%252FZUrCqghZIIilbDWKszT7pkI44xp9vaL6cszH9Sgg1YPCAHdVWqccZYxYXGW174A%253D% 253D%26महत्वपूर्ण%3Dtrue%26emlId%3D61245244440&tc_serial=30894750852&tc_rand=1847060911&utm_source=stf&utm_medium=email&utm_campaign=ANNO_CLEANUP_EDIT&utm_content=001

@tparikka https://github.com/tparikka मैं अत्यधिक अनुशंसा करता हूं कि
मेरे पास पहुँचो।

-
आप इसे प्राप्त कर रहे हैं क्योंकि आपका उल्लेख किया गया था।
इस ईमेल का सीधे उत्तर दें, इसे GitHub पर देखें
https://github.com/nunit/nunit/issues/164#issuecomment-308521058 , या म्यूट करें
सूत्र
https://github.com/notifications/unsubscribe-auth/AAHNVmEzVDbw32Xx0jkYcGK9bZW3tLvXks5sECh8gaJpZM4CUZ8r
.

मैंने अभी तक LevelOfParallelism नहीं किया है। यह आपके पास मौजूद कोर की संख्या के लिए डिफ़ॉल्ट है।

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

@CharliePoole मैं TestcaseSource का उपयोग कर रहा हूं, लेकिन ऐसा लगता है कि परिणामी टेस्टकेस वास्तव में समानांतर में निष्पादित नहीं किए जा रहे हैं। क्या ऐसा कुछ काम करने की उम्मीद है:

```सी#
[टेस्टफिक्चर]
वर्ग अक्रमांकन
{
सार्वजनिक स्थैतिक IEnumerableshouldDeserializeAllCases() => Enumerable.Repeat(0, 5).Select(x => TimeSpan.FromSeconds(2));

    [TestCaseSource("ShouldDeserializeAllCases"), Parallelizable(ParallelScope.Children)]
    public void ShouldDeserializeAll(TimeSpan t)
    {
        Thread.Sleep(t);
        Assert.AreEqual(1, 1);
    }
}

```

लिया गया कुल समय ~ 2 के बजाय 10 सेकंड है।

मुझे लगता है कि कोई बच्चे नहीं हैं, इसलिए इस मामले में, आप बेहतर उपयोग कर सकते हैं
[समानांतर (समानांतर स्कोप। सभी)]
या अपनी विशेषता को कक्षा स्तर पर ले जाएँ।

@ParanoikCZE धन्यवाद। मैं वास्तव में उस विशेषता के संबंध में अंधा उड़ रहा हूं, इसलिए मैंने वहां सभी एनम मूल्यों की कोशिश की है। चाहे मैं All , Children , Fixture या Self किसका उपयोग करूं, मुझे 10 सेकंड का निष्पादन समय मिलता है (कम से कम विजुअल स्टूडियो में)।

मैंने इसे कक्षा में ले जाने की कोशिश की, लेकिन यह भी मदद नहीं कर रहा है।

कोशिश करो यह प्रेरणा का स्रोत है :)

class Deserialization
{
    public static IEnumerable<TestCaseData> ShouldDeserializeAllCases
    {
        get
        {
            for (int i = 1; i <= 5; i++)
                yield return new TestCaseData(TimeSpan.FromSeconds(i)).SetName($"Thread_worker_{i}");
        }
    }

    [TestCaseSource(nameof(ShouldDeserializeAllCases)), Parallelizable(ParallelScope.Children)]
    public void ShouldDeserializeAll(TimeSpan t) => System.Threading.Thread.Sleep(t);
}

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

असेंबलीइन्फो में [असेंबली: LevelOfParallelism(5)] जोड़ने का प्रयास करें, मुझे लगता है कि कुछ डिफ़ॉल्ट मान है, लेकिन शायद यह आपके लिए किसी भी तरह से काम नहीं करता है। वैसे भी, मैं विचारों से बाहर हूँ। :)