मेन्यू

JUnit टेस्ट निष्पादन आदेश: टेस्ट का क्रम JUnit 4 बनाम JUnit 5

  • मुख्य
  • अन्य
  • JUnit टेस्ट निष्पादन आदेश: टेस्ट का क्रम JUnit 4 बनाम JUnit 5

junit test execution order

समस्याओं को खत्म करने के लिए हमारे साधन का प्रयास करें

विंडोज़ के लिए सबसे अच्छा मुफ्त डेटाबेस सॉफ्टवेयर

यह ट्यूटोरियल बताता है कि ज्यूनिट टेस्ट के मामलों के लिए निष्पादन आदेश कैसे निर्धारित किया जाए। आप JUnit 4 बनाम JUnit 5 में JUnit टेस्ट निष्पादन आदेश सेट करने के लिए एनोटेशन और कक्षाओं के बारे में जानेंगे:

हमने सीखा कि टेस्ट सूट कैसे बनाया जाए, परीक्षण के मामलों में श्रेणी या टैग कैसे जोड़ा जाए, और हमारे पिछले ट्यूटोरियल में श्रेणी या टैग के आधार पर परीक्षणों को कैसे फ़िल्टर किया जाए (परीक्षण मामलों को शामिल करें या शामिल करें)।

इसके अलावा, हमें पता चला है कि JUnit 4 में, हमारे पास है @ श्रेणी, @ सूची, श्रेणी, तथा @ExcludeCategory JUnit 5 है, जबकि परीक्षण मामलों को छानने के लिए @IncludeTags तथा @ExcludeTags वही करने के लिए।

JUnit 5 में एनोटेशन का उपयोग करके अतिरिक्त फ़िल्टरिंग विकल्प हैं @IncludePackages, @ExcludePackages, और वर्ग नाम पैटर्न का उपयोग करके कक्षाओं को शामिल करने या बाहर करने के लिए एनोटेशन भी।

=> JUnit प्रशिक्षण ट्यूटोरियल के ए-जेड को देखने के लिए यहां देखें ।

JUnit टेस्ट निष्पादन आदेश

आप क्या सीखेंगे:

JUnit टेस्ट निष्पादन आदेश

इस ट्यूटोरियल में, हम सीखेंगे कि प्रत्येक टेस्ट केस के लिए ऑर्डर कैसे सेट करें ताकि वे सेट ऑर्डर में चलें। हम सीखेंगे कि कैसे JUnit 4 के साथ-साथ JUnit 5 में परीक्षण का आदेश दिया जाए।

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

परीक्षण मामलों के निष्पादन के क्रम को निर्धारित करने के लिए अलग-अलग तरीके या तरीके हैं। हम यह भी बताएंगे कि JUnit 4, JUnit 5 की तुलना में परीक्षण के मामलों को क्रमबद्ध करने में कैसे बदलता है।

JUnit 4: @FixedMethodOrder, क्लास मेथोडर्स

4.11 से शुरू करके, हमारे पास एनोटेशन है @FixMethodOrder तथा MethodSorters.class परीक्षण के निष्पादन के लिए एक आदेश की सुविधा का समर्थन करना

पैकेज org.junit.runners। * वर्ग को शामिल करने के लिए आयात करने की आवश्यकता है MethodSorters । यह वर्ग तय करता है कि परीक्षण के मामलों को किस तरह से आदेशित किया जाना चाहिए। MethodSorters है तीन एनम मान।

नीचे दिए गए मूल्य के प्रत्येक उद्देश्य के साथ-साथ कक्षा के एनम मान दिए गए हैं:

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

एनोटेशन @FixedMethodOrder के इनपुट पैरामीटर में लेता है MethodSorters इसके enum value के साथ। एनोटेशन के लिए आवश्यक पैकेज है org.junit.FixedMethodOrder।

आइए देखें कि इसे कोड के माध्यम से कैसे लागू किया जाता है।

MethodSorters.DEFAULT के लिए कोड कार्यान्वयन

आइए एक JUnit क्लास फ़ाइल बनाएं U Junit4TestOrder.java ' जहां हम उपयोग करेंगे MethodSorters.DEFAULT

Junit4TestOrder.java के लिए कोड

@FixMethodOrder(MethodSorters.DEFAULT) public class JUnit4TestOrder { @Test public void Testcase_3() { System.out.println('Testcase_3 executes'); } @Test public void Testcase_1() { System.out.println('Testcase_1 executes'); } @Test public void Testcase_2() { System.out.println('Testcase_2 executes '); } }

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

कंसोल विंडो ने परिणाम निम्नानुसार दिखाए - परीक्षण निष्पादन का क्रम TestCase_3, TestCase_1 और TestCase_2 है और आदेश रन की संख्या के साथ परिवर्तित नहीं होता है।

कंसोल विंडो 1

MethodSorters के लिए कोड कार्यान्वयन। जेवीएम

अब हम 'Junit4TestOrder.java' को अपडेट करेंगे MethodSorters.JVM

Junit4TestOrder.java के लिए कोड स्निपेट

@FixMethodOrder(MethodSorters . JVM ) public class JUnit4TestOrder {

हम दो बार कक्षा चलाते हैं और प्रत्येक रन के साथ परीक्षणों के निष्पादन के क्रम बदलते हैं।

के लिए कंसोल विंडो प्रथम नीचे दिए अनुसार रन किया गया है:

कंसोल विंडो FIRST रन

के लिए कंसोल विंडो दूसरा नीचे दिए अनुसार रन किया गया है:

कंसोल विंडो दूसरा रन

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

MethodSorters.NAME_ASCENDING के लिए कोड कार्यान्वयन

अब हम 'Junit4TestOrder.java' को अपडेट करेंगे MethodSorters.NAME_ASCENDING

Junit4TestOrder.java के लिए कोड स्निपेट

@FixMethodOrder(MethodSorters.NAME_ASCENDING) public class JUnit4TestOrder {

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

कंसोल विंडो आदेश TestCase_1, TestCase_2 और TestCase_3 में निष्पादित परीक्षणों का परिणाम दिखाती है।

परीक्षा के परिणाम

JUnit 5: @TestMethodOrder, @ ऑडर, इंटरफ़ेस मेथोडर

परीक्षणों के निष्पादन के क्रम को नियंत्रित करने के लिए, नीचे की इकाइयाँ ऐसा करने में मदद करती हैं:

  1. एनोटेशन @TestMethodOrder
  2. एनोटेशन @ ऑडर
  3. MethodOrderer इंटरफ़ेस से संबंधित क्लासेस

अंतर्निहित मेथोडर कक्षाएं और उनके विवरण नीचे दिए गए हैं:

MethodOrderer वर्ग में बनाया गया हैपैकेज सेविवरण
अक्षरांकीय org.junit.jupiter.api.MethodOrderer.lphanumericउनके नामों के आधार पर अल्फ़ान्यूमेरिक रूप से परीक्षण के तरीके
आदेश org.junit.jupiter.api.MethodOrderer.OrderAnnotationएनोटेशन @ ऑडर के लिए दिए गए मानों के आधार पर संख्यानुसार परीक्षण विधियों का परीक्षण करता है
बिना सोचे समझे org.junit.jupiter.api.MethodOrderer। आयामीJUnit 4 में MethodSorters.JVM की तरह ही परीक्षण विधियों को बेतरतीब ढंग से परीक्षण करता है

आइए अब इन आदेश देने वाली रणनीतियों में से प्रत्येक के प्रदर्शन को देखें:

Alphanumeric.class के लिए कोड कार्यान्वयन

आइए JUnit5TestOrder.java की तरह JUnit5TestOrder.java नाम से एक JUnit 5 क्लास फ़ाइल बनाएं और परीक्षणों को अल्फ़ान्यूमेरिक रूप से ऑर्डर करने के लिए Alphanumeric.class के साथ एनोटेशन का उपयोग करें।

Junit5TestOrder.java के लिए कोड

@TestMethodOrder(Alphanumeric.class) public class JUnit5TestOrder { @Test public void Testcase_3() { System.out.println('Testcase_3 executes'); } @Test public void Testcase_1() { System.out.println('Testcase_1 executes'); } @Test public void Testcase_2() { System.out.println('Testcase_2 executes '); } }

हमने कक्षा को तीन बार दौड़ाया और अभी भी परीक्षण विधि के नाम के अल्फ़ान्यूमेरिक रूप से क्रमबद्ध क्रम में चलाए जा रहे परीक्षणों का एक ही क्रम देखते हैं।

वर्ग फ़ाइल का पोस्ट निष्पादन, परीक्षण निष्पादन का क्रम:

  1. Testcase_1,
  2. टेस्टकेस .2 और
  3. टेस्टकेस_3

ध्यान दें: अल्फ़ान्यूमेरिक प्रकार की रणनीति मामला संवेदनशील है इसलिए मामले में हमारे पास एक और परीक्षण मामला था जिसका नाम testcase_1 था।

निष्पादन का क्रम होगा:

  1. Testcase_1,
  2. Testcase_2,
  3. टेस्टकेस_3,
  4. testcase_1

इसलिए, ऊपरी केस लोअर-केस विधि नामों पर प्राथमिकता लेता है।

रैंडम.क्लास के लिए कोड कार्यान्वयन

अब हम यादृच्छिक के साथ एनोटेशन का उपयोग करने के लिए JUnit 5 वर्ग JUnit5TestOrder.java को अपडेट करेंगे।

Junit5TestOrder.java के लिए कोड स्निपेट

@TestMethodOrder (Random.class) public class JUnit5TestOrder {

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

के लिए वर्ग फ़ाइल का पोस्ट निष्पादन पहली बार परीक्षण निष्पादन का क्रम था:

  1. Testcase_2,
  2. टेस्टकेस १
  3. टेस्टकेस_3

जब चलाने के लिए निष्पादन का क्रम दूसरा समय दिखाया:

  1. Testcase_2,
  2. टेस्टकेस_3
  3. टेस्टकेस १ ।

OrderAnnotation.class के लिए कोड कार्यान्वयन

अब हम JUnit 5 वर्ग JUnit5TestOrder.java को अपडेट करेंगे, जिसमें एनोटेशन का उपयोग किया जाएगा आर्डरनोटेशन.क्लास। एनोटेशन @गण यहां परीक्षण विधियों की प्राथमिकता सेटिंग में भी महत्वपूर्ण भूमिका निभाएगा।

Junit5TestOrder.java के लिए कोड स्निपेट

@TestMethodOrder(OrderAnnotation.class) public class JUnit5TestOrder { @Test @Order(1) public void Testcase_3() { System.out.println('Testcase_3 executes'); } @Test @Order(2) public void Testcase_1() { System.out.println('Testcase_1 executes'); } @Test @Order(3) public void Testcase_2() { System.out.println('Testcase_2 executes '); } }

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

परीक्षण विधि के लिए @ ऑडर का मूल्य जितना कम होगा, निष्पादन के दौरान इसकी प्राथमिकता उतनी ही अधिक होगी।

निष्पादन के बाद, परीक्षणों का क्रम निम्नानुसार चला:

  1. टेस्टकेस_3,
  2. टेस्टकेस १
  3. Testcase_2 क्योंकि परीक्षण मामलों के लिए निर्धारित क्रम क्रमशः 1,2 और 3 है।

यही कारण है कि अगर परीक्षण के मामले क्रम में लिखे गए हैं तो यह कोई फर्क नहीं पड़ता। इसके अलावा, यदि विधि के नाम अल्फ़ान्यूमेरिक क्रम में हैं या नहीं हैं, तो यह महत्वपूर्ण नहीं है।

JUnit 5: कस्टम ऑर्डर बनाना

इसके अलावा, बिल्ट-इन ऑर्डर क्लासेस, JUnit 5 इंटरफ़ेस को लागू करके कस्टम ऑर्डर का भी समर्थन करता है विधिऑडर । JUnit 5 संस्करण 5.4 से शुरू, कस्टम प्रकार समर्थित है।

चलिए जल्दी से देखते हैं कि विधि लंबाई के अनुसार कस्टम ऑर्डर कैसे बनाएं और कार्यान्वित करें।

चरण 1: MethodOrderer इंटरफ़ेस को लागू करने वाला एक कस्टम ऑर्डर क्लास बनाया गया और क्लास को TestCaseLengthOrder नाम दिया

TestCaseLengthOrder.java के लिए कोड

public class TestCaseLengthOrder implements MethodOrderer { @Override public void orderMethods(MethodOrdererContext context) { MethodDescriptor md1; MethodDescriptor md2; context.getMethodDescriptors().sort((md1, md2)-> md1.getMethod().getName().length().compareTo(md2.getMethod().getName().length())); } }

TestCaseLengthOrder कोड स्पष्टीकरण:

  1. MethodOrderer इंटरफ़ेस को लागू करके एक कस्टम ऑर्डर क्लास बनाया जाता है।
  2. void orderMethods (MethodOrderContext संदर्भ) {} विधि जो कि इंटरफ़ेस मेथोडरडर से लागू की गई अंतर्निहित विधि है। यहां वह जगह है जहां आप परीक्षण के आदेश को लागू करने के तर्क को परिभाषित करते हैं।
  3. MethodDescriptor एक इंटरफ़ेस है जो किसी विधि के बारे में विवरण संलग्न करता है:
    • MethodDescriptor.getMethod () विधि वर्णनकर्ता के लिए विधि नाम प्राप्त करती है।
    • विधि का नाम String के साथ विधि getName () अर्थात MethodDescriptor.getModod ()। GetName () में परिवर्तित हो जाता है।
    • विधि की लंबाई () विधि की लंबाई (जैसे string.length () एक स्ट्रिंग मान की लंबाई लाती है)।
    • सभी विधि नाम एक दूसरे से तुलना () विधि का उपयोग करके की जाती है।
  4. विधि getMethodDescriptors () एक वर्ग में सभी विधि वर्णनकर्ताओं की सूची प्राप्त करता है।
  5. सॉर्ट () विधि MethodDescriptor ऑब्जेक्ट को सॉर्ट करता है।

अब, जब हमने मेथोडर के प्रत्येक एपीआई को स्पष्ट रूप से समझा है, तो हम आशा करते हैं कि उपरोक्त कोड की व्याख्या करना आसान है।

चरण 2 : कस्टम ऑर्डर क्लास का उपयोग करें जैसे कि आप टेस्ट क्लास में किसी भी अंतर्निहित क्रम का उपयोग करते हैं।

एक इनपुट के रूप में एनोटेशन @TestMethodOrder।

JUnit_CustomOrder.java के लिए कोड

@TestMethodOrder(TestCaseLengthOrder.class) class JUnit_CustomOrder{ @Test public void subt(){ } @Test public void add(){ } @Test public void multiply(){ } @Test public void divide(){ }

चरण 3:

का पोस्ट निष्पादन JUnit_CustomOrder.class परीक्षण निष्पादन का क्रम इस प्रकार है कि परीक्षण मामलों के नाम की लंबाई के बढ़ते क्रम के आधार पर:

  1. जोड़ें (),
  2. उप (),
  3. बांटना ()
  4. गुणा ()

निष्कर्ष

JUnit परीक्षण निष्पादन आदेश पर इस ट्यूटोरियल को समाप्त करने के लिए।

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

=> यहाँ JUnit शुरुआती गाइड पर एक नज़र रखना।

अनुशंसित पाठ

^