TestNG - त्वरित गाइड

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

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

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

  • निर्भरता परीक्षण नहीं कर सकते।

  • खराब विन्यास नियंत्रण (सेटअप / टियरडाउन)।

  • घुसपैठ (आपको कक्षाएं बढ़ाने और अपने तरीकों को एक निश्चित तरीके से नाम देने के लिए मजबूर करता है)।

  • स्टैटिक प्रोग्रामिंग मॉडल (आपको अनावश्यक रूप से फिर से संगठित करने के लिए मजबूर करता है)।

  • जटिल परियोजनाओं में परीक्षणों के विभिन्न सुइट्स का प्रबंधन बहुत मुश्किल हो सकता है।

TestNG क्या है?

TestNG की परिभाषा इसके प्रलेखन के अनुसार इस प्रकार है -

TestNG, JUnit और NUnit से प्रेरित एक परीक्षण ढाँचा है, लेकिन कुछ नई कार्यक्षमताओं को प्रस्तुत करता है जो इसे अधिक शक्तिशाली और उपयोग करने में आसान बनाते हैं।

TestNG एक खुला स्रोत स्वचालित परीक्षण ढांचा है; कहाँ पेNG माध्यम NextGeneration। TestNG JUnit (विशेष रूप से JUnit 4) के समान है, लेकिन यह JUnit एक्सटेंशन नहीं है। यह JUnit से प्रेरित है। यह JUnit से बेहतर होने के लिए डिज़ाइन किया गया है, खासकर जब एकीकृत कक्षाओं का परीक्षण। TestNG के निर्माता सेड्रिक बीस्ट हैं ।

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

TestNG सुविधाएँ

  • एनोटेशन का समर्थन करता है।

  • TestNG अधिक जावा और OO सुविधाओं का उपयोग करता है।

  • एकीकृत कक्षाओं के परीक्षण का समर्थन करता है (उदाहरण के लिए, डिफ़ॉल्ट रूप से, हर परीक्षा पद्धति के लिए एक नया परीक्षण वर्ग उदाहरण बनाने की आवश्यकता नहीं है)।

  • रन-टाइम कॉन्फ़िगरेशन / डेटा जानकारी से संकलन-समय परीक्षण कोड को अलग करता है।

  • लचीला रनटाइम कॉन्फ़िगरेशन।

  • 'परीक्षण समूहों' का परिचय देता है। एक बार जब आप अपने परीक्षण संकलित कर लेते हैं, तो आप बस TestNG को सभी "फ्रंट-एंड" टेस्ट, या "फास्ट", "स्लो", "डेटाबेस" टेस्ट आदि चलाने के लिए कह सकते हैं।

  • आश्रित परीक्षण विधियों, समानांतर परीक्षण, लोड परीक्षण और आंशिक विफलता का समर्थन करता है।

  • लचीला प्लग-इन एपीआई।

  • बहु थ्रेडेड परीक्षण के लिए समर्थन।

TestNG जावा के लिए एक रूपरेखा है, इसलिए आपकी मशीन में JDK को स्थापित करने की पहली आवश्यकता है।

व्यवस्था की आवश्यकता

JDK 1.5 या ऊपर।
याद कोई न्यूनतम आवश्यकता नहीं।
डिस्क में जगह कोई न्यूनतम आवश्यकता नहीं।
ऑपरेटिंग सिस्टम कोई न्यूनतम आवश्यकता नहीं।

चरण 1 - अपनी मशीन में जावा इंस्टॉलेशन को सत्यापित करें

कंसोल खोलें और आपके सिस्टम पर आपके द्वारा इंस्टॉल किए गए ऑपरेटिंग सिस्टम के आधार पर एक जावा कमांड निष्पादित करें।

ओएस टास्क आदेश
खिड़कियाँ कमांड कंसोल खोलें c: \> java -version
लिनक्स कमांड टर्मिनल खोलें $ जावा -अविवर्तन
मैक टर्मिनल खोलें मशीन: ~ joseph $ java -version

आइए सभी ऑपरेटिंग सिस्टम के लिए आउटपुट को सत्यापित करें -

ओएस उत्पादन
खिड़कियाँ

जावा संस्करण "1.7.0_25"

जावा (TM) एसई रनटाइम एनवायरनमेंट (बिल्ड 1.7.0_25-b15)

जावा हॉटस्पॉट (TM) 64-बिट सर्वर VM (23.25-b01, मिश्रित मोड का निर्माण)
लिनक्स

जावा संस्करण "1.7.0_25"

जावा (TM) एसई रनटाइम एनवायरनमेंट (बिल्ड 1.7.0_25-b15)

जावा हॉटस्पॉट (TM) 64-बिट सर्वर VM (23.25-b01, मिश्रित मोड का निर्माण)
मैक

जावा संस्करण "1.7.0_25"

जावा (TM) एसई रनटाइम एनवायरनमेंट (बिल्ड 1.7.0_25-b15)

जावा हॉटस्पॉट (TM) 64-बिट सर्वर VM (23.25-b01, मिश्रित मोड का निर्माण)

यदि आपके पास जावा नहीं है, तो जावा सॉफ़्टवेयर डेवलपमेंट किट (एसडीके) से इंस्टॉल करें https://www.oracle.com/technetwork/java/javase/downloads/index.html। हम इस ट्यूटोरियल के लिए जावा 1.7.0_25 को स्थापित संस्करण मान रहे हैं।

चरण 2: जावा पर्यावरण सेट करें

ठीक JAVA_HOMEआधार चर स्थान पर इंगित करने के लिए पर्यावरण चर, जहां जावा आपकी मशीन पर स्थापित है। उदाहरण के लिए,

ओएस उत्पादन
खिड़कियाँ पर्यावरण चर JAVA_HOME को C: \ Program Files \ Java \ jdk1.7.0_25 पर सेट करें।
लिनक्स निर्यात JAVA_HOME = / usr / स्थानीय / जावा-वर्तमान।
मैक निर्यात JAVA_HOME = / लाइब्रेरी / जावा / होम।

सिस्टम पथ में जावा संकलक स्थान को जोड़ें।

ओएस उत्पादन
खिड़कियाँ सिस्टम चर, पथ के अंत में स्ट्रिंग C: \ Program Files \ Java \ jdk1.7.0_25 \ bin जोड़ें।
लिनक्स निर्यात पथ =$PATH:$JAVA_HOME / bin /
मैक की जरूरत नहीं है

कमांड का उपयोग करके जावा इंस्टॉलेशन को सत्यापित करें java -version जैसा कि ऊपर बताया गया है।

चरण 3: TestNG संग्रह डाउनलोड करें

TestNG जार फ़ाइल का नवीनतम संस्करण डाउनलोड करें http://www.testng.org। इस ट्यूटोरियल को लिखने के समय, हमने testng-6.8.jar डाउनलोड किया है और इसे C: \> TestNG फ़ोल्डर में कॉपी किया है।

ओएस संग्रह का नाम
खिड़कियाँ TestNG-6.8.jar
लिनक्स TestNG-6.8.jar
मैक TestNG-6.8.jar

चरण 4: सेट TestNG पर्यावरण

ठीक TESTNG_HOMEआधार चर स्थान पर इंगित करने के लिए पर्यावरण चर, जहां TestNG जार आपकी मशीन पर संग्रहीत है। निम्न तालिका से पता चलता है कि विंडोज, लिनक्स और मैक में पर्यावरण चर को कैसे सेट किया जाए, यह मानते हुए कि हमने स्थान C: \> TestNG पर testng-6.8.jar संग्रहीत किया है।

ओएस विवरण
खिड़कियाँ C: \ TESTNG पर पर्यावरण चर TESTNG_HOME सेट करें।
लिनक्स TESTNG_HOME = / usr / स्थानीय / TESTNG निर्यात करें
मैक TESTNG_HOME = / लाइब्रेरी / TESTNG निर्यात करें

चरण 5: CLASSPATH चर सेट करें

ठीक CLASSPATH पर्यावरण चर TestNG जार स्थान को इंगित करने के लिए।

ओएस विवरण
खिड़कियाँ वातावरण चर CLASSPATH को% CLASSPATH%;% TESTNG_HOME% \ testng-6.8.jar पर सेट करें।
लिनक्स निर्यात CLASSPATH =$CLASSPATH:$TESTNG_HOME / TestNG-6.8.jar।
मैक निर्यात CLASSPATH =$CLASSPATH:$TESTNG_HOME / TestNG-6.8.jar।

चरण 6: TestNG सेटअप का परीक्षण करें

TestNGSimpleTest नामक एक जावा वर्ग फ़ाइल बनाएँ C:\>TestNG_WORKSPACE.

import org.testng.annotations.Test;
import static org.testng.Assert.assertEquals;

public class TestNGSimpleTest {
   @Test
   public void testAdd() {
      String str = "TestNG is working fine";
      AssertEquals("TestNG is working fine", str);
   }
}

TestNG को कई अलग-अलग तरीकों से लागू किया जा सकता है -

  • एक testng.xml फ़ाइल के साथ।
  • ANT के साथ।
  • कमांड लाइन से।

हमें testng.xml फ़ाइल का उपयोग करके आह्वान करते हैं। Testng.xml नाम से एक xml फ़ाइल बनाएँC:\>TestNG_WORKSPACE परीक्षण मामले को निष्पादित करने के लिए।

<?xml version = "1.0" encoding = "UTF-8"?>
<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd" >

<suite name = "Suite1">
   <test name = "test1">
      <classes>
         <class name = "TestNGSimpleTest"/>
      </classes>
   </test>
</suite>

चरण 7: परिणाम सत्यापित करें

का उपयोग कर वर्ग संकलित करें javac संकलक निम्नानुसार है -

C:\TestNG_WORKSPACE>javac TestNGSimpleTest.java

अब, परिणाम देखने के लिए testng.xml लागू करें -

C:\TestNG_WORKSPACE>java -cp "C:\TestNG_WORKSPACE" org.testng.TestNG testng.xml

आउटपुट सत्यापित करें।

===============================================
Suite1
Total tests run: 1, Failures: 0, Skips: 0
===============================================

TestNG में टेस्ट लिखना मूल रूप से निम्नलिखित चरणों को शामिल करता है -

  • अपने परीक्षण का व्यावसायिक तर्क लिखें और अपने कोड में TestNG एनोटेशन डालें।

  • एक testng.xml फ़ाइल में या build.xml में अपने परीक्षण के बारे में जानकारी (जैसे वर्ग का नाम, आप चलाने के लिए चाहते हैं, आदि) जोड़ें।

  • TestNG चलाएं।

यहां, हम POJO वर्ग, बिजनेस लॉजिक क्लास और टेस्ट xml का उपयोग करके TestNG परीक्षण का एक पूरा उदाहरण देखेंगे, जो TestNG द्वारा चलाया जाएगा।

सृजन करना EmployeeDetails.java में C:\>TestNG_WORKSPACE, जो एक POJO वर्ग है।

public class EmployeeDetails {

   private String name;
   private double monthlySalary;
   private int age;
   
   // @return the name

   public String getName() {
      return name;
   }
   
   // @param name the name to set
   
   public void setName(String name) {
      this.name = name;
   }
   
   // @return the monthlySalary

   public double getMonthlySalary() {
      return monthlySalary;
   }
   
   // @param monthlySalary the monthlySalary to set
   
   public void setMonthlySalary(double monthlySalary) {
      this.monthlySalary = monthlySalary;
   }
   
   // @return the age
 
   public int getAge() {
      return age;
   }
   
   // @param age the age to set
 
   public void setAge(int age) {
      this.age = age;
   }
}

EmployeeDetails वर्ग का उपयोग किया जाता है -

  • कर्मचारी के नाम का मूल्य प्राप्त / निर्धारित करना।
  • कर्मचारी के मासिक वेतन का मूल्य निर्धारित करें।
  • कर्मचारी की आयु का मूल्य प्राप्त / निर्धारित करें।

बनाओ EmpBusinessLogic.java में C:\>TestNG_WORKSPACE, जिसमें व्यावसायिक तर्क शामिल हैं।

public class EmpBusinessLogic {

   // Calculate the yearly salary of employee
   public double calculateYearlySalary(EmployeeDetails employeeDetails) {
      double yearlySalary = 0;
      yearlySalary = employeeDetails.getMonthlySalary() * 12;
      return yearlySalary;
   }
	
   // Calculate the appraisal amount of employee
   public double calculateAppraisal(EmployeeDetails employeeDetails) {
   
      double appraisal = 0;
      
      if(employeeDetails.getMonthlySalary() < 10000) {
         appraisal = 500;
         
      } else {
         appraisal = 1000;
      }
      
      return appraisal;
   }
}

EmpBusinessLogic वर्ग की गणना के लिए उपयोग किया जाता है -

  • कर्मचारी का वार्षिक वेतन।
  • कर्मचारी की मूल्यांकन राशि।

अब, एक TestNG क्लास बनाएं TestEmployeeDetails.javaC: \> TestNG_WORKSPACE पर। TestNG क्लास एक जावा क्लास है जिसमें कम से कम एक TestNG एनोटेशन होता है। इस वर्ग में परीक्षण किए जाने वाले परीक्षण मामले हैं। TestNG परीक्षण को @BeforeXXX और @AfterXXX एनोटेशन द्वारा कॉन्फ़िगर किया जा सकता है (हम इसे अध्याय TestNG - निष्पादन प्रक्रिया में देखेंगे ), जो एक निश्चित बिंदु से पहले और बाद में कुछ जावा तर्क करने की अनुमति देता है।

import org.testng.Assert;
import org.testng.annotations.Test;

public class TestEmployeeDetails {
   EmpBusinessLogic empBusinessLogic = new EmpBusinessLogic();
   EmployeeDetails employee = new EmployeeDetails();

   @Test
   public void testCalculateAppriasal() {
   
      employee.setName("Rajeev");
      employee.setAge(25);
      employee.setMonthlySalary(8000);
      
      double appraisal = empBusinessLogic.calculateAppraisal(employee);
      Assert.assertEquals(500, appraisal, 0.0, "500");
   }

   // Test to check yearly salary
   @Test
   public void testCalculateYearlySalary() {
   
      employee.setName("Rajeev");
      employee.setAge(25);
      employee.setMonthlySalary(8000);
      
      double salary = empBusinessLogic.calculateYearlySalary(employee);
      Assert.assertEquals(96000, salary, 0.0, "8000");
   }
}

TestEmployeeDetails वर्ग के तरीकों के परीक्षण के लिए प्रयोग किया जाता है EmpBusinessLogicकक्षा। यह निम्नलिखित है -

  • कर्मचारी के वार्षिक वेतन का परीक्षण करें।

  • कर्मचारी की मूल्यांकन राशि का परीक्षण करता है।

इससे पहले कि आप परीक्षण चला सकें, आपको एक विशेष XML फ़ाइल का उपयोग करके TestNG को कॉन्फ़िगर करना होगा, जिसे पारंपरिक रूप से testng.xml नाम दिया गया है। इस फ़ाइल का सिंटैक्स बहुत सरल है, और इसकी सामग्री नीचे दी गई है। इस फ़ाइल को बनाएँC:\>TestNG_WORKSPACE।

<?xml version = "1.0" encoding = "UTF-8"?>
<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd" >

<suite name = "Suite1">
   <test name = "test1">
      <classes>
         <class name = "TestEmployeeDetails"/>
      </classes>
   </test>
</suite>

उपरोक्त फाइल का विवरण इस प्रकार है -

  • एक सुइट को एक एक्सएमएल फ़ाइल द्वारा दर्शाया गया है। इसमें एक या एक से अधिक परीक्षण हो सकते हैं और इसे <सूट> टैग द्वारा परिभाषित किया गया है।

  • टैग <परीक्षण> एक परीक्षण का प्रतिनिधित्व करता है और इसमें एक या अधिक TestNG कक्षाएं हो सकती हैं।

  • <class> टैग एक TestNG वर्ग का प्रतिनिधित्व करता है। यह एक जावा वर्ग है जिसमें कम से कम एक TestNG एनोटेशन होता है। इसमें एक या एक से अधिक परीक्षण विधियां हो सकती हैं।

जावैक का उपयोग करके टेस्ट केस कक्षाओं को संकलित करें।

C:\TestNG_WORKSPACE>javac EmployeeDetails.java EmpBusinessLogic.java TestEmployeeDetails.java

अब निम्नलिखित कमांड के साथ TestNG -

C:\TestNG_WORKSPACE>java -cp "C:\TestNG_WORKSPACE" org.testng.TestNG testng.xml

यदि सभी सही ढंग से किया गया है, तो आपको अपने परीक्षणों के परिणामों को कंसोल में देखना चाहिए। इसके अलावा, TestNG नामक एक फ़ोल्डर में एक बहुत अच्छी HTML रिपोर्ट बनाता हैtest-outputयह स्वचालित रूप से वर्तमान निर्देशिका में बनाया गया है। यदि आप इसे खोलते हैं और index.html लोड करते हैं, तो आपको नीचे दी गई छवि के समान पृष्ठ दिखाई देगा -

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

JDK 5 में जावा भाषा में एनोटेशन को औपचारिक रूप से जोड़ा गया था, और TestNG ने टेस्ट कक्षाओं को एनोटेट करने के लिए एनोटेशन का उपयोग करने का विकल्प बनाया।

यहाँ उन टिप्पणियों की सूची दी गई है जो TestNG का समर्थन करती है -

अनु क्रमांक। एनोटेशन और विवरण
1

@BeforeSuite

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

@AfterSuite

एनोटेट पद्धति को इस सूट में सभी परीक्षणों के बाद केवल एक बार चलाया जाएगा।
3

@BeforeClass

एनोटेट विधि वर्तमान वर्ग में पहली परीक्षा विधि लागू होने से पहले केवल एक बार चलाई जाएगी।
4

@AfterClass

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

@BeforeTest

एनोटेट विधि को <परीक्षण> टैग के अंदर कक्षाओं से संबंधित किसी भी परीक्षण विधि से पहले चलाया जाएगा।
6

@AfterTest

एनोटेट विधि को सभी परीक्षण विधियों से संबंधित परीक्षण विधियों के अंदर चलाया जाएगा <परीक्षण> टैग चला गया है।
7

@BeforeGroups

समूहों की सूची जो इस कॉन्फ़िगरेशन विधि से पहले चलेगी। इस पद्धति को गारंटी दी जाती है कि इन समूहों में से किसी एक के पहले परीक्षण विधि को शीघ्र ही चलाया जाए।
8

@AfterGroups

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

@BeforeMethod

एनोटेट विधि प्रत्येक परीक्षण विधि से पहले चलाई जाएगी।
10

@AfterMethod

एनोटेट विधि प्रत्येक परीक्षण विधि के बाद चलाई जाएगी।
1 1

@DataProvider

परीक्षण विधि के लिए डेटा की आपूर्ति के रूप में एक विधि को चिह्नित करता है। एनोटेटेड विधि को एक वस्तु [] [] को वापस करना चाहिए, जहां प्रत्येक वस्तु [] को परीक्षण विधि की पैरामीटर सूची सौंपी जा सकती है। इस डेटाप्रोवाइडर से डेटा प्राप्त करने की इच्छा रखने वाली @Test विधि को इस एनोटेशन के नाम के बराबर डेटाप्रोवाइडर नाम का उपयोग करने की आवश्यकता है।
12

@Factory

एक कारखाने के रूप में एक विधि को चिह्नित करता है जो वस्तुओं को लौटाता है जो TestNG द्वारा टेस्ट कक्षाओं के रूप में उपयोग किया जाएगा। विधि वस्तु [] को वापस करना चाहिए।
13

@Listeners

एक परीक्षण वर्ग पर श्रोताओं को परिभाषित करता है।
14

@Parameters

यह बताता है कि कैसे एक @Test विधि में मापदंडों को पारित किया जाए।
15

@Test

परीक्षण के एक भाग के रूप में एक वर्ग या एक विधि को चिह्नित करता है।

एनोटेशन का उपयोग करने के लाभ

एनोटेशन का उपयोग करने के कुछ लाभ निम्नलिखित हैं -

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

  • हम एनोटेशन के लिए अतिरिक्त पैरामीटर पास कर सकते हैं।

  • एनोटेशन को दृढ़ता से टाइप किया जाता है, इसलिए कंपाइलर तुरंत किसी भी गलती को चिह्नित करेगा।

  • टेस्ट क्लासेस को अब कुछ भी विस्तारित करने की आवश्यकता नहीं है (जैसे कि TestCase, JUnit 3 के लिए)।

यह अध्याय TestNG में विधियों के निष्पादन की प्रक्रिया के बारे में बताता है। यह बताई गई विधियों का क्रम बताता है। यहाँ एक उदाहरण के साथ TestNG परीक्षण एपीआई विधियों की निष्पादन प्रक्रिया है।

एक जावा वर्ग फ़ाइल नाम बनाएँ TestngAnnotation.java में C:\>TestNG_WORKSPACE एनोटेशन का परीक्षण करने के लिए।

import org.testng.annotations.Test;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeTest;
import org.testng.annotations.AfterTest;
import org.testng.annotations.BeforeSuite;
import org.testng.annotations.AfterSuite;

public class TestngAnnotation {
   // test case 1
   @Test
   public void testCase1() {
      System.out.println("in test case 1");
   }

   // test case 2
   @Test
   public void testCase2() {
      System.out.println("in test case 2");
   }

   @BeforeMethod
   public void beforeMethod() {
      System.out.println("in beforeMethod");
   }

   @AfterMethod
   public void afterMethod() {
      System.out.println("in afterMethod");
   }

   @BeforeClass
   public void beforeClass() {
      System.out.println("in beforeClass");
   }

   @AfterClass
   public void afterClass() {
      System.out.println("in afterClass");
   }

   @BeforeTest
   public void beforeTest() {
      System.out.println("in beforeTest");
   }

   @AfterTest
   public void afterTest() {
      System.out.println("in afterTest");
   }

   @BeforeSuite
   public void beforeSuite() {
      System.out.println("in beforeSuite");
   }

   @AfterSuite
   public void afterSuite() {
      System.out.println("in afterSuite");
   }

}

इसके बाद, फाइल बनाते हैं testng.xml में C:\>TestNG_WORKSPACE एनोटेशन निष्पादित करने के लिए।

<?xml version = "1.0" encoding = "UTF-8"?>
<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd" >

<suite name = "Suite1">
   <test name = "test1">
      <classes>
         <class name = "TestngAnnotation"/>
      </classes>
   </test>
</suite>

जावैक का उपयोग करके टेस्ट केस क्लास को संकलित करें।

C:\TestNG_WORKSPACE>javac TestngAnnotation.java

अब, testng.xml चलाएं, जो प्रदान किए गए टेस्ट केस क्लास में परिभाषित टेस्ट केस को चलाएगा।

C:\TestNG_WORKSPACE>java org.testng.TestNG testng.xml

आउटपुट सत्यापित करें।

in beforeSuite
in beforeTest
in beforeClass
in beforeMethod
in test case 1
in afterMethod
in beforeMethod
in test case 2
in afterMethod
in afterClass
in afterTest
in afterSuite

===============================================
Suite
Total tests run: 2, Failures: 0, Skips: 0
===============================================

उपरोक्त आउटपुट के आधार पर, निष्पादन प्रक्रिया निम्नानुसार है -

  • सबसे पहले, पहले (पहले) विधि को केवल एक बार निष्पादित किया जाता है।

  • अंत में, afterSuite () विधि केवल एक बार निष्पादित होती है।

  • पहले के तरीके भी (), पहले (पहले), बाद में (), और बाद के तरीके केवल एक बार ही निष्पादित होते हैं।

  • मेथोड () विधि प्रत्येक परीक्षण मामले के लिए निष्पादित होती है, लेकिन परीक्षण मामले को निष्पादित करने से पहले।

  • afterMethod () विधि प्रत्येक परीक्षण मामले के लिए निष्पादित होती है लेकिन परीक्षण मामले को निष्पादित करने के बाद।

  • मेथेथोड () और आफ्टरमेथोड () से पहले, प्रत्येक टेस्ट केस निष्पादित होता है।

परीक्षण मामलों का उपयोग करके निष्पादित किया जाता है TestNGकक्षा। यह वर्ग TestNG ढांचे में परीक्षण चलाने के लिए मुख्य प्रवेश बिंदु है। उपयोगकर्ता अपनी खुद की TestNG ऑब्जेक्ट बना सकते हैं और इसे कई अलग-अलग तरीकों से लागू कर सकते हैं जैसे कि -

  • मौजूदा testng.xml पर।

  • पूरी तरह से जावा से निर्मित एक सिंथेटिक testng.xml पर।

  • सीधे परीक्षण कक्षाओं की स्थापना करके।

आप यह भी परिभाषित कर सकते हैं कि किन समूहों को शामिल करना या बाहर करना, पैरामीटर असाइन करना आदि कमांड लाइन के पैरामीटर हैं -

  • -d outputdir: आउटपुट डायरेक्टरी निर्दिष्ट करें।

  • -estestassass class_name: एक या कई वर्ग नामों को निर्दिष्ट करता है।

  • -estestar jar_name: परीक्षणों से युक्त जार निर्दिष्ट करता है।

  • -सुवेदिर src1; src2:; स्रोत निर्देशिकाओं की अलग-अलग सूची (जब केवल javadoc एनोटेशन का उपयोग किया जाता है)।

  • -target

  • -groups

  • -testrunfactory

  • -listener

हम नीचे दिए गए उदाहरण में TestNG ऑब्जेक्ट को मौजूदा testng.xml बनाएंगे।

एक क्लास बनाएँ

परीक्षण करने के लिए एक जावा वर्ग बनाएँ, कहते हैं, MessageUtil.java में C:\>TestNG_WORKSPACE।

/*
* This class prints the given message on console.
*/

public class MessageUtil {

   private String message;

   //Constructor
   //@param message to be printed
   public MessageUtil(String message) {
      this.message = message;
   }
      
   // prints the message
   public String printMessage() {
      System.out.println(message);
      return message;
   }   
}

टेस्ट केस क्लास बनाएं

  • एक जावा टेस्ट क्लास बनाएं, कहें, SampleTest.java।

  • अपने परीक्षण वर्ग में एक परीक्षण विधि testPrintMessage () जोड़ें।

  • मेथड टेस्टप्रिंटमैसेज () में एनोटेशन @ टेस्ट जोड़ें।

  • परीक्षण की स्थिति को लागू करें और TestNG के एपीआई का उपयोग कर स्थिति की जाँच करें।

जावा क्लास की एक फ़ाइल बनाएँ SampleTest.java में C:\>TestNG_WORKSPACE।

import org.testng.Assert;
import org.testng.annotations.Test;

public class SampleTest {
	
   String message = "Hello World";
   MessageUtil messageUtil = new MessageUtil(message);

   @Test
   public void testPrintMessage() {
      Assert.assertEquals(message, messageUtil.printMessage());
   }
}

Testng.xml बनाएँ

इसके बाद, testng.xml फ़ाइल बनाएँ C:\>TestNG_WORKSPACE, परीक्षण मामले को निष्पादित करने के लिए। यह फ़ाइल XML में आपके संपूर्ण परीक्षण को कैप्चर करती है। यह फ़ाइल आपके सभी परीक्षण सूट और उनके मापदंडों का एक फ़ाइल में वर्णन करना आसान बनाती है, जिसे आप अपने कोड रिपॉजिटरी या सहकर्मियों को ई-मेल में देख सकते हैं। यह आपके परीक्षणों के सबसेट को निकालने या कई रनटाइम कॉन्फ़िगरेशन को विभाजित करने में भी आसान बनाता है (उदाहरण के लिए, testngdatabase.xml केवल वही परीक्षण चलाएगा जो आपके डेटाबेस का उपयोग करते हैं)।

<?xml version = "1.0" encoding = "UTF-8"?>

<suite name = "Sample test Suite">
   <test name = "Sample test">
      <classes>
         <class name = "SampleTest" />
      </classes>
   </test>
</suite>

Javac का उपयोग करके परीक्षण केस संकलित करें।

C:\TestNG_WORKSPACE>javac MessageUtil.java SampleTest.java

अब, testng.xml चलाएँ, जो <test> टैग में परिभाषित परीक्षण केस चलाएगा।

C:\TestNG_WORKSPACE>java -cp "C:\TestNG_WORKSPACE" org.testng.TestNG testng.xml

आउटपुट सत्यापित करें।

Hello World

===============================================
Sample test Suite
Total tests run: 1, Failures: 0, Skips: 0
===============================================

ए test suiteकिसी व्यवहार या सॉफ़्टवेयर प्रोग्राम के व्यवहार के सेट का परीक्षण करने के लिए किए गए परीक्षण मामलों का एक संग्रह है। TestNG में, हम परीक्षण स्रोत कोड में एक सूट को परिभाषित नहीं कर सकते हैं, लेकिन यह एक एक्सएमएल फ़ाइल द्वारा दर्शाया गया है, क्योंकि सूट निष्पादन की विशेषता है। यह परीक्षणों के लचीले विन्यास को भी चलाने की अनुमति देता है । एक सूट में एक या अधिक परीक्षण शामिल हो सकते हैं और इसे <सूट> टैग द्वारा परिभाषित किया जाता है।

<सूट> आपके testng.xml का मूल टैग है। यह एक परीक्षण सूट का वर्णन करता है, जो बदले में कई <परीक्षण> वर्गों से बना है।

निम्न तालिका उन सभी कानूनी विशेषताओं को सूचीबद्ध करती है जिन्हें <सूट> स्वीकार करता है।

अनु क्रमांक। विशेषता और विवरण
1

name

इस सुइट का नाम। यह है एकmandatory विशेषता।
2

verbose

इस रन के लिए स्तर या वर्बोसिटी।
3

parallel

क्या TestNG को इस सूट को चलाने के लिए अलग-अलग थ्रेड चलाने चाहिए।
4

thread-count

यदि समानांतर मोड सक्षम किया गया है, तो उपयोग करने के लिए थ्रेड्स की संख्या (अन्य वार अनदेखा)।
5

annotations

आपके परीक्षण में आपके द्वारा उपयोग किए जा रहे एनोटेशन के प्रकार।
6

time-out

डिफ़ॉल्ट समयबाह्य जो इस परीक्षण में पाए गए सभी परीक्षण विधियों पर उपयोग किया जाएगा।

इस अध्याय में, हम आपको एक उदाहरण दिखाएंगे जिसमें दो टेस्ट क्लास, टेस्ट 1 और टेस्ट 2 हैं, टेस्ट सूट का उपयोग करके एक साथ चलाने के लिए।

एक क्लास बनाएँ

परीक्षण करने के लिए एक जावा वर्ग बनाएँ, कहते हैं, MessageUtil.java में C:\>JUNIT_WORKSPACE।

/*
* This class prints the given message on console.
*/

public class MessageUtil {
   private String message;

   // Constructor
   // @param message to be printed
   public MessageUtil(String message) {
      this.message = message;
   }

   // prints the message
   public String printMessage() {
      System.out.println(message);
      return message;
   }

   // add "Hi!" to the message
   public String salutationMessage() {
      message = "Hi!" + message;
      System.out.println(message);
      return message;
   }
}

टेस्ट केस क्लासेस बनाएं

नाम से एक जावा वर्ग फ़ाइल बनाएँ Test1.java में C:\>TestNG_WORKSPACE।

import org.testng.Assert;
import org.testng.annotations.Test;

public class Test1 {
   String message = "Manisha";
   MessageUtil messageUtil = new MessageUtil(message);

   @Test
   public void testPrintMessage() {
      System.out.println("Inside testPrintMessage()");
      Assert.assertEquals(message, messageUtil.printMessage());
   }
}

नाम से एक जावा वर्ग फ़ाइल बनाएँ Test2.java में C:\>TestNG_WORKSPACE।

import org.testng.Assert;
import org.testng.annotations.Test;

public class Test2 {
   String message = "Manisha";	
   MessageUtil messageUtil = new MessageUtil(message);
	 
   @Test
   public void testSalutationMessage() {
      System.out.println("Inside testSalutationMessage()");
      message = "Hi!" + "Manisha";
      Assert.assertEquals(message,messageUtil.salutationMessage());
   }
}

अब, testng.xml को लिखते हैं C:\>TestNG_WORKSPACE, जिसमें <सुइट> टैग निम्नानुसार होगा -

<?xml version = "1.0" encoding = "UTF-8"?>
<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd" >

<suite name = "Suite1">

   <test name = "exampletest1">
      <classes>
         <class name = "Test1" />
      </classes>
   </test>
  
   <test name = "exampletest2">
      <classes>
         <class name = "Test2" />
      </classes>
   </test>
  
</suite>

सुइट 1 शामिल हैं exampletest1 तथा exampletest2।

जावा का उपयोग करके सभी जावा कक्षाओं को संकलित करें।

C:\TestNG_WORKSPACE>javac MessageUtil.java Test1.java Test2.java

अब, testng.xml चलाएं, जो प्रदान किए गए टेस्ट केस क्लास में परिभाषित टेस्ट केस को चलाएगा।

C:\TestNG_WORKSPACE>java -cp "C:\TestNG_WORKSPACE" org.testng.TestNG testng.xml

आउटपुट सत्यापित करें।

Inside testPrintMessage()
Manisha
Inside testSalutationMessage()
Hi!Manisha

===============================================
Suite1
Total tests run: 2, Failures: 0, Skips: 0
===============================================

आप परीक्षण-आउटपुट फ़ोल्डर भी देख सकते हैं । Suite1 फ़ोल्डर के अंतर्गत , आप दो html फाइलें बनाकर देख सकते हैं, exampletest1.html और exampletest2.html, जो इस प्रकार दिखेंगे:

कभी-कभी, ऐसा होता है कि हमारा कोड तैयार नहीं होता है और उस पद्धति / कोड को परीक्षण करने के लिए लिखा गया टेस्ट केस विफल हो जाता है। ऐसे मामलों में, एनोटेशन@Test(enabled = false) इस परीक्षण मामले को अक्षम करने में मदद करता है।

यदि टेस्ट पद्धति को @ टेस्ट (सक्षम = गलत) के साथ एनोटेट किया जाता है , तो परीक्षण का परीक्षण जो परीक्षण के लिए तैयार नहीं है, उसे दरकिनार कर दिया जाता है।

अब, कार्रवाई में @Test (सक्षम = गलत) देखें।

एक क्लास बनाएँ

परीक्षण करने के लिए एक जावा वर्ग बनाएँ, कहते हैं, MessageUtil.java में C:\>TestNG_WORKSPACE।

/*
* This class prints the given message on console.
*/

public class MessageUtil {

   private String message;

   //Constructor
   //@param message to be printed
   public MessageUtil(String message) {
      this.message = message; 
   }

   // prints the message
   public String printMessage() {
      System.out.println(message);
      return message;
   }   

   // add "Hi!" to the message
   public String salutationMessage() {
      message = "Hi!" + message;
      System.out.println(message);
      return message;
   }   
}

टेस्ट केस क्लास बनाएं

  • एक जावा टेस्ट क्लास बनाएं, कहें, IgnoreTest.java।

  • परीक्षण विधियाँ जोड़ें, TestPrintMessage (), और, TestSalutationMessage (), अपने परीक्षण वर्ग में।

  • विधि testPrintMessage () में एनोटेशन @ टेस्ट (सक्षम = गलत) जोड़ें।

नाम से एक जावा वर्ग फ़ाइल बनाएँ IgnoreTest.java में C:\>TestNG_WORKSPACE।

import org.testng.Assert;
import org.testng.annotations.Test;

public class IgnoreTest {
   String message = "Manisha";
   MessageUtil messageUtil = new MessageUtil(message);

   @Test(enabled = false)
   public void testPrintMessage() {
      System.out.println("Inside testPrintMessage()");
      message = "Manisha";
      Assert.assertEquals(message, messageUtil.printMessage());
   }

   @Test
   public void testSalutationMessage() {
      System.out.println("Inside testSalutationMessage()");
      message = "Hi!" + "Manisha";
      Assert.assertEquals(message, messageUtil.salutationMessage());
   }
}

Testng.xml बनाएँ

में testng.xml बनाएँ C:\>TestNG_WORKSPACE परीक्षण मामले को निष्पादित करने के लिए।

<?xml version = "1.0" encoding = "UTF-8"?>
<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd" >

<suite name = "Suite1">
   <test name = "test1">
      <classes>
         <class name = "IgnoreTest" />
      </classes>
   </test>
</suite>

जावा का उपयोग करके मैसेज यूटिल और टेस्ट केस कक्षाओं को संकलित करें।

C:\TestNG_WORKSPACE>javac MessageUtil.java IgnoreTest.java

अब, testng.xml चलाएं, जो TestPrintMessage () टेस्ट केस क्लास में दिए गए टेस्ट केस को नहीं चलाएगा।

C:\TestNG_WORKSPACE>java -cp "C:\TestNG_WORKSPACE" org.testng.TestNG testng.xml

आउटपुट सत्यापित करें। testPrintMessage () परीक्षण मामले का परीक्षण नहीं किया गया है।

Inside testSalutationMessage()
Hi!Manisha

===============================================
Suite1
Total tests run: 1, Failures: 0, Skips: 0
===============================================

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

समूह परीक्षण TestNG में एक नई अभिनव विशेषता है, जो JUnit ढांचे में मौजूद नहीं है। यह आपको उचित भागों में तरीकों को भेजने और परीक्षण विधियों के परिष्कृत समूह बनाने की अनुमति देता है।

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

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

समूह <test> टैग का उपयोग करके आपके testng.xml फ़ाइल में निर्दिष्ट हैं। यह <परीक्षण> या <सूट> टैग के तहत पाया जा सकता है। <सूट> टैग में निर्दिष्ट समूह नीचे दिए गए सभी <परीक्षण> टैग पर लागू होते हैं।

अब, आइए एक उदाहरण लेते हैं कि समूह परीक्षण कैसे काम करता है।

एक क्लास बनाएँ

परीक्षण करने के लिए एक जावा वर्ग बनाएँ, कहते हैं, MessageUtil.java में C:\> TestNG_WORKSPACE।

/*
* This class prints the given message on console.
*/
public class MessageUtil {
   private String message;

   // Constructor
   // @param message to be printed
   public MessageUtil(String message) {
      this.message = message;
   }

   // prints the message
   public String printMessage() {
      System.out.println(message);
      return message;
   }

   // add "tutorialspoint" to the message
   public String salutationMessage() {
      message = "tutorialspoint" + message;
      System.out.println(message);
      return message;
   }

   // add "www." to the message
   public String exitMessage() {
      message = "www." + message;
      System.out.println(message);
      return message;
   }
}

टेस्ट केस क्लास बनाएं

  • एक जावा टेस्ट क्लास बनाएं, कहें, GroupTestExample.java।

  • परीक्षण विधियाँ, TestPrintMessage () और testSalutationMessage () जोड़ें, अपने परीक्षण वर्ग में जोड़ें।

  • परीक्षा विधि को दो श्रेणियों में समूहित करें -

    • Check-in tests (checkintest)- नया कोड सबमिट करने से पहले ये परीक्षण चलाए जाने चाहिए। वे आम तौर पर तेज होना चाहिए और बस सुनिश्चित करें कि कोई बुनियादी कार्यक्षमता टूटी नहीं है।

    • Functional tests (functest) - इन परीक्षणों में आपके सॉफ़्टवेयर की सभी कार्यक्षमताओं को शामिल किया जाना चाहिए और दिन में कम से कम एक बार चलाया जाना चाहिए, हालांकि आदर्श रूप से आप उन्हें लगातार चलाना चाहते हैं।

नाम से जावा वर्ग फ़ाइल बनाएँ GroupTestExample.java में C:\>TestNG_WORKSPACE।

import org.testng.Assert;
import org.testng.annotations.Test;

public class GroupTestExample {
   String message = ".com";
   MessageUtil messageUtil = new MessageUtil(message);

   @Test(groups = { "functest", "checkintest" })
   
   public void testPrintMessage() {
      System.out.println("Inside testPrintMessage()");
      message = ".com";
      Assert.assertEquals(message, messageUtil.printMessage());
   }

   @Test(groups = { "checkintest" })
   
   public void testSalutationMessage() {
      System.out.println("Inside testSalutationMessage()");
      message = "tutorialspoint" + ".com";
      Assert.assertEquals(message, messageUtil.salutationMessage());
   }

   @Test(groups = { "functest" })
   
   public void testingExitMessage() {
      System.out.println("Inside testExitMessage()");
      message = "www." + "tutorialspoint"+".com";
      Assert.assertEquals(message, messageUtil.exitMessage());
   }  
}

Testng.xml बनाएँ

में testng.xml बनाएँ C:\> TestNG_WORKSPACE, परीक्षण मामले को निष्पादित करने के लिए। यहाँ, हम केवल उन्हीं परीक्षण, कि समूह के हैं क्रियान्वित किया जाएगा functest ।

<?xml version = "1.0" encoding = "UTF-8"?>
<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd" >

<suite name = "Suite1">
   <test name = "test1">
   
      <groups>
         <run>
            <include name = "functest" />
         </run>
      </groups>

      <classes>
         <class name = "GroupTestExample" />
      </classes>
   
   </test>
</suite>

मैसेज यूटिल का संकलन करें, टेस्ट केस क्लासेस जेवाक का उपयोग करते हुए।

C:\TestNG_WORKSPACE>javac MessageUtil.java GroupTestExample.java

अब, testng.xml चलाएं, जो केवल विधि testPrintMessage () चलाएगा, क्योंकि यह समूह कार्यशील के अंतर्गत आता है ।

C:\TestNG_WORKSPACE>java -cp "C:\TestNG_WORKSPACE" org.testng.TestNG testng.xml

आउटपुट सत्यापित करें। केवल विधि testPrintMessage () निष्पादित की गई है।

Inside testPrintMessage()
.com
Inside testExitMessage()
www..com

===============================================
Suite1
Total tests run: 2, Failures: 1, Skips: 0
===============================================

समूह का समूह

समूह अन्य समूहों को भी शामिल कर सकते हैं। इन समूहों को कहा जाता हैMetaGroups। उदाहरण के लिए, यदि आप एक समूह निर्धारित कर सकते हैं सब कि शामिल checkintest और functest । चलिए हमारी testng.xml फ़ाइल को निम्न प्रकार से संशोधित करते हैं -

<?xml version = "1.0" encoding = "UTF-8"?>
<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd" >
<suite name = "Suite1">
   <test name = "test1">
   
      <groups>
      
         <define name = "all">
            <include name = "functest"/>
            <include name = "checkintest"/>
         </define>
         
         <run>
            <include name = "all"/>
         </run>
         
      </groups>
      
      <classes>
         <class name = "GroupTestExample" />
      </classes>
      
   </test>
</suite>

उपरोक्त testng.xml को निष्पादित करने से सभी तीन परीक्षण निष्पादित होंगे और आपको निम्नलिखित परिणाम देंगे -

Inside testPrintMessage()
.com
Inside testSalutationMessage()
tutorialspoint.com
Inside testExitMessage()
www.tutorialspoint.com

===============================================
Suite1
Total tests run: 3, Failures: 0, Skips: 0
===============================================

बहिष्करण समूह

आप नीचे दिखाए गए अनुसार <बहिष्कृत> टैग का उपयोग करके किसी समूह को अनदेखा कर सकते हैं -

<?xml version = "1.0" encoding = "UTF-8"?>
<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd" >
<suite name = "Suite1">
   <test name = "test1">

      <groups>
         <define name = "all">
            <exclude name = "functest"/>
            <include name = "checkintest"/>
         </define>

         <run>
            <include name = "all"/>
         </run>
      </groups>

      <classes>
         <class name = "GroupTestExample" />
      </classes>

   </test>
</suite>

TestNG कोड के अपवाद हैंडलिंग को ट्रेस करने का एक विकल्प प्रदान करता है। आप परीक्षण कर सकते हैं कि कोई कोड वांछित अपवाद फेंकता है या नहीं। यहां हीexpectedExceptionsपैरामीटर का उपयोग @Test एनोटेशन के साथ किया जाता है। अब, चलो देखते हैं@Test(expectedExceptions) कार्रवाई में।

एक क्लास बनाएँ

परीक्षण करने के लिए एक जावा वर्ग बनाएँ, कहते हैं, MessageUtil.java में C:\> TestNG_WORKSPACE। PrintMessage () विधि के अंदर एक त्रुटि स्थिति जोड़ें।

/*
* This class prints the given message on console.
*/
public class MessageUtil {

   private String message;

   //Constructor
   //@param message to be printed
   public MessageUtil(String message) {
      this.message = message; 
   }

   // prints the message
   public void printMessage() {
      System.out.println(message);
      int a =0;
      int b = 1/a;
   }   

   // add "Hi!" to the message
   public String salutationMessage() {
      message = "Hi!" + message;
      System.out.println(message);
      return message;
   }   
}

टेस्ट केस क्लास बनाएं

  • एक जावा टेस्ट क्लास बनाएं, कहें, ExpectedExceptionTest.java।

  • TestPrintMessage () परीक्षण मामले में एक अपेक्षित अपवाद अंकगणित अपवाद जोड़ें।

नाम से एक जावा वर्ग फ़ाइल बनाएँ ExpectedExceptionTest.java में C:\> TestNG_WORKSPACE।

import org.testng.Assert;
import org.testng.annotations.Test;

public class ExpectedExceptionTest {
   String message = "Manisha";	
   MessageUtil messageUtil = new MessageUtil(message);
	   
   @Test(expectedExceptions = ArithmeticException.class)
   public void testPrintMessage() {	
      System.out.println("Inside testPrintMessage()");     
      messageUtil.printMessage();     
   }
   
   @Test
   public void testSalutationMessage() {
      System.out.println("Inside testSalutationMessage()");
      message = "Hi!" + "Manisha";
      Assert.assertEquals(message,messageUtil.salutationMessage());
   }
}

टेस्ट रनर बनाएं

में testng.xml बनाएँ C:\>TestNG_WORKSPACE परीक्षण मामले को निष्पादित करने के लिए।

<?xml version = "1.0" encoding = "UTF-8"?>
<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd" >

<suite name = "Suite1">
   <test name = "test1">
      <classes>
         <class name = "ExpectedExceptionTest" />
      </classes>
   </test>
</suite>

मैसेज यूटिल का संकलन करें, टेस्ट केस क्लासेस जेवाक का उपयोग करते हुए।

C:\TestNG_WORKSPACE>javac MessageUtil.java TestJunit.java

अब, टेस्ट रनर चलाएं, जो प्रदान किए गए टेस्ट केस क्लास में परिभाषित टेस्ट केस चलाएगा।

C:\TestNG_WORKSPACE>java -cp "C:\TestNG_WORKSPACE" org.testng.TestNG testng.xml

आउटपुट सत्यापित करें। testPrintMessage () परीक्षण मामला पारित किया जाएगा।

Inside testPrintMessage()
Manisha
Inside testSalutationMessage()
Hi!Manisha

===============================================
Suite1
Total tests run: 2, Failures: 0, Skips: 0
===============================================

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

TestNG आपको निर्भरता को या तो निर्दिष्ट करने की अनुमति देता है -

  • विशेषता का उपयोग करता है @Test एनोटेशन, या में ORMMethods।

  • विशेषता का उपयोग करते हुए @ वॉयस एनोटेशन में निर्भर करता है।

उदाहरण का उपयोग करता है निर्भरऑनमेथोड्स

एक क्लास बनाएँ

परीक्षण करने के लिए एक जावा वर्ग बनाएँ, कहते हैं, MessageUtil.java में C:\>TestNG_WORKSPACE।

public class MessageUtil {
   private String message;

   // Constructor
   // @param message to be printed
   public MessageUtil(String message) {
      this.message = message;
   }

   // prints the message
   public String printMessage() {
      System.out.println(message);
      return message;
   }

   // add "Hi!" to the message
   public String salutationMessage() {
      message = "Hi!" + message;
      System.out.println(message);
      return message;
   }
}

टेस्ट केस क्लास बनाएं

  • एक जावा परीक्षण वर्ग बनाएं, कहते हैं, निर्भरता परीक्षण UAnotnot.java।

  • परीक्षण विधियाँ जोड़ें, TestPrintMessage () और testSalutationMessage (), और initEnvironmentTest (), अपने परीक्षण वर्ग में।

  • विशेषता जोड़ें dependsOnMethods = {"initEnvironmentTest"} के @ सबसे बड़े एनोटेशन के लिए testSalutationMessage() तरीका।

एक जावा वर्ग फ़ाइल नाम बनाएँ DependencyTestUsingAnnotation.java में C:\>TestNG_WORKSPACE।

import org.testng.Assert;
import org.testng.annotations.Test;

public class DependencyTestUsingAnnotation {
String message = "Manisha";
MessageUtil messageUtil = new MessageUtil(message);

   @Test
   public void testPrintMessage() {
      System.out.println("Inside testPrintMessage()");
      message = "Manisha";
      Assert.assertEquals(message, messageUtil.printMessage());
   }

   @Test(dependsOnMethods = { "initEnvironmentTest" })
   public void testSalutationMessage() {
      System.out.println("Inside testSalutationMessage()");
      message = "Hi!" + "Manisha";
      Assert.assertEquals(message, messageUtil.salutationMessage());
   }

   @Test
   public void initEnvironmentTest() {
      System.out.println("This is initEnvironmentTest");
   }
}

Testng.xml बनाएँ

में testng.xml बनाएँ C:\>TestNG_WORKSPACE परीक्षण मामले को निष्पादित करने के लिए।

<?xml version = "1.0" encoding = "UTF-8"?>
<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd" >

<suite name = "Suite1">
   <test name = "test1">
      <classes>
         <class name = "DependencyTestUsingAnnotation" />
      </classes>
   </test>
</suite>

मैसेज यूटिल का संकलन करें, टेस्ट केस क्लासेस जेवाक का उपयोग करते हुए।

C:\TestNG_WORKSPACE>javac MessageUtil.java DependencyTestUsingAnnotation.java

अब, testng.xml चलाएँ, जो inSEnvironmentTest () विधि के निष्पादन के बाद ही testSalutationMessage () विधि चलाएगा।

C:\TestNG_WORKSPACE>java -cp "C:\TestNG_WORKSPACE" org.testng.TestNG testng.xml

आउटपुट सत्यापित करें।

This is initEnvironmentTest
Inside testPrintMessage()
Manisha
Inside testSalutationMessage()
Hi!Manisha

===============================================
Suite1
Total tests run: 3, Failures: 0, Skips: 0
===============================================

उदाहरण का उपयोग करता है OnOnGroups

आपके पास ऐसे तरीके भी हो सकते हैं जो पूरे समूहों पर निर्भर करते हैं। इसे प्रदर्शित करने के लिए एक उदाहरण है।

एक क्लास बनाएँ

परीक्षण करने के लिए एक जावा वर्ग बनाएँ, कहते हैं, MessageUtil.java में C:\>TestNG_WORKSPACE।

public class MessageUtil {
   private String message;

   // Constructor
   // @param message to be printed
   public MessageUtil(String message) {
      this.message = message;
   }

   // prints the message
   public String printMessage() {
      System.out.println(message);
      return message;
   }

   // add "Hi!" to the message
   public String salutationMessage() {
      message = "Hi!" + message;
      System.out.println(message);
      return message;
   }
}

टेस्ट केस क्लास बनाएं

  • एक जावा परीक्षण वर्ग बनाएं, कहते हैं, निर्भरता परीक्षण UAnotnot.java।

  • परीक्षण विधियाँ जोड़ें, TestPrintMessage () testSalutationMessage (), और initEnvironmentTest () को अपने परीक्षण वर्ग में जोड़ें, और उन्हें समूह "init" में जोड़ें।

  • विशेषता जोड़ें dependsOnMethods = {"init.*"} के @ सबसे बड़े एनोटेशन के लिए testSalutationMessage() तरीका।

नाम से एक जावा वर्ग फ़ाइल बनाएँ DependencyTestUsingAnnotation.java में C:\>TestNG_WORKSPACE।

import org.testng.Assert;
import org.testng.annotations.Test;

public class DependencyTestUsingAnnotation {
   String message = "Manisha";
   MessageUtil messageUtil = new MessageUtil(message);

   @Test(groups = { "init" })
   public void testPrintMessage() {
      System.out.println("Inside testPrintMessage()");
      message = "Manisha";
      Assert.assertEquals(message, messageUtil.printMessage());
   }

   @Test(dependsOnGroups = { "init.*" })
   public void testSalutationMessage() {
      System.out.println("Inside testSalutationMessage()");
      message = "Hi!" + "Manisha";
      Assert.assertEquals(message, messageUtil.salutationMessage());
   }

   @Test(groups = { "init" })
   public void initEnvironmentTest() {
      System.out.println("This is initEnvironmentTest");
   }
}

इस उदाहरण में, testSalutationMessage () को किसी भी समूह के आधार पर घोषित किया जाता है, जो नियमित अभिव्यक्ति "init। *" से मेल खाता है, जो गारंटी देता है कि तरीके testPrintMessage () और initEnvironmentTest () हमेशा testSalutationMessage () से पहले लागू किए जाएंगे।

यदि एक विधि पर निर्भर विफल रहता है, और आप इस पर एक कठिन निर्भरता है (हमेशा = गलत, जो कि डिफ़ॉल्ट है), इस पर निर्भर करने वाले तरीके विफल नहीं बल्कि SKIP के रूप में चिह्नित हैं। अंतिम रिपोर्ट में इस तरह के स्केप किए गए तरीकों को रिपोर्ट किया जाएगा (HTML में एक रंग में जो न तो लाल है और न ही हरा है), जो कि महत्वपूर्ण है क्योंकि स्किप किए गए तरीके आवश्यक रूप से विफल नहीं होते हैं।

Testng.xml बनाएँ

में testng.xml बनाएँ C:\>TestNG_WORKSPACE परीक्षण मामले को निष्पादित करने के लिए।

<?xml version = "1.0" encoding = "UTF-8"?>
<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd" >

<suite name = "Suite1">
   <test name = "test1">
      <classes>
         <class name = "DependencyTestUsingAnnotation" />
      </classes>
   </test>
</suite>

मैसेज यूटिल का संकलन करें, टेस्ट केस क्लासेस जेवाक का उपयोग करते हुए।

C:\TestNG_WORKSPACE>javac MessageUtil.java DependencyTestUsingAnnotation.java

अब, testng.xml चलाएँ, जो inSEnvironmentTest () विधि के निष्पादन के बाद ही testSalutationMessage () विधि चलाएगा ।

C:\TestNG_WORKSPACE>java -cp "C:\TestNG_WORKSPACE" org.testng.TestNG testng.xml

आउटपुट सत्यापित करें।

This is initEnvironmentTest
Inside testPrintMessage()
Manisha
Inside testSalutationMessage()
Hi!Manisha

===============================================
Suite1
Total tests run: 3, Failures: 0, Skips: 0
===============================================

निर्भरऑनग्रुप्स बनाम निर्भरऑनमेथोड्स

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

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

TestNG में उपलब्ध एक और दिलचस्प विशेषता है parametric testing। ज्यादातर मामलों में, आप एक ऐसे परिदृश्य में आएंगे, जहाँ व्यापार तर्क के लिए अलग-अलग परीक्षणों की संख्या की आवश्यकता होती है।Parameterized tests डेवलपर्स को विभिन्न मूल्यों का उपयोग करके एक ही परीक्षण को बार-बार चलाने की अनुमति दें।

TestNG आपको दो अलग-अलग तरीकों से सीधे अपने परीक्षण विधियों में पैरामीटर पास करने देता है -

  • Testng.xml के साथ
  • डेटा प्रदाताओं के साथ

Testng.xml के साथ पैरामीटर्स पास करना

इस तकनीक के साथ, आप testng.xml फ़ाइल में सरल मापदंडों को परिभाषित करते हैं और फिर उन मापदंडों को स्रोत फ़ाइलों में संदर्भित करते हैं। आइए हमारे पास एक उदाहरण है कि मापदंडों को पारित करने के लिए इस तकनीक का उपयोग कैसे करें।

टेस्ट केस क्लास बनाएं

  • एक जावा टेस्ट क्लास बनाएं, कहते हैं, ParameterizedTest1.java।

  • परीक्षण पद्धति पैरामीटर जोड़ें () को अपने परीक्षण वर्ग में जोड़ें। यह विधि इनपुट पैरामीटर के रूप में एक स्ट्रिंग लेती है।

  • इस विधि में एनोटेशन @Parameters ("myName") जोड़ें । पैरामीटर को testng.xml से एक मान दिया जाएगा, जिसे हम अगले चरण में देखेंगे।

नाम से एक जावा वर्ग फ़ाइल बनाएँ ParameterizedTest1.java में C:\>TestNG_WORKSPACE।

import org.testng.annotations.Parameters;
import org.testng.annotations.Test;

public class ParameterizedTest1 {
   @Test
   @Parameters("myName")
   public void parameterTest(String myName) {
      System.out.println("Parameterized value is : " + myName);
   }
}

Testng.xml बनाएँ

में testng.xml बनाएँ C:\>TestNG_WORKSPACE परीक्षण मामले को निष्पादित करने के लिए।

<?xml version = "1.0" encoding = "UTF-8"?>
<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd" >

<suite name = "Suite1">
   <test name = "test1">
   
      <parameter name = "myName" value="manisha"/> 
      
      <classes>
         <class name = "ParameterizedTest1" />
      </classes>
      
   </test>
</suite>

हम <सूट> स्तर पर भी मापदंडों को परिभाषित कर सकते हैं। मान लीजिए हमने myName को <सूट> और <परीक्षण> दोनों स्तरों पर परिभाषित किया है। ऐसे मामलों में, नियमित स्कूपिंग नियम लागू होते हैं। इसका अर्थ है कि <परीक्षण> टैग के अंदर कोई भी वर्ग <परीक्षण> में परिभाषित पैरामीटर के मूल्य को देखेगा, जबकि बाकी testng.xml फ़ाइल में वर्ग <सूट> में परिभाषित मूल्य देखेंगे।

Javac का उपयोग करके परीक्षण केस क्लास संकलित करें।

C:\TestNG_WORKSPACE>javac ParameterizedTest1.java

अब, testng.xml चलाएं, जो पैरामीटरटेस्ट विधि को चलाएगा । TestNG <परीक्षण> टैग में पहले myName नामक एक पैरामीटर खोजने की कोशिश करेगा , और फिर, अगर यह नहीं मिल सकता है, तो यह <सूट> टैग में खोज करता है जो इसे संलग्न करता है।

C:\TestNG_WORKSPACE>java -cp "C:\TestNG_WORKSPACE" org.testng.TestNG testng.xml

आउटपुट सत्यापित करें।

Parameterized value is : manisha

===============================================
Suite1
Total tests run: 1, Failures: 0, Skips: 0
===============================================

TestNG स्वचालित रूप से आपके पैरामीटर के प्रकार में testng.xml में निर्दिष्ट मान को परिवर्तित करने का प्रयास करेगा। यहाँ समर्थित प्रकार हैं -

  • String
  • int/Integer
  • boolean/Boolean
  • byte/Byte
  • char/Character
  • double/Double
  • float/Float
  • long/Long
  • short/Short

डाटाप्रोवाइडर्स के साथ पासिंग पैरामीटर्स

जब आपको जटिल मापदंडों या मापदंडों को पारित करने की आवश्यकता होती है जो जावा (जटिल वस्तुओं, एक संपत्ति फ़ाइल या डेटाबेस, आदि से पढ़ी जाने वाली वस्तुओं) से बनाने की आवश्यकता होती है, तो मापदंडों को डाटाप्रोवाइडर्स का उपयोग करके पारित किया जा सकता है।

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

निम्न उदाहरण प्रदर्शित करते हैं कि डेटा प्रदाताओं का उपयोग कैसे करें। पहला उदाहरण वैक्टर के रूप में वेक्टर, स्ट्रिंग या इंटेगर का उपयोग करके @DataProvider के बारे में है, और दूसरा उदाहरण पैरामीटर के रूप में ऑब्जेक्ट का उपयोग करके @DataProvider के बारे में है।

उदाहरण 1

यहां, @DataProvider इंटर्जर और बूलियन को पैरामीटर के रूप में पास करता है।

Create Java class

PrimeNumberChecker.java नामक एक जावा वर्ग बनाएँ। यदि संख्या प्रधान है तो यह वर्ग जाँचता है। इस वर्ग में बनाएँC:\>TestNG_WORKSPACE।

public class PrimeNumberChecker {
   public Boolean validate(final Integer primeNumber) {
   
      for (int i = 2; i < (primeNumber / 2); i++) {
         if (primeNumber % i == 0) {
            return false;
         }
      }
      return true;
   }
}

Create Test Case Class

  • एक जावा टेस्ट क्लास बनाएं, कहें, ParamTestWithDataProvider1.java।

  • विधि प्राइम्यून्स () को परिभाषित करें, जिसे एनोटेशन का उपयोग करके डेटा प्रदाता के रूप में परिभाषित किया गया है। यह विधि ऑब्जेक्ट की एक सरणी देता है।

  • परीक्षण विधि testPrimeNumberChecker () को अपने परीक्षण वर्ग में जोड़ें। यह विधि इनपुट मापदंडों के रूप में एक इंटेगर और बूलियन लेती है। यह विधि मान्य है यदि पारित पैरामीटर एक प्रमुख संख्या है।

  • इस पद्धति में एनोटेशन @Test (dataProvider = "test1") जोड़ें । विशेषता dataProvider "test1" के लिए मैप किया गया है।

नाम से एक जावा वर्ग फ़ाइल बनाएँ ParamTestWithDataProvider1.java में C:\>TestNG_WORKSPACE।

import org.testng.Assert;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;

public class ParamTestWithDataProvider1 {
   private PrimeNumberChecker primeNumberChecker;

   @BeforeMethod
   public void initialize() {
      primeNumberChecker = new PrimeNumberChecker();
   }

   @DataProvider(name = "test1")
   public static Object[][] primeNumbers() {
      return new Object[][] {{2, true}, {6, false}, {19, true}, {22, false}, {23, true}};
   }

   // This test will run 4 times since we have 5 parameters defined
   @Test(dataProvider = "test1")
   public void testPrimeNumberChecker(Integer inputNumber, Boolean expectedResult) {
      System.out.println(inputNumber + " " + expectedResult);
      Assert.assertEquals(expectedResult, primeNumberChecker.validate(inputNumber));
   }
}

Create testng.xml

एक testng.xml बनाएँ C:\>TestNG_WORKSPACE परीक्षण मामले को निष्पादित करने के लिए।

<?xml version = "1.0" encoding = "UTF-8"?>
<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd" >

<suite name = "Suite1">
   <test name = "test1">
      <classes>
         <class name = "ParamTestWithDataProvider1" />
      </classes>
   </test>
</suite>

जावैक का उपयोग करके टेस्ट केस क्लास को संकलित करें।

C:\TestNG_WORKSPACE>.javac ParamTestWithDataProvider1.java PrimeNumberChecker.java

अब, testng.xml चलाएँ।

C:\TestNG_WORKSPACE>java -cp "C:\TestNG_WORKSPACE" org.testng.TestNG testng.xml

आउटपुट सत्यापित करें।

2 true
   6 false
   19 true
   22 false
   23 true

===============================================
   Suite1
   Total tests run: 5, Failures: 0, Skips: 0
===============================================

उदाहरण 2

यहां, @DataProvider ऑब्जेक्ट को पैरामीटर के रूप में पास करता है।

Create Java class

एक जावा क्लास बीन बनाइए। जावा, जो कि प्राप्त / निर्धारित विधियों के साथ एक सरल वस्तु है C:\>TestNG_WORKSPACE।

public class Bean {
   private String val;
   private int i;
   
   public Bean(String val, int i) {
      this.val = val;
      this.i = i;
   }
   
   public String getVal() {
      return val;
   }
   
   public void setVal(String val) {
      this.val = val;
   }
   
   public int getI() {
      return i;
   }
   
   public void setI(int i) {
      this.i = i;
   }
}

Create Test Case Class

  • एक जावा टेस्ट क्लास बनाएं, कहें, ParamTestWithDataProvider2.java।

  • विधि प्राइम्यून्स () को परिभाषित करें, जिसे एनोटेशन का उपयोग करके डेटा प्रदाता के रूप में परिभाषित किया गया है। यह विधि ऑब्जेक्ट की एक सरणी देता है।

  • परीक्षण विधि testMethod () को अपने परीक्षण वर्ग में जोड़ें। यह विधि एक ऑब्जेक्ट बीन को पैरामीटर के रूप में लेती है।

  • इस पद्धति में एनोटेशन @Test (dataProvider = "test1") जोड़ें । विशेषता dataProvider "test1" के लिए मैप किया गया है।

ParamTestWithDataProvider2.java नाम से एक जावा वर्ग फ़ाइल बनाएँ C:\>TestNG_WORKSPACE।

import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;

public class ParamTestWithDataProvider2 {
   @DataProvider(name = "test1")
   public static Object[][] primeNumbers() {
      return new Object[][] { { new Bean("hi I am the bean", 111) } };
   }

   @Test(dataProvider = "test1")
   public void testMethod(Bean myBean) {
      System.out.println(myBean.getVal() + " " + myBean.getI());
   }
}

Create testng.xml

में testng.xml बनाएँ C:\>TestNG_WORKSPACE परीक्षण मामले को निष्पादित करने के लिए।

<?xml version = "1.0" encoding = "UTF-8"?>
<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd" >

<suite name = "Suite1">
   <test name = "test1">
      <classes>
         <class name = "ParamTestWithDataProvider2" />
      </classes>
   </test>
</suite>

Javac का उपयोग करके परीक्षण केस क्लास संकलित करें।

C:\TestNG_WORKSPACE>javac ParamTestWithDataProvider2.java Bean.java

अब, testng.xml चलाएँ।

C:\TestNG_WORKSPACE>java -cp "C:\TestNG_WORKSPACE" org.testng.TestNG testng.xml

आउटपुट सत्यापित करें।

hi I am the bean 111

===============================================
   Suite1
   Total tests run: 1, Failures: 0, Skips: 0
===============================================

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

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

आइए, हमारे पास TestNG की इस अद्भुत क्षमता को प्रदर्शित करने के लिए एक उदाहरण है।

JUnit टेस्ट केस क्लास बनाएं

एक जावा क्लास बनाएं, जो कि JUnit टेस्ट क्लास है, TestJunit.java इन C:\>TestNG_WORKSPACE।

import org.junit.Test;
import static org.testng.AssertJUnit.assertEquals;

public class TestJunit {
   @Test
   public void testAdd() {
      String str = "Junit testing using TestNG";
      AssertEquals("Junit testing using TestNG",str);
   }
}

अब, testng.xml को लिखते हैं C:\>TestNG_WORKSPACE, जिसमें <सुइट> टैग निम्नानुसार होगा -

<?xml version = "1.0" encoding = "UTF-8"?>
<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd">

<suite name = "Converted JUnit suite" >
   <test name = "JUnitTests" junit="true">
      <classes>
         <class name = "TestJunit" />
      </classes>
   </test>
</suite>

JUnit परीक्षण मामलों को निष्पादित करने के लिए, ऊपर दिए गए xml में संपत्ति junit = "true" को परिभाषित करें । JUnit टेस्ट केस क्लास TestJunit को क्लास के नाम से परिभाषित किया गया है।

JUnit 4 के लिए, TestNG आपके परीक्षण चलाने के लिए org.junit.runner.JUnitCore धावक का उपयोग करेगा ।

जावा का उपयोग करके सभी जावा कक्षाओं को संकलित करें।

C:\TestNG_WORKSPACE>javac TestJunit.java

अब, testng.xml चलाएं, जो टेस्टनेट के रूप में JUnit टेस्ट केस चलाएगा।

C:\TestNG_WORKSPACE>java -cp "C:\TestNG_WORKSPACE:C:\TestNG_WORKSPACE\lib\junit-4.11.jar" org.testng.TestNG testng.xml

यहां, हमने C: \ TestNG_WORKSPACE \ lib \ junit-4.11.jar के तहत जूनियर-4.11.jar रखा है।

आउटपुट सत्यापित करें।

===============================================
   Converted JUnit suite

   Total tests run: 1, Failures: 0, Skips: 0
===============================================

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

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

TestNG के साथ रिपोर्ट बनाने के दो तरीके हैं -

  • Listeners- श्रोता वर्ग को लागू करने के लिए, वर्ग को org.testng.ITestListener इंटरफ़ेस को लागू करना होगा । टेस्ट शुरू होने पर, समाप्त होने, विफल होने, या पास होने पर इन कक्षाओं को टेस्टएनजी द्वारा अधिसूचित किया जाता है।

  • Reporters- रिपोर्टिंग क्लास लागू करने के लिए, क्लास को एक org.testng.IReporter इंटरफ़ेस लागू करना होगा । इन कक्षाओं को तब बुलाया जाता है जब पूरे सुइट रन समाप्त होते हैं। पूरे परीक्षण रन की जानकारी वाली वस्तु को इस वर्ग में तब पास किया जाता है जब उसे बुलाया जाता है।

इस अध्याय में, हमारे पास रिपोर्टिंग और लॉगिंग के चार अलग-अलग मामलों को प्रदर्शित करने के लिए चार अलग-अलग उदाहरण होंगे -

अनु क्रमांक। केस और उदाहरण
1 कस्टम लॉगिंग

यह उदाहरण दिखाता है कि कैसे अपने लकड़हारे को लिखना है।
2 कस्टम रिपोर्टर

यह उदाहरण दिखाता है कि अपने खुद के रिपोर्टर कैसे लिखें।
3 HTML और XML रिपोर्ट

यह उदाहरण TestNG द्वारा उत्पन्न डिफ़ॉल्ट HTML और XML रिपोर्ट दिखाता है।
4 JUnit रिपोर्ट

यह उदाहरण बताता है कि टेस्टनेट रिपोर्ट से JUnit रिपोर्ट कैसे जनरेट की जाती है।

इस अध्याय में, हम एएनटी का उपयोग करके टेस्टएनजी को चलाने के तरीके का प्रदर्शन करेंगे। आइए नीचे दिए गए चरणों का पालन करें -

चरण 1: अपाचे चींटी डाउनलोड करें

Apache Ant का नवीनतम संस्करण डाउनलोड करें

ओएस पुरालेख का नाम
खिड़कियाँ apache-ant-1.8.4-bin.zip
लिनक्स अपाचे-चींटी-1.8.4-bin.tar.gz
मैक अपाचे-चींटी-1.8.4-bin.tar.gz

चरण 2: चींटी पर्यावरण सेट करें

ठीक ANT_HOMEपर्यावरण चर को बेस डायरेक्टरी स्थान पर इंगित करने के लिए, जहां ANT लाइब्रेरी आपके मशीन पर संग्रहीत हैं। मान लेते हैं कि हमने चींटी पुस्तकालयों को फ़ोल्डर अपाचे-चींटी-1.8.4 फ़ोल्डर में संग्रहीत किया है।

ओएस उत्पादन
खिड़कियाँ पर्यावरण चर ANT_HOME को C: \ Program Files \ Apache Software Foundation \ Apache-ant-1.8.4 पर सेट करें
लिनक्स ANT_HOME = / usr / स्थानीय / अपाचे-चींटी-1.8.4 निर्यात करें
मैक ANT_HOME = / लाइब्रेरी / Apache-ant-1.8.4 निर्यात करें

सिस्टम पथ में चींटी संकलक का स्थान निम्नानुसार है -

ओएस विवरण
खिड़कियाँ सिस्टम चर, पथ के अंत में स्ट्रिंग% ANT_HOME \ बिन को जोड़ें।
लिनक्स निर्यात पथ =$PATH:$ANT_HOME / bin /
मैक की जरूरत नहीं है।

चरण 3: TestNG संग्रह डाउनलोड करें

आवश्यक जार फ़ाइलों को डाउनलोड करें http://www.testng.org.

ओएस संग्रह का नाम
खिड़कियाँ TestNG-6.8.jar
लिनक्स TestNG-6.8.jar
मैक TestNG-6.8.jar

चरण 4: प्रोजेक्ट संरचना बनाएँ

  • एक फ़ोल्डर बनाएँ TestNGWithAnt में C:\>TestNG_WORKSPACE।

  • एक फ़ोल्डर बनाएँ src में C:\>TestNG_WORKSPACE>TestNGWithAnt।

  • एक फ़ोल्डर बनाएँ test में C:\>TestNG_WORKSPACE>TestNGWithAnt।

  • एक फ़ोल्डर बनाएँ lib में C:\>TestNG_WORKSPACE>TestNGWithAnt।

  • सृजन करना MessageUtil कक्षा में C:\>TestNG_WORKSPACE>TestNGWithAnt>src फ़ोल्डर।

/*
* This class prints the given message on console.
*/

public class MessageUtil {

   private String message;

   //Constructor
   //@param message to be printed
   public MessageUtil(String message) {
      this.message = message; 
   }

   // prints the message
   public void printMessage() {
      System.out.println(message);
      return message;
   }   

   // add "Hi!" to the message
   public String salutationMessage() {
      message = "Hi!" + message;
      System.out.println(message);
      return message;
   }   
}

  • में TestMessageUtil क्लास बनाएँ C:\>TestNG_WORKSPACE>TestNGWithAnt>src फ़ोल्डर।

import org.testng.Assert;
import org.testng.annotations.Test;


public class TestMessageUtil {
   String message = "Manisha";	
   MessageUtil messageUtil = new MessageUtil(message);

   @Test
   public void testPrintMessage() {	
      System.out.println("Inside testPrintMessage()");     
      Assert.assertEquals(message,messageUtil.printMessage());
   }

   @Test
   public void testSalutationMessage() {
      System.out.println("Inside testSalutationMessage()");
      message = "Hi!" + "Manisha";
      Assert.assertEquals(message,messageUtil.salutationMessage());
   }
}

  • कॉपी testng-6.8.jar में C:\>TestNG_WORKSPACE>TestNGWithAnt>lib फ़ोल्डर।

ANT build.xml बनाएँ

सबसे पहले, हमें TestNG चींटी कार्य को इस प्रकार परिभाषित करना होगा -

<taskdef name = "testng" classname = "org.testng.TestNGAntTask">
   <classpath>
      <pathelement location = "lib/testng-6.8.jar"/>
   </classpath>
</taskdef>

फिर, हम उपयोग करेंगे <testng> चींटी में कार्य हमारे TestNG परीक्षण मामलों को निष्पादित करने के लिए।

build.xml फ़ाइल इस प्रकार है -

<project name = "TestNGTest" default = "test" basedir = ".">

   <!-- Define <testng> task -->

   <taskdef name = "testng" classname = "org.testng.TestNGAntTask">
      <classpath>
         <pathelement location = "lib/testng-6.8.jar"/>
      </classpath>
   </taskdef>

   <property name = "testdir" location = "test" />
   <property name = "srcdir" location = "src" />
   <property name = "libdir" location = "lib" />
   <property name = "full-compile" value="true" />
   
   <path id = "classpath.base"/>
   <path id = "classpath.test">
   
   <fileset dir = "${libdir}"> <include name = "**/*.jar" /> </fileset> <pathelement location = "${testdir}" />
   <pathelement location = "${srcdir}" /> <path refid = "classpath.base" /> </path> <target name = "clean" > <delete verbose="${full-compile}">
         <fileset dir = "${testdir}" includes="**/*.class" /> </delete> </target> <target name = "compile" depends="clean"> <javac srcdir = "${srcdir}" destdir = "${testdir}" verbose="${full-compile}">
         <classpath refid = "classpath.test"/>
      </javac>
   </target>
   
   <target name = "test" depends="compile">
      <testng outputdir = "${testdir}" classpathref="classpath.test"> <xmlfileset dir = "${srcdir}" includes="testng.xml"/> 
      </testng>
   </target>
   
</project>

निम्नलिखित चींटी कमांड चलाएं।

C:\TestNG_WORKSPACE\TestNGWithAnt>ant

आउटपुट सत्यापित करें।

test:
   [testng] [TestNG] Running:
   [testng]   C:\TestNG_WORKSPACE\TestNGWithAnt\src\testng.xml
   [testng] 
   [testng] Inside testPrintMessage()
   [testng] Manisha
   [testng] Inside testSalutationMessage()
   [testng] Hi!Manisha
   [testng] 
   [testng] ===============================================
   [testng] Plug ANT test Suite
   [testng] Total tests run: 2, Failures: 0, Skips: 0
   [testng] ===============================================
   [testng] 

BUILD SUCCESSFUL
Total time: 1 second

ग्रहण के साथ TestNG स्थापित करने के लिए, नीचे दिए गए चरणों का पालन करें -

चरण 1: TestNG संग्रह डाउनलोड करें

TestNG जार फ़ाइल का नवीनतम संस्करण डाउनलोड करें http://www.testng.org

ओएस संग्रह का नाम
खिड़कियाँ TestNG-6.8.jar
लिनक्स TestNG-6.8.jar
मैक TestNG-6.8.jar

हमें लगता है कि आपने ऊपर JAR फ़ाइल C: \> TestNG फ़ोल्डर में कॉपी कर ली है।

चरण 2: ग्रहण वातावरण सेट करें

  • ओपन एक्लिप्स → प्रोजेक्ट पर राइट क्लिक करें और प्रॉपर्टी पर जाएं → बिल्ड पाथ → बिल्ड पाथ कॉन्फ़िगर करें और जोड़ें बाहरी जार बटन का उपयोग करके पुस्तकालयों में testng-6.8.jar जोड़ें ।

  • हम मानते हैं कि आपके ग्रहण में TestNG प्लग-इन इनबिल्ट है; यदि यह उपलब्ध नहीं है, तो कृपया अद्यतन साइट का उपयोग करके नवीनतम संस्करण प्राप्त करें।

    • अपने ग्रहण आईडीई में, मदद / सॉफ्टवेयर अपडेट / ढूंढें और इंस्टॉल करें का चयन करें ।

    • स्थापित करने के लिए नई सुविधाओं की खोज करें।

    • नई दूरस्थ साइट।

    • ग्रहण 3.4 और ऊपर के लिए, दर्ज करें http://beust.com/eclipse।

    • ग्रहण 3.3 और उससे नीचे के लिए, दर्ज करें http://beust.com/eclipse1।

    • सुनिश्चित करें कि URL के आगे चेक बॉक्स चेक किया गया है और अगला क्लिक करें ।

    • ग्रहण तब प्रक्रिया के माध्यम से आपका मार्गदर्शन करेगा।

अब, आपका ग्रहण TestNG परीक्षण मामलों के विकास के लिए तैयार है।

चरण 3: ग्रहण में TestNG स्थापना सत्यापित करें

  • किसी भी स्थान पर ग्रहण में एक परियोजना TestNGProject बनाएँ।

  • प्रोजेक्ट में परीक्षण करने के लिए एक क्लास MessageUtil बनाएँ।

/*
* This class prints the given message on console.
*/

public class MessageUtil {

   private String message;

   //Constructor
   //@param message to be printed
   public MessageUtil(String message) {
      this.message = message;
   }

   // prints the message
   public String printMessage() {
      System.out.println(message);
      return message;
   }   
}

  • प्रोजेक्ट में एक परीक्षण वर्ग TestNGExample बनाएँ।

import org.testng.Assert;
import org.testng.annotations.Test;

public class TestNGExample {
   String message = "Hello World";	
   MessageUtil messageUtil = new MessageUtil(message);

   @Test
   public void testPrintMessage() {	  
      Assert.assertEquals(message,messageUtil.printMessage());
   }
}

परियोजना की संरचना इस प्रकार होनी चाहिए -

अंत में, प्रोग्राम पर राइट-क्लिक करके और TestNG के रूप में चलाकर प्रोग्राम के आउटपुट को सत्यापित करें।

परिणाम सत्यापित करें।

ja/tutorial
es/tutorial
de/tutorial
fr/tutorial
th/tutorial
pt/tutorial
ru/tutorial
vi/tutorial
it/tutorial
ko/tutorial
tr/tutorial
id/tutorial
pl/tutorial
hi/tutorial
japost
espost
depost
frpost
thpost
ptpost
rupost
vipost
itpost
kopost
trpost
idpost
plpost
hipost

© Copyright 2021 - 2024 | All Rights Reserved