दिलचस्प पोस्ट
com.sun.faces.numberOfViewsInSession बनाम com.sun.faces.numberOfLogicalViews "1" बनाने के लिए "2-1" जैसे स्ट्रिंग का गणितीय मूल्यांकन कैसे करें? क्या जावास्क्रिप्ट में एक "अशक्त संकालन" ऑपरेटर है? जावा में सार वर्ग बनाम अंतरफलक सी में मुद्रण हेक्साडेसिमल वर्ण XCode 6 में पीसीएच फ़ाइल अस्पष्ट PHP कोड ट्विटर बूटस्ट्रैप टाइपआहेड अजाक्स उदाहरण JSON.stringify का उपयोग करते हुए त्रुटि को स्ट्रिंग करना संभव नहीं है? डी 3 v4 – शून्य की संपत्ति पाठ पढ़ा नहीं जा सकता त्रुटि: 'स्थानीय MySQL सर्वर से सॉकेट के माध्यम से कनेक्ट नहीं किया जा सकता' /var/run/mysqld/mysqld.sock '(2)' jQuery के साथ addClass / removeClass एनिमेटिंग घातक त्रुटि: Python.h: ऐसा कोई फ़ाइल या निर्देशिका नहीं स्ट्रिंग फ़ील्ड से MySQL में कोई दिनांक परिवर्तित करना क्या C89, C90 या C99 में सभी कार्यों के लिए प्रोटोटाइप आवश्यक है?

मैं कैसे इकाई परीक्षण थ्रेडेड कोड चाहिए?

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

आज प्रोग्रामर के लिए यह वास्तव में एक महत्वपूर्ण समस्या की तरह लगता है, यह हमारे ज्ञान को इस एक आईमो पर पूल करने के लिए उपयोगी होगा।

वेब के समाधान से एकत्रित समाधान "मैं कैसे इकाई परीक्षण थ्रेडेड कोड चाहिए?"

देखो, ऐसा करने का कोई आसान तरीका नहीं है मैं एक ऐसी परियोजना पर काम कर रहा हूं जो स्वाभाविक रूप से मल्टीथ्रेड है घटनाक्रम ऑपरेटिंग सिस्टम से आते हैं और मुझे उन्हें समवर्ती रूप से प्रोसेस करना पड़ता है

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

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

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

संभवतः थ्रेडिंग समस्याओं के लिए कोड का परीक्षण करने का सर्वोत्तम तरीका कोड के स्थिर विश्लेषण के माध्यम से होता है। यदि आपका थ्रेडेड कोड थ्रेड सुरक्षित पैटर्न का एक सीमित सेट का पालन नहीं करता है, तो आपके पास समस्या हो सकती है। मेरा मानना ​​है कि वी.एस. में कोड विश्लेषण में सूत्रण के कुछ ज्ञान शामिल हैं, लेकिन शायद अधिक नहीं।

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

यह कुछ समय था जब यह सवाल पोस्ट किया गया था, लेकिन इसका अभी भी उत्तर नहीं दिया गया है …

kleolb02 का जवाब अच्छा है मैं और अधिक जानकारी में जाने की कोशिश करता हूँ

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

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

यह आपको तुल्यकालिक तरीके से कोर लॉजिक कोड का परीक्षण करने की स्थिति में रखता है। आपके पास मुख्य तर्क पर किए गए कॉलों के समय पर पूर्ण नियंत्रण है और इस प्रकार प्रतिलिपि प्रस्तुत करने योग्य परीक्षण कर सकते हैं। और यह मुख्य तर्क और अतुल्यकालिक तर्क को अलग करने से आपका लाभ है।

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

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

वास्तव में एक मुश्किल! मेरे (सी ++) यूनिट परीक्षणों में, मैंने इसका उपयोग संगामिति पैटर्न की तर्ज पर कई श्रेणियों में किया है:

  1. कक्षाओं के लिए यूनिट परीक्षण जो एक धागे में कार्य करते हैं और धागा को अवगत नहीं करते हैं – सामान्य रूप से सामान्य रूप से परीक्षण करें

  2. मॉनिटर ऑब्जेक्ट्स (जो कि कॉलर्स 'थ्रेड ऑफ कंट्रोल में सिंक्रनाइज़ किए गए तरीकों को निष्पादित करते हैं) के लिए यूनिट परीक्षण जो एक सिंक्रनाइज़ पब्लिक एपीआई का पर्दाफाश करते हैं – एपीआई का प्रयोग करने वाले कई नकली थ्रेडों को तत्काल प्रदान करते हैं। परिस्थितियों का निर्माण करें जो निष्क्रिय ऑब्जेक्ट की आंतरिक स्थितियों का उपयोग करें। एक लंबे समय तक चलने वाला परीक्षण शामिल करें, जो सामान्यतया लंबे समय तक कई थ्रेड्स से उस बिल्ली को बाहर से मारता है। यह अवैज्ञानिक मुझे पता है लेकिन यह आत्मविश्वास का निर्माण करता है

  3. सक्रिय ऑब्जेक्ट्स (जो कि अपने खुद के धागे या नियंत्रण के सूत्रों को समाहित करता है) के लिए यूनिट टेस्ट – क्लास डिजाइन के आधार पर भिन्नता के साथ # 2 के समान। सार्वजनिक एपीआई अवरुद्ध या गैर-अवरुद्ध हो सकता है, कॉल करने वाले फ़्यूचर्स प्राप्त कर सकते हैं, डेटा कतारों पर पहुंच सकता है या उन्हें ड्यूक्यूड करने की आवश्यकता है। यहां कई संयोजन संभव हैं; सफेद बॉक्स दूर फिर भी परीक्षण के तहत ऑब्जेक्ट को कॉल करने के लिए एकाधिक नकली धागे की आवश्यकता है।

स्वगत कथन के रूप में:

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

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

परीक्षण योग्य बहुभाषी कोड लिखना

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

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

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

Multithreaded कोड के लिए इकाई परीक्षण लेखन

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

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

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

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

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

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

इसके आसपास कुछ उपकरण हैं जो काफी अच्छे हैं। यहां कुछ जावा वाले लोगों का सारांश है

कुछ अच्छे स्थिर विश्लेषण उपकरणों में FindBugs (कुछ उपयोगी संकेत देता है), जेलिंट , जावा पाथफाइंडर (जेपीएफ और जेपीएफ 2) और बोगोर शामिल हैं ।

MultithreadedTC काफी अच्छा गतिशील विश्लेषण उपकरण (JUnit में एकीकृत) जहां आप अपने खुद के परीक्षण के मामलों को स्थापित करना होगा।

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

SPIN आपके जावा (और अन्य) घटकों को मॉडलिंग के लिए एक बहुत अच्छा उपकरण है, लेकिन आपको कुछ उपयोगी ढांचे की आवश्यकता है। यह प्रयोग करना कठिन है, लेकिन बहुत शक्तिशाली अगर आपको पता है कि इसका उपयोग कैसे करना है। काफी कुछ उपकरण हुड के नीचे SPIN का उपयोग करते हैं

MultithreadedTC शायद सबसे मुख्य धारा है, लेकिन ऊपर सूचीबद्ध कुछ स्थिर विश्लेषण उपकरण निश्चित रूप से देखने के लायक हैं।

निर्धारक यूनिट परीक्षणों को लिखने में आपकी सहायता के लिए भी उपयुक्त हो सकता है। यह आपके सिस्टम में किसी न किसी राज्य को अपडेट होने तक प्रतीक्षा करने की सुविधा देता है। उदाहरण के लिए:

await().untilCall( to(myService).myMethod(), greaterThan(3) ); 

या

 await().atMost(5,SECONDS).until(fieldIn(myObject).ofType(int.class), equalTo(1)); 

इसमें स्काला और ग्रोवी समर्थन भी है।

 await until { something() > 4 } // Scala example 

मैंने बहुत कुछ किया है, और हाँ यह बेकार है।

कुछ सुझाव:

  • एकाधिक परीक्षण धागे चलाने के लिए GroboUtils
  • अल्फा वर्क्स पुनरावृत्तियों के बीच अंतर के लिए इंटरलेविंग के कारण साधन वर्गों के लिए कॉन्टेस्ट
  • एक throwable फ़ील्ड बनाएं और इसे tearDown में tearDown (लिस्टिंग 1 देखें)। यदि आप किसी अन्य धागा में एक अपवाद को पकड़ते हैं, तो इसे केवल अचेतन करने के लिए निर्दिष्ट करें
  • मैंने लिस्टिंग 2 में यूटिलस वर्ग बनाया है और इसे अमूल्य पाया है, विशेष रूप से प्रतीक्षा करें सत्यापित करें और इंतजार करेंकंडशन, जो आपके परीक्षणों के प्रदर्शन को बहुत बढ़ा देगा।
  • अपने परीक्षणों में AtomicBoolean का अच्छा उपयोग करें यह धागा सुरक्षित है, और आपको अक्सर कॉलबैक वर्गों से मूल्यों को संग्रहीत करने के लिए अंतिम संदर्भ प्रकार की आवश्यकता होती है और इस तरह जैसे। लिस्टिंग 3 में उदाहरण देखें
  • सुनिश्चित करें कि हमेशा अपना परीक्षण एक टाइमआउट दें (उदाहरण के लिए, @Test(timeout=60*1000) ), क्योंकि संगतता परीक्षण कभी-कभी हमेशा के लिए लटकाए जाते हैं जब वे टूटा हो

लिस्टिंग 1:

 @After public void tearDown() { if ( throwable != null ) throw throwable; } 

लिस्टिंग 2:

 import static org.junit.Assert.fail; import java.io.File; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Proxy; import java.util.Random; import org.apache.commons.collections.Closure; import org.apache.commons.collections.Predicate; import org.apache.commons.lang.time.StopWatch; import org.easymock.EasyMock; import org.easymock.classextension.internal.ClassExtensionHelper; import static org.easymock.classextension.EasyMock.*; import ca.digitalrapids.io.DRFileUtils; /** * Various utilities for testing */ public abstract class DRTestUtils { static private Random random = new Random(); /** Calls {@link #waitForCondition(Integer, Integer, Predicate, String)} with * default max wait and check period values. */ static public void waitForCondition(Predicate predicate, String errorMessage) throws Throwable { waitForCondition(null, null, predicate, errorMessage); } /** Blocks until a condition is true, throwing an {@link AssertionError} if * it does not become true during a given max time. * @param maxWait_ms max time to wait for true condition. Optional; defaults * to 30 * 1000 ms (30 seconds). * @param checkPeriod_ms period at which to try the condition. Optional; defaults * to 100 ms. * @param predicate the condition * @param errorMessage message use in the {@link AssertionError} * @throws Throwable on {@link AssertionError} or any other exception/error */ static public void waitForCondition(Integer maxWait_ms, Integer checkPeriod_ms, Predicate predicate, String errorMessage) throws Throwable { waitForCondition(maxWait_ms, checkPeriod_ms, predicate, new Closure() { public void execute(Object errorMessage) { fail((String)errorMessage); } }, errorMessage); } /** Blocks until a condition is true, running a closure if * it does not become true during a given max time. * @param maxWait_ms max time to wait for true condition. Optional; defaults * to 30 * 1000 ms (30 seconds). * @param checkPeriod_ms period at which to try the condition. Optional; defaults * to 100 ms. * @param predicate the condition * @param closure closure to run * @param argument argument for closure * @throws Throwable on {@link AssertionError} or any other exception/error */ static public void waitForCondition(Integer maxWait_ms, Integer checkPeriod_ms, Predicate predicate, Closure closure, Object argument) throws Throwable { if ( maxWait_ms == null ) maxWait_ms = 30 * 1000; if ( checkPeriod_ms == null ) checkPeriod_ms = 100; StopWatch stopWatch = new StopWatch(); stopWatch.start(); while ( !predicate.evaluate(null) ) { Thread.sleep(checkPeriod_ms); if ( stopWatch.getTime() > maxWait_ms ) { closure.execute(argument); } } } /** Calls {@link #waitForVerify(Integer, Object)} with <code>null</code> * for {@code maxWait_ms} */ static public void waitForVerify(Object easyMockProxy) throws Throwable { waitForVerify(null, easyMockProxy); } /** Repeatedly calls {@link EasyMock#verify(Object[])} until it succeeds, or a * max wait time has elapsed. * @param maxWait_ms Max wait time. <code>null</code> defaults to 30s. * @param easyMockProxy Proxy to call verify on * @throws Throwable */ static public void waitForVerify(Integer maxWait_ms, Object easyMockProxy) throws Throwable { if ( maxWait_ms == null ) maxWait_ms = 30 * 1000; StopWatch stopWatch = new StopWatch(); stopWatch.start(); for(;;) { try { verify(easyMockProxy); break; } catch (AssertionError e) { if ( stopWatch.getTime() > maxWait_ms ) throw e; Thread.sleep(100); } } } /** Returns a path to a directory in the temp dir with the name of the given * class. This is useful for temporary test files. * @param aClass test class for which to create dir * @return the path */ static public String getTestDirPathForTestClass(Object object) { String filename = object instanceof Class ? ((Class)object).getName() : object.getClass().getName(); return DRFileUtils.getTempDir() + File.separator + filename; } static public byte[] createRandomByteArray(int bytesLength) { byte[] sourceBytes = new byte[bytesLength]; random.nextBytes(sourceBytes); return sourceBytes; } /** Returns <code>true</code> if the given object is an EasyMock mock object */ static public boolean isEasyMockMock(Object object) { try { InvocationHandler invocationHandler = Proxy .getInvocationHandler(object); return invocationHandler.getClass().getName().contains("easymock"); } catch (IllegalArgumentException e) { return false; } } } 

लिस्टिंग 3:

 @Test public void testSomething() { final AtomicBoolean called = new AtomicBoolean(false); subject.setCallback(new SomeCallback() { public void callback(Object arg) { // check arg here called.set(true); } }); subject.run(); assertTrue(called.get()); } 

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

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

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

पढ़ने के लिए कुछ रोचक लिंक:

  • निर्धारित अंतरःविस्तार : एक ढांचा जो कुछ थ्रेड इंटरलेविज को मजबूर करने की अनुमति देता है और फिर इनवेरिएंट्स की जांच करता है
  • जेएमक ब्लिट्जर : तनाव परीक्षण सिंक्रनाइज़ेशन
  • assertConcurrent : तनाव परीक्षण synronization के JUnit संस्करण
  • समवर्ती कोड का परीक्षण : ब्रूट बल (तनाव परीक्षण) या नियतात्मक (प्राथमिकताओं के लिए जा रहे) के दो प्राथमिक तरीकों का संक्षिप्त अवलोकन

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

उद्धरण:

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

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

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

पीट गुडलिफ़ की थ्रेड कोड की इकाई परीक्षण पर एक श्रृंखला है।

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

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

यूनिट परीक्षणों के साथ धागा-सुरक्षा "साबित करना" मेरा विश्वास है कि यह विभिन्न प्लेटफार्मों / कॉन्फ़िगरेशनों पर स्वचालित एकीकरण परीक्षण द्वारा बेहतर सेवा प्रदान करता है

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

इसलिए मैंने ऐसे रैपर लिखी हैं जो कुछ इस तरह दिखते हैं (सरलीकृत):

 public interface IThread { void Start(); ... } public class ThreadWrapper : IThread { private readonly Thread _thread; public ThreadWrapper(ThreadStart threadStart) { _thread = new Thread(threadStart); } public Start() { _thread.Start(); } } public interface IThreadingManager { IThread CreateThread(ThreadStart threadStart); } public class ThreadingManager : IThreadingManager { public IThread CreateThread(ThreadStart threadStart) { return new ThreadWrapper(threadStart) } } 

वहां से मैं आसानी से अपने घटकों में आईटहाड़ीिंग मैनेजर को इंजेक्ट कर सकता हूं और टेस्ट के दौरान उम्मीद करता हूं कि थ्रेड को व्यवहार करने के लिए मेरी अलग-अलग ढांचा का उपयोग करना चाहिए।

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

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

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

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

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

अपडेट: मैं मल्टीथ्रेडेड टीसी जावा लाइब्रेरी के साथ थोड़ा खेला है, और यह अच्छी तरह से काम करता है। मैंने अपनी सुविधाओं में से कुछ को एक .NET संस्करण में रख दिया है I TickingTest को कॉल करता है

मेरे संबंधित उत्तर को देखें

कस्टम बैरियर के लिए एक टेस्ट क्लास तैयार करना

यह जावा के प्रति पक्षपातपूर्ण है, लेकिन विकल्प का एक उचित सारांश है।

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

स्थैतिक विश्लेषण और औपचारिक तरीकों (देखें, संवैधानिकता: राज्य मॉडल और जावा प्रोग्राम ) एक विकल्प है लेकिन मैंने उन्हें वाणिज्यिक विकास में सीमित उपयोग के रूप में पाया है।

यह मत भूलो कि समस्याओं को उजागर करने के लिए किसी भी लोड / सॉक शैली परीक्षणों को शायद ही कभी गारंटी दी जाती है।

सौभाग्य!

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

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

यदि आप लिखते हैं तो बहु-धागा जावा इसे एक शॉट देता है।

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

छिड़काव – उन्नत सिंक्रनाइज़ेशन ऑब्जेक्ट

मैंने पिछले हफ्ते एक विश्वविद्यालय पुस्तकालय में समवर्ती कोड के डीबगिंग का अध्ययन किया था। केंद्रीय समस्या समवर्ती कोड गैर-नियतात्मक है आमतौर पर, अकादमिक डीबगिंग यहां तीन शिविरों में से एक में गिर गई है:

  1. घटना का पता लगाने / पुनरावृत्ति। इसके लिए इवेंट मॉनिटर की आवश्यकता होती है और फिर भेजे गए ईवेंट की समीक्षा की जाती है। एक यूटी फ्रेमवर्क में, यह एक परीक्षण के हिस्से के रूप में मैन्युअल रूप से इवेंट्स भेजने, और फिर पोस्टमार्टम की समीक्षा कर रहा है।
  2. स्क्रिप्ट। यह वह जगह है जहां आप ट्रिगर्स के सेट के साथ चल रहे कोड के साथ सहभागिता करते हैं। "एक्स पर" फू, बाज़ () "। यह एक यूटी फ्रेमवर्क में व्याख्या की जा सकती है जहां आपके पास एक निश्चित स्थिति पर एक निश्चित परीक्षण ट्रिगर हो।
  3. इंटरएक्टिव। यह स्पष्ट रूप से एक स्वचालित परीक्षण स्थिति में काम नहीं करेगा। 😉

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

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

शुभकामनाएँ, और समस्या पर काम करना जारी रखें।

जावा में: पैकेज java.util.concurrent में कुछ बुरे जाने-पहचाने वर्ग शामिल हैं, जो कि निर्धारणीय JUnit-Tests को लिखने में मदद कर सकते हैं।

अच्छी तरह से देखिए

  • CountDownLatch
  • सिकंदरा
  • एक्सचेंजर

मुझे थ्रेडेड कोड का परीक्षण करने के दुर्भाग्यपूर्ण कार्य हुए हैं और वे निश्चित रूप से सबसे कठिन परीक्षण हैं जो मैंने कभी लिखा है।

मेरे परीक्षण लिखते समय, मैंने प्रतिनिधियों और घटनाओं के संयोजन का उपयोग किया था असल में यह एक WaitCallback या किसी तरह के ConditionalWaiter WaitCallback साथ PropertyNotifyChanged WaitCallback घटनाओं का उपयोग करने के बारे में है, जो कि चुनाव

मुझे यकीन नहीं है कि यह सबसे अच्छा तरीका था, लेकिन उसने मेरे लिए काम किया है

किताब को क्लीन कोड अध्याय 13 में लिखें, मल्टीथ्रेडेड कोड का परीक्षण करने के लिए एक संपूर्ण खंड है और आम तौर पर संगामिति के लिए भी आपको बेहतर मल्टीथ्रेड कोड तैयार करने में मदद मिल सकती है।

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

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

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

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

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

परीक्षण उदाहरण थ्रेडसेफ़ बनाने के लिए आप EasyMock.makeThreadSafe का उपयोग कर सकते हैं

(यदि संभव हो) थ्रेड्स का उपयोग न करें, अभिनेता / सक्रिय ऑब्जेक्ट का उपयोग करें परीक्षण करने के लिए आसान