मैं कोई सॉफ्टवेयर इंजीनियर नहीं हूँ। मैं जियोसाइंस के क्षेत्र में एक पीएचडी छात्र हूं।
लगभग दो साल पहले मैंने एक वैज्ञानिक सॉफ्टवेयर की प्रोग्रामिंग शुरू की। मैंने कभी भी निरंतर एकीकरण (CI) का उपयोग नहीं किया, मुख्यतः क्योंकि पहले मुझे नहीं पता था कि यह मौजूद है और मैं इस सॉफ्टवेयर पर काम करने वाला एकमात्र व्यक्ति था।
अब चूंकि सॉफ्टवेयर का आधार चल रहा है, अन्य लोग इसमें रुचि लेने लगते हैं और सॉफ्टवेयर में योगदान देना चाहते हैं। योजना यह है कि अन्य विश्वविद्यालयों के अन्य व्यक्ति कोर सॉफ्टवेयर में परिवर्धन लागू कर रहे हैं। (मुझे डर है कि वे बग का परिचय दे सकते हैं)। इसके अतिरिक्त, सॉफ्टवेयर काफी जटिल हो गया और परीक्षण के लिए कठिन और कठिन हो गया और मैंने इस पर काम करना जारी रखने की योजना भी बनाई है।
इस दो कारणों के कारण, मैं अब सीआई का उपयोग करने के बारे में अधिक से अधिक सोच रहा हूं। चूँकि मेरे पास कभी भी सॉफ्टवेयर इंजीनियर की शिक्षा नहीं थी और मेरे आस-पास किसी ने कभी भी सीआई (हम वैज्ञानिक, कोई प्रोग्रामर नहीं) के बारे में नहीं सुना है, मुझे अपनी परियोजना के लिए शुरुआत करना मुश्किल लगता है।
मेरे पास कुछ सवाल हैं जहां मैं कुछ सलाह लेना चाहूंगा:
सबसे पहले सॉफ्टवेयर कैसे काम करता है की एक छोटी व्याख्या:
सॉफ्टवेयर सभी आवश्यक सेटिंग्स युक्त एक .xml फ़ाइल द्वारा नियंत्रित किया जाता है। आप केवल एक इनपुट तर्क के रूप में .xml फ़ाइल के लिए पथ पास करके सॉफ़्टवेयर प्रारंभ करते हैं और यह परिणामों के साथ कुछ फ़ाइलों को चलाता है और बनाता है। एक सिंगल रन में ~ 30 सेकंड लग सकते हैं।
यह एक वैज्ञानिक सॉफ्टवेयर है। लगभग सभी कार्यों में कई इनपुट पैरामीटर होते हैं, जिनके प्रकार ज्यादातर वर्ग होते हैं जो काफी जटिल होते हैं। मेरे पास बड़ी कैटलॉग के साथ कई .txt फाइलें हैं जो इन वर्गों के उदाहरण बनाने के लिए उपयोग की जाती हैं।
अब चलिए मेरे सवालों पर आते हैं:
इकाई परीक्षण, एकीकरण परीक्षण, एंड-टू-एंड परीक्षण? : मेरा सॉफ्टवेयर अब सैकड़ों कार्यों और ~ 80 कक्षाओं के साथ कोड की लगभग 30.000 पंक्तियाँ है। यह सैकड़ों तरह के कार्यों के लिए यूनिट परीक्षण लिखना शुरू करने के लिए मुझे अजीब लगता है जो पहले से ही लागू हैं। इसलिए मैंने केवल कुछ परीक्षण मामलों को बनाने के बारे में सोचा। 10-20 अलग .xml फाइलें तैयार करें और सॉफ्टवेयर को चलने दें। मुझे लगता है कि इसे एंड-टू-एंड टेस्ट कहा जाता है? मैं अक्सर पढ़ता हूं कि आपको ऐसा नहीं करना चाहिए, लेकिन शायद यह एक शुरुआत के रूप में ठीक है अगर आपके पास पहले से ही एक काम करने वाला सॉफ्टवेयर है? या यह केवल एक गूंगा विचार है कि सीआई को पहले से काम कर रहे सॉफ़्टवेयर में जोड़ने का प्रयास किया जाए।
यदि आप फ़ंक्शन पैरामीटर बनाना मुश्किल है, तो आप यूनिट टेस्ट कैसे लिखेंगे? मान लें कि मेरे पास एक फ़ंक्शन है
double fun(vector<Class_A> a, vector<Class_B>)और आमतौर पर, मुझे पहले प्रकार की वस्तुओं को बनाने के लिए कई पाठ फ़ाइलों में पढ़ने की आवश्यकता होती हैClass_AऔरClass_B। मैंने कुछ डमी फ़ंक्शंस बनाने के बारे में सोचा जैसेClass_A create_dummy_object()बिना टेक्स्ट फ़ाइलों में पढ़े। मैंने कुछ प्रकार के क्रमांकन को लागू करने के बारे में भी सोचा । (मैं वर्ग वस्तुओं के निर्माण का परीक्षण करने की योजना नहीं बनाता क्योंकि वे केवल कई पाठ फ़ाइलों पर निर्भर करते हैं)यदि परिणाम अत्यधिक परिवर्तनशील हैं तो परीक्षण कैसे लिखें? मेरा सॉफ्टवेयर बड़े मोंटे-कार्लो सिमुलेशन का उपयोग करता है और पुनरावृति से काम करता है। आमतौर पर, आपके पास ~ 1000 पुनरावृत्तियों और प्रत्येक पुनरावृत्ति पर, आप मोंटे-कार्लो सिमुलेशन के आधार पर वस्तुओं के ~ 500-20.000 उदाहरण बना रहे हैं। यदि केवल एक पुनरावृत्ति का एक परिणाम थोड़ा भिन्न होता है तो आगामी आगामी पुनरावृत्तियां पूरी तरह से भिन्न होती हैं। आप इस स्थिति से कैसे निपटेंगे? मुझे लगता है कि एंड-टू-एंड परीक्षणों के खिलाफ यह एक बड़ा बिंदु है, क्योंकि अंतिम परिणाम अत्यधिक परिवर्तनशील है?
CI के साथ किसी भी अन्य सलाह की बहुत सराहना की जाती है।