खोज…
टिप्पणियों
पैरामीटर | प्रसंग | विवरण |
---|---|---|
@कक्षा से पहले | स्थिर | जब पहली बार कक्षा बनाई जाती है, तो निष्पादित किया जाता है |
@इससे पहले | उदाहरण | कक्षा में प्रत्येक परीक्षा से पहले उत्तीर्ण |
@परीक्षा | उदाहरण | परीक्षण करने के लिए प्रत्येक विधि घोषित की जानी चाहिए |
@उपरांत | उदाहरण | कक्षा में प्रत्येक परीक्षण के बाद निष्पादित |
@कक्षा के बाद | स्थिर | वर्ग के विनाश से पहले निष्पादित |
उदाहरण टेस्ट क्लास फॉर्मेट
public class TestFeatureA {
@BeforeClass
public static void setupClass() {}
@Before
public void setupTest() {}
@Test
public void testA() {}
@Test
public void testB() {}
@After
public void tearDownTest() {}
@AfterClass
public static void tearDownClass() {}
}
}
JUnit का उपयोग करके यूनिट परीक्षण
यहां हमारे पास एक क्लास Counter
जिसमें तरीकों की countNumbers()
और hasNumbers()
।
public class Counter {
/* To count the numbers in the input */
public static int countNumbers(String input) {
int count = 0;
for (char letter : input.toCharArray()) {
if (Character.isDigit(letter))
count++;
}
return count;
}
/* To check whether the input has number*/
public static boolean hasNumber(String input) {
return input.matches(".*\\d.*");
}
}
इस वर्ग का परीक्षण करने के लिए, हम जूनिट ढांचे का उपयोग कर सकते हैं। अपने प्रोजेक्ट क्लास पथ में junit.jar
जोड़ें। फिर नीचे के रूप में टेस्ट केस क्लास बनाएं:
import org.junit.Assert; // imports from the junit.jar
import org.junit.Test;
public class CounterTest {
@Test // Test annotation makes this method as a test case
public void countNumbersTest() {
int expectedCount = 3;
int actualCount = Counter.countNumbers("Hi 123");
Assert.assertEquals(expectedCount, actualCount); //compares expected and actual value
}
@Test
public void hasNumberTest() {
boolean expectedValue = false;
boolean actualValue = Counter.hasNumber("Hi there!");
Assert.assertEquals(expectedValue, actualValue);
}
}
अपने IDE में आप इस क्लास को "जूनिट टेस्टकेस" के रूप में चला सकते हैं और GUI में आउटपुट देख सकते हैं। कमांड प्रॉम्प्ट में आप नीचे दिए अनुसार परीक्षण मामले को संकलित और चला सकते हैं:
\> javac -cp ,;junit.jar CounterTest.java
\> java -cp .;junit.jar org.junit.runner.JUnitCore CounterTest
एक सफल परीक्षण रन से आउटपुट के समान दिखना चाहिए:
JUnit version 4.9b2
..
Time: 0.019
OK (2 tests)
एक परीक्षण विफलता के मामले में यह अधिक दिखेगा:
Time: 0.024
There was 1 failure:
1) CountNumbersTest(CounterTest)
java.lang.AssertionError: expected:<30> but was:<3>
... // truncated output
FAILURES!!!
Tests run: 2, Failures: 1
फिक्स्चर
एक परीक्षण स्थिरता कुछ आइटम, डिवाइस या सॉफ़्टवेयर के टुकड़े का लगातार परीक्षण करने के लिए उपयोग की जाती है।
यह स्वयं परीक्षण विधियों से सामान्य आरंभीकरण / अंतिमकरण कोड निकालकर परीक्षणों की पठनीयता को बढ़ा सकता है।
जहां प्रत्येक परीक्षण से पहले एक बार सामान्य पुनरावृत्ति को निष्पादित किया जा सकता है, इससे परीक्षणों को चलाने में लगने वाले समय को भी कम किया जा सकता है।
JUnit द्वारा उपलब्ध कराए गए मुख्य विकल्पों को दिखाने के लिए नीचे दिए गए उदाहरण से संबंधित है। एक वर्ग Foo
जो आरंभ करने के लिए महंगा है:
public class Foo {
public Foo() {
// expensive initialization
}
public void cleanUp() {
// cleans up resources
}
}
एक अन्य वर्ग Bar
में Foo
संदर्भ है:
public class Bar {
private Foo foo;
public Bar(Foo foo) {
this.foo = foo;
}
public void cleanUp() {
// cleans up resources
}
}
नीचे दिए गए परीक्षण एक Bar
के एक सूची वाले प्रारंभिक संदर्भ की अपेक्षा करते हैं।
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import java.util.Arrays;
import java.util.List;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
public class FixturesTest {
private static Foo referenceFoo;
private List<Bar> testContext;
@BeforeClass
public static void setupOnce() {
// Called once before any tests have run
referenceFoo = new Foo();
}
@Before
public void setup() {
// Called before each test is run
testContext = Arrays.asList(new Bar(referenceFoo));
}
@Test
public void testSingle() {
assertEquals("Wrong test context size", 1, testContext.size());
Bar baz = testContext.get(0);
assertEquals(referenceFoo, baz.getFoo());
}
@Test
public void testMultiple() {
testContext.add(new Bar(referenceFoo));
assertEquals("Wrong test context size", 2, testContext.size());
for (Bar baz : testContext) {
assertEquals(referenceFoo, baz.getFoo());
}
}
@After
public void tearDown() {
// Called after each test is run
for (Bar baz : testContext) {
baz.cleanUp();
}
}
@AfterClass
public void tearDownOnce() {
// Called once after all tests have run
referenceFoo.cleanUp();
}
}
उदाहरण में @BeforeClass
एनोटेट विधि setupOnce()
बनाने के लिए प्रयोग किया जाता है Foo
वस्तु है, जो आरंभ करने के लिए महंगा है। यह महत्वपूर्ण है कि इसे किसी भी परीक्षण द्वारा संशोधित नहीं किया जाए, अन्यथा परीक्षण रन के परिणाम व्यक्तिगत परीक्षणों के निष्पादन के आदेश पर निर्भर हो सकते हैं। विचार यह है कि प्रत्येक परीक्षण स्वतंत्र है और एक छोटी सी विशेषता का परीक्षण करता है।
@Before
एनोटेट विधि setup()
परीक्षण संदर्भ सेट करता है। संदर्भ को परीक्षण निष्पादन के दौरान संशोधित किया जा सकता है, यही कारण है कि प्रत्येक परीक्षण से पहले इसे आरंभीकृत किया जाना चाहिए। प्रत्येक परीक्षण विधि के प्रारंभ में इस विधि में समाहित कोड को शामिल करके समतुल्य प्रभाव प्राप्त किया जा सकता है।
@After
एनोटेट विधि tearDown()
परीक्षण के संदर्भ में संसाधनों को साफ करती है। इसे प्रत्येक परीक्षण आह्वान के बाद कहा जाता है, और जैसा कि अक्सर @Before
एनोटेट विधि में आवंटित मुक्त संसाधनों के लिए उपयोग किया जाता है।
सभी परीक्षण चलने के बाद @AfterClass
एनोटेट विधि tearDownOnce()
संसाधनों को साफ करती है। इस तरह के तरीकों का इस्तेमाल आमतौर पर आरंभीकरण के दौरान या @BeforeClass
एनोटेट विधि के दौरान आवंटित संसाधनों को मुक्त करने के लिए किया जाता है। उन्होंने कहा, इकाई परीक्षणों में बाहरी संसाधनों से बचना शायद सबसे अच्छा है ताकि परीक्षण परीक्षण वर्ग के बाहर किसी चीज पर निर्भर न हों।
सिद्धांतों का उपयोग करते हुए इकाई परीक्षण
सिद्धांत धावक एक निश्चित कार्यक्षमता का परीक्षण करने के लिए डेटा बिंदुओं के एक अनंत सेट के खिलाफ अनुमति देता है।
सिद्धांत चलाना
import org.junit.experimental.theories.Theories;
import org.junit.experimental.theories.Theory;
import org.junit.runner.RunWith;
@RunWith(Theories.class)
public class FixturesTest {
@Theory
public void theory(){
//...some asserts
}
}
@Theory
साथ एनोटेट किए गए तरीकों को @Theory
रनर द्वारा सिद्धांतों के रूप में पढ़ा जाएगा।
@ डेटापोट एनोटेशन
@RunWith(Theories.class)
public class FixturesTest {
@DataPoint
public static String dataPoint1 = "str1";
@DataPoint
public static String dataPoint2 = "str2";
@DataPoint
public static int intDataPoint = 2;
@Theory
public void theoryMethod(String dataPoint, int intData){
//...some asserts
}
}
@DataPoint
साथ एनोटेट किए गए प्रत्येक फ़ील्ड का उपयोग सिद्धांतों में दिए गए प्रकार के एक विधि पैरामीटर के रूप में किया जाएगा। theoryMethod
ऊपर उदाहरण theoryMethod
निम्न मापदंडों के साथ दो बार चलेगा: ["str1", 2] , ["str2", 2]
@DataPoints एनोटेशन @RunWith (Theories.class) पब्लिक क्लास फिक्स्चरटेस्ट {
@DataPoints
public static String[] dataPoints = new String[]{"str1", "str2"};
@DataPoints
public static int[] dataPoints = new int[]{1, 2};
@Theory
public void theoryMethod(String dataPoint, ){
//...some asserts
}
}
सरणी के प्रत्येक तत्व को @DataPoints
एनोटेशन के साथ एनोटेट किया जाएगा जो सिद्धांतों में दिए गए प्रकार के एक विधि पैरामीटर के रूप में उपयोग किया जाएगा। theoryMethod
ऊपर उदाहरण में, theoryMethod
निम्न मापदंडों के साथ चार बार चलेगा: ["str1", 1], ["str2", 1], ["str1", 2], ["str2", 2]
प्रदर्शन माप
यदि आपको यह जांचने की आवश्यकता है कि क्या आपकी परीक्षण विधि को निष्पादित करने में बहुत लंबा समय लगता है, तो आप ऐसा कर सकते हैं कि @Test एनोटेशन की टाइमआउट संपत्ति का उपयोग करके अपने अपेक्षित निष्पादन समय का उल्लेख कर सकें। यदि परीक्षण निष्पादन मिलीसेकंड की उस संख्या से अधिक समय लेता है तो यह परीक्षण पद्धति को विफल कर देता है।
public class StringConcatenationTest {
private static final int TIMES = 10_000;
// timeout in milliseconds
@Test(timeout = 20)
public void testString(){
String res = "";
for (int i = 0; i < TIMES; i++) {
res += i;
}
System.out.println(res.length());
}
@Test(timeout = 20)
public void testStringBuilder(){
StringBuilder res = new StringBuilder();
for (int i = 0; i < TIMES; i++) {
res.append(i);
}
System.out.println(res.length());
}
@Test(timeout = 20)
public void testStringBuffer(){
StringBuffer res = new StringBufferr();
for (int i = 0; i < TIMES; i++) {
res.append(i);
}
System.out.println(res.length());
}
}
जेवीएम वार्म-अप के बिना ज्यादातर मामलों में testString
विफल हो जाएगी। लेकिन testStringBuffer
और testStringBuilder
को सफलतापूर्वक इस परीक्षा को पास करना चाहिए।