junitशुरुआत जूनियर से हुई


टिप्पणियों

JUnit जावा प्रोग्रामिंग भाषा के लिए दोहराए जाने वाले परीक्षण लिखने के लिए एक सरल ढांचा है। यह इकाई परीक्षण ढांचे के लिए xUnit वास्तुकला का एक उदाहरण है।

मुख्य विशेषताओं में शामिल हैं:

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

JUnit के लिए उपयोगी विस्तार:

  • AssertJ : जावा के लिए धाराप्रवाह अभिकथन
  • मॉकिटो : जावा के लिए मॉकिंग फ्रेमवर्क

संस्करण

संस्करण रिलीज़ की तारीख
JUnit 5 माइलस्टोन 2 2016/07/23
JUnit 5 मील का पत्थर 1 2016/07/07
ज्यूनिट 4.12 2016/04/18
ज्यूनिट 4.11 2012-11-14
ज्यूनिट 4.10 2011-09-28
JUnit 4.9 2011-08-22
JUnit 4.8 2009-12-01
JUnit 4.7 2009-07-28
JUnit 4.6 2009-04-14

स्थापना या सेटअप

चूँकि JUnit एक Java लाइब्रेरी है, आपको इसे स्थापित करने के लिए बस इतना करना है कि अपने Java प्रोजेक्ट के classpath में कुछ JAR फाइलें जोड़ें और आप जाने के लिए तैयार हैं।

आप इन दो JAR फ़ाइलों को मैन्युअल रूप से डाउनलोड कर सकते हैं: junit.jar & hamcrest-core.jar

यदि आप मावेन का उपयोग कर रहे हैं, तो आप बस अपने pom.xml में निर्भरता में जोड़ सकते हैं:

<dependency>
  <groupId>junit</groupId>
  <artifactId>junit</artifactId>
  <version>4.12</version>
  <scope>test</scope>
</dependency>
 

या यदि आप build.gradle का उपयोग कर रहे हैं, तो अपने build.gradle निर्भरता में जोड़ें:

apply plugin: 'java'

dependencies {
    testCompile 'junit:junit:4.12'
}
 

इसके बाद आप अपना पहला टेस्ट क्लास बना सकते हैं:

import static org.junit.Assert.assertEquals;

import org.junit.Test;

public class MyTest {
    @Test
    public void onePlusOneShouldBeTwo() {
        int sum = 1 + 1;
        assertEquals(2, sum);
    }
}
 

और इसे कमांड लाइन से चलाएं:

  • Windows java -cp .;junit-X.YY.jar;hamcrest-core-XYjar org.junit.runner.JUnitCore MyTest
  • Linux या OsX java -cp .:junit-X.YY.jar:hamcrest-core-XYjar org.junit.runner.JUnitCore MyTest

या मावेन के साथ: mvn test

@पहले बादमे

@Before साथ एक एनोटेट विधि को @Test विधियों के प्रत्येक निष्पादन से पहले निष्पादित किया जाएगा। अनुरूपता @After एक @After एनोटेट विधि हर @Test विधि के बाद निष्पादित की @Test है। इसका उपयोग बार-बार टेस्ट सेटिंग सेट करने और हर टेस्ट के बाद सफाई करने के लिए किया जा सकता है। इसलिए परीक्षण स्वतंत्र हैं और तैयारी कोड @Test पद्धति के अंदर कॉपी नहीं किया गया है।

उदाहरण:

import static org.junit.Assert.assertEquals;

import java.util.ArrayList;
import java.util.List;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;

public class DemoTest {

    private List<Integer> list;

    @Before
    public void setUp() {
        list = new ArrayList<>();
        list.add(3);
        list.add(1);
        list.add(4);
        list.add(1);
        list.add(5);
        list.add(9);
    }

    @After
    public void tearDown() {
        list.clear();
    }

    @Test
    public void shouldBeOkToAlterTestData() {
        list.remove(0); // Remove first element of list.
        assertEquals(5, list.size()); // Size is down to five
    }

    @Test
    public void shouldBeIndependentOfOtherTests() {
        assertEquals(6, list.size());
    }
}
 

@Before या @After साथ एनोटेट किए गए तरीके public void होने चाहिए और शून्य तर्क के साथ।

मूल इकाई परीक्षण उदाहरण

यह उदाहरण StringBuilder.toString () जूनिट का उपयोग करने के लिए एक मूल सेटअप है।

import static org.junit.Assert.assertEquals;

import org.junit.Test;

public class StringBuilderTest {

    @Test
    public void stringBuilderAppendShouldConcatinate()  {
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append("String");
        stringBuilder.append("Builder");
        stringBuilder.append("Test");

        assertEquals("StringBuilderTest", stringBuilder.toString());
    }

}
 

अपेक्षित अपवाद पकड़ो

बिना किसी try catch ब्लॉक के आसानी से अपवाद को पकड़ना संभव है।

public class ListTest {
  private final List<Object> list = new ArrayList<>();

  @Test(expected = IndexOutOfBoundsException.class)
  public void testIndexOutOfBoundsException() {
    list.get(0);
  }
}
 

ऊपर दिए गए उदाहरण को सरल मामलों के लिए पर्याप्त होना चाहिए, जब आप फेंके गए अपवाद द्वारा किए गए संदेश की जांच नहीं करना चाहते हैं।

यदि आप अपवाद के बारे में जानकारी की जांच करना चाहते हैं, तो आप कोशिश / कैच ब्लॉक का उपयोग कर सकते हैं:

@Test
public void testIndexOutOfBoundsException() {
    try {
        list.get(0);
        Assert.fail("Should throw IndexOutOfBoundException");
    } catch (IndexOutOfBoundsException ex) {
        Assert.assertEquals("Index: 0, Size: 0", ex.getMessage());
    }
}
 

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

अधिक विस्तृत मामलों के लिए, JUnit में ExpectedException @Rule , जो इस जानकारी का परीक्षण भी कर सकती है और इसका उपयोग इस प्रकार है:

public class SimpleExpectedExceptionTest {
     @Rule
     public ExpectedException expectedException = ExpectedException.none();

     @Test
     public void throwsNothing() {
         // no exception expected, none thrown: passes.
     }

     @Test
     public void throwsExceptionWithSpecificType() {
         expectedException.expect(NullPointerException.class);

         throw new NullPointerException();
     }

     @Test
     public void throwsExceptionWithSpecificTypeAndMessage() {
         expectedException.expect(IllegalArgumentException.class);
         expectedException.expectMessage("Wanted a donut.");

         throw new IllegalArgumentException("Wanted a donut.");
     }
}
 

JUnit5 में परीक्षण अपवाद

JUnit 5 में समान प्राप्त करने के लिए, आप एक पूरी तरह से नए तंत्र का उपयोग करते हैं:

परीक्षित विधि

public class Calculator {
    public double divide(double a, double b) {
        if (b == 0.0) {
            throw new IllegalArgumentException("Divider must not be 0");
        }
        return a/b;
    }
}
 

परीक्षण विधि

public class CalculatorTest {
    @Test
    void triangularMinus5() { // The test method does not have to be public in JUnit5
        Calculator calc = new Calculator();

        IllegalArgumentException thrown = assertThrows(
            IllegalArgumentException.class, 
            () -> calculator.divide(42.0, 0.0));
        // If the exception has not been thrown, the above test has failed.

        // And now you may further inspect the returned exception...
        // ...e.g. like this:
        assertEquals("Divider must not be 0", thrown.getMessage());
}
 

टेस्ट को नजरअंदाज करना

एक परीक्षण को अनदेखा करने के लिए, बस परीक्षण में @Ignore एनोटेशन जोड़ें और वैकल्पिक रूप से कारण के साथ एनोटेशन को एक पैरामीटर प्रदान करें।

@Ignore("Calculator add not implemented yet.")
@Test
public void testPlus() {
    assertEquals(5, calculator.add(2,3));
}
 

परीक्षण की टिप्पणी करने या @Test सबसे टिप्पणी को हटाने की @Test , परीक्षण धावक अभी भी इस परीक्षण की रिपोर्ट करेगा और ध्यान दें कि इसे अनदेखा किया गया था।

JUnit मान्यताओं का उपयोग करके एक परीक्षण मामले को सशर्त रूप से अनदेखा करना भी संभव है। एक डेवलपर द्वारा एक निश्चित बग तय किए जाने के बाद ही एक नमूना उपयोग-मामला परीक्षण-मामला चलाने के लिए होगा। उदाहरण:

import org.junit.Assume;
import org.junit.Assert;
...

@Test 
public void testForBug1234() {

    Assume.assumeTrue(isBugFixed(1234));//will not run this test until the bug 1234 is fixed

    Assert.assertEquals(5, calculator.add(2,3));
}
 

डिफ़ॉल्ट रनर परीक्षण को अनदेखा मानकर विफलताओं के साथ व्यवहार करता है। यह संभव है कि अन्य धावक अलग-अलग व्यवहार कर सकते हैं जैसे कि उन्हें पारित मान लें।

JUnit - मूल एनोटेशन उदाहरण

यहाँ कुछ बुनियादी JUnit एनोटेशन हैं जिन्हें आपको समझना चाहिए:

@BeforeClass – Run once before any of the test methods in the class, public static void 
@AfterClass – Run once after all the tests in the class has been run, public static void
@Before – Run before @Test, public void
@After – Run after @Test, public void
@Test – This is the test method to run, public void