JUnitలో @Before మరియు @After ఉల్లేఖనాలను ఎలా ఉపయోగించాలి

మీరు యూనిట్ టెస్ట్ సూట్‌ను వ్రాస్తున్నప్పుడు, మీరు నిర్వహించాల్సిన కొన్ని పరీక్ష-సంబంధిత కార్యకలాపాలు ఉండవచ్చు. ఈ కార్యకలాపాలు ఏ రూపంలోనైనా ఉండవచ్చు. మీరు పరీక్షను నిర్వహించే ముందు మీరు డేటాబేస్‌కు కనెక్ట్ చేయాల్సి రావచ్చు లేదా వనరులను సేకరించాలి. ప్రతి పరీక్ష కేసును అమలు చేసిన తర్వాత, మీరు కొన్ని వనరులను విడుదల చేయాల్సి రావచ్చు.

రోజు యొక్క వీడియోను తయారు చేయండి

యూనిట్ టెస్ట్ క్లాస్ పరిధికి వెలుపల ఈ నాన్-టెస్ట్-సంబంధిత కార్యకలాపాలలో ఏదైనా చేయడం అసాధ్యం కాకపోయినా దుర్భరమైనది. మీ టెస్ట్ క్లాస్ యొక్క విజయవంతమైన అమలు ఈ కార్యకలాపాలపై ఆధారపడి ఉండవచ్చు, కాబట్టి ఈ సమస్యను పరిష్కరించడానికి JUnit రెండు జతల ఉల్లేఖనాలను అందిస్తుంది.

---

---

ఆపిల్ వాచ్ సిరీస్ 2 స్టెయిన్లెస్ స్టీల్ vs అల్యూమినియం

@BeforeAll ఉల్లేఖన

JUnit పరీక్ష తరగతి ఒకటి లేదా అంతకంటే ఎక్కువ పరీక్ష పద్ధతులను కలిగి ఉంటుంది. @BeforeAll ఉల్లేఖనం పరీక్ష తరగతిలోని అన్ని పరీక్ష పద్ధతులకు ముందు నిర్దిష్ట పద్ధతిని అమలు చేయాలని సూచిస్తుంది. ఈ ఉల్లేఖనంతో అనుబంధించబడిన పద్ధతి పరీక్ష తరగతిలోని పరీక్షా పద్ధతుల సంఖ్యతో సంబంధం లేకుండా ఒకసారి మాత్రమే (పరీక్ష ప్రారంభంలో) అమలు చేయబడుతుంది.

@BeforeAll ఉల్లేఖనాన్ని ఉపయోగించే ఏదైనా పద్ధతి తప్పనిసరిగా కొన్ని నిబంధనలను అనుసరించాలి. ఈ పద్ధతులు తప్పనిసరిగా శూన్యమైన రిటర్న్ రకాన్ని కలిగి ఉండాలి, పబ్లిక్‌గా ఉండాలి మరియు ప్రైవేట్‌గా ఉండకూడదు. @BeforeAll ఉల్లేఖనాన్ని స్థాపించడానికి అనువైనది డేటాబేస్కు కనెక్షన్ లేదా కొత్త ఫైల్‌ను సృష్టించడం. మీరు @BeforeAll ఉల్లేఖనాన్ని ఎలా ఉపయోగించవచ్చో చూపించడానికి ఈ కథనం కాలిక్యులేటర్ పరీక్ష తరగతిని ఉపయోగిస్తుంది.

కాలిక్యులేటర్ క్లాస్

package com.app; 
public class Calculator { 
      public static int add(int num1, int num2) { 
             return num1 + num2; 
      } 
      public static int subtract(int num1, int num2) { 
             return num1 - num2; 
      } 
      public static int multiply(int num1, int num2) { 
             return num1 * num2; 
      } 
      public static int divide(int num1, int num2) { 
             return num1 / num2; 
      } 
}

కాలిక్యులేటర్ టెస్ట్ క్లాస్

import static org.junit.jupiter.api.Assertions.*; 
import org.junit.jupiter.api.BeforeAll; 
import org.junit.jupiter.api.Test; 
import org.junit.jupiter.api.DisplayName; 
  
@DisplayName("Test class demonstrating how to use the before and after annotations.") 
class CalculatorTest { 
      @BeforeAll 
      public static void powerOnCalculator() { 
             System.out.println("The calculator is on"); 
      } 
  
      @Test 
      @DisplayName("Testing method that adds two integer values.") 
      public void testAdd() { 
             assertEquals(7, Calculator.add(3, 4)); 
      }      
  
      @Test 
      @DisplayName("Testing method that subtracts one integer value from another.") 
      public void testSubtract() { 
             assertEquals(6, Calculator.subtract(9, 3)); 
      } 
  
      @Test 
      @DisplayName("Testing method that multiplies two integer values") 
      public void testMultiply() { 
             assertEquals(10, Calculator.multiply(5, 2)); 
      } 
  
      @Test 
      @DisplayName("Testing method that divides one integer value by another") 
      public void testDivide() { 
             assertEquals(2, Calculator.divide(4, 2)); 
      } 
}

ఈ తరగతిలో, @BeforeAll ఉల్లేఖనం powerOnCalculator() పద్ధతితో పని చేస్తుంది, ఇది ఏదైనా టెస్ట్ రన్‌కు ముందు “కాలిక్యులేటర్ ఆన్‌లో ఉంది” అని ప్రింట్ చేస్తుంది. విజయవంతమైన పరీక్ష అమలు క్రింది పరీక్ష నివేదికను ముద్రిస్తుంది:

మీరు చూడగలిగినట్లుగా @BeforeAll ఉల్లేఖనతో అనుబంధించబడిన పద్ధతి పరీక్ష నివేదికలో కనిపించదు. అయితే, @BeforeAll ఉల్లేఖన పద్ధతిలో లోపం ఉన్నట్లయితే, పరీక్ష నివేదిక ఫలితాలు దీనిని వైఫల్యంతో సూచిస్తాయి.

facebook స్నేహితుల ఆన్‌లైన్ జాబితా చూపడం లేదు

@BeforeEach ఉల్లేఖనం

@BeforeAll ఉల్లేఖన పద్ధతి వలె, @BeforeEach ఉల్లేఖన పద్ధతి పరీక్ష నివేదికలో కనిపించదు. @BeforeEach ఉల్లేఖన పద్ధతి పరీక్ష తరగతిలో ప్రతి పరీక్ష పద్ధతికి ముందు అమలు చేయబడుతుంది. కాబట్టి, ఒక పరీక్ష తరగతి రెండు పరీక్ష పద్ధతులను కలిగి ఉంటే, @BeforeEach ఉల్లేఖనం రెండుసార్లు అమలు చేయబడుతుంది.

---

---

import static org.junit.jupiter.api.Assertions.*; 
import org.junit.jupiter.api.BeforeAll; 
import org.junit.jupiter.api.BeforeEach; 
import org.junit.jupiter.api.Test; 
@DisplayName("Test class demonstrating how to use the before and after annotations.") 
class CalculatorTest { 
      @BeforeAll 
      public static void powerOnCalculator() { 
             System.out.println("The calculator is on"); 
      } 
      @BeforeEach 
      public void clearCalculator() { 
             System.out.println("The calculator is ready"); 
      } 
      @Test 
      @DisplayName("Testing method that adds two integer values.") 
      public void testAdd() { 
             assertEquals(7, Calculator.add(3, 4)); 
      }      
      @Test 
      @DisplayName("Testing method that subtracts one integer value from another.") 
      public void testSubtract() { 
             assertEquals(6, Calculator.subtract(9, 3)); 
      } 
      @Test 
      @DisplayName("Testing method that multiplies two integer values") 
      public void testMultiply() { 
             assertEquals(10, Calculator.multiply(5, 2)); 
      } 
      @Test 
      @DisplayName("Testing method that divides one integer value by another") 
      public void testDivide() { 
             assertEquals(2, Calculator.divide(4, 2)); 
      } 
} 

కాలిక్యులేటర్ టెస్ట్ తరగతికి @BeforeEach ఉల్లేఖనాన్ని జోడించడం వలన కింది అవుట్‌పుట్ ఉత్పత్తి అవుతుంది:

@BeforeEach ఉల్లేఖనంతో అనుబంధించబడిన పద్ధతి ప్రతి పరీక్ష పద్ధతికి ముందు ఒకసారి నాలుగు సార్లు అమలు చేయబడుతుంది. @BeforeEach పద్ధతి స్టాటిక్ కాదని, శూన్యమైన రిటర్న్ రకాన్ని కలిగి ఉందని మరియు ప్రైవేట్ కాదని మీరు గమనించాలి, ఎందుకంటే ఇవి తప్పనిసరి నిబంధనలు. @BeforeEach ఉల్లేఖనంతో అనుబంధించబడిన పద్ధతి @BeforeAll పద్ధతి తర్వాత నడుస్తుందని కూడా గమనించడం ముఖ్యం.

---

---

@AfterAll ఉల్లేఖన

@AfterAll ఉల్లేఖనంతో ఒక పద్ధతి పరీక్ష తరగతిలోని అన్ని పరీక్ష పద్ధతులు వాటి అమలును పూర్తి చేసిన తర్వాత అమలు చేయబడుతుంది. @AfterAll ఉల్లేఖన అనువైనది ప్రాథమిక ఫైల్ కార్యకలాపాలు , ఫైల్‌ను మూసివేయడం లేదా డేటాబేస్ నుండి డిస్‌కనెక్ట్ చేయడం వంటివి. @AfterAll ఉల్లేఖన అనేది @BeforeAll ఉల్లేఖనానికి ప్రతిరూపం. @BeforeAll ఉల్లేఖనం వలె, @AfterAll ఉల్లేఖనం తప్పనిసరిగా స్థిరంగా ఉండాలి, తప్పక శూన్యంగా ఉండాలి మరియు చాలా వరకు ప్రైవేట్‌గా ఉండకూడదు.

@AfterAll 
public static void powerOffCalculator() { 
    System.out.println("The calculator is off"); 
}

ఇప్పటికే ఉన్న కాలిక్యులేటర్ టెస్ట్ క్లాస్‌కు @AfterAll ఉల్లేఖన పద్ధతిని జోడించడం వలన కన్సోల్‌కు క్రింది అవుట్‌పుట్ ప్రింట్ చేయబడుతుంది:

@AfterAll ఉల్లేఖనాన్ని ఉపయోగించే powerOffCalculator() పద్ధతి అన్ని పరీక్ష పద్ధతులను అమలు చేసిన తర్వాత పరీక్ష తరగతి చివరిలో ముద్రించబడుతుందని గమనించండి.

@AfterEach ఉల్లేఖన

@AfterEach ఉల్లేఖన @BeforeEach ఉల్లేఖనానికి ప్రతిరూపం. వాటికి ఒకే విధమైన తప్పనిసరి నిబంధనలు ఉన్నాయి, ఇవి @BeforeAll మరియు @AfterAll ఉల్లేఖనాల నుండి కొద్దిగా భిన్నంగా ఉంటాయి. @AfterEach ఉల్లేఖనాన్ని @BeforeEach ఉల్లేఖనం (వారి పేర్లు కాకుండా) నుండి వేరు చేసేది ఏమిటంటే @AfterEach పద్ధతి ప్రతి పరీక్ష పద్ధతి తర్వాత నడుస్తుంది.

@AfterEach 
public void returnResults() { 
    System.out.println("The results are ready"); 
}

కాలిక్యులేటర్ టెస్ట్ క్లాస్‌ని అమలు చేయడం కింది అవుట్‌పుట్‌ను కన్సోల్‌కు ప్రింట్ చేస్తుంది:

ఇంటర్నెట్ విండోస్ 7 కి కనెక్ట్ చేయడం సాధ్యం కాదు

@AfterEach ఉల్లేఖనం (రిటర్న్ రిజల్ట్స్)తో అనుబంధించబడిన పద్ధతి నాలుగు సార్లు ప్రింట్ చేయబడుతుందని అవుట్‌పుట్ చూపిస్తుంది. రిటర్న్ రిజల్ట్స్() పద్ధతి యొక్క ప్రతి అమలు ప్రతి యూనిట్ పరీక్షను అమలు చేసిన తర్వాత మాత్రమే జరుగుతుంది. @BeforeEach ఉల్లేఖనంతో అనుబంధించబడిన పద్ధతి నుండి ప్రతి అవుట్‌పుట్ తర్వాత, returnResults() పద్ధతి అవుట్‌పుట్ కనిపించడం ద్వారా ఇది స్పష్టమవుతుంది.

ఉల్లేఖనాలను ఉపయోగించి మీ టెస్ట్ సూట్‌లను పోలిష్ చేయండి

JUnit ముందు మరియు తర్వాత జత ఉల్లేఖనాలను ఉపయోగించి నాన్-టెస్ట్ సంబంధిత ప్రక్రియలను నిర్వహించడానికి మిమ్మల్ని అనుమతిస్తుంది. ఈ నాలుగు ఉల్లేఖనాలు మీ పరీక్షలకు విలువను జోడించే అనేక ఇతర ఉల్లేఖనాల జాబితాకు చెందినవి. JUnit యొక్క మరొక ఉల్లేఖన @DisplayName.

పూర్తి కాలిక్యులేటర్ టెస్ట్ తరగతిని ప్రదర్శించే రెండు కోడ్ ఉదాహరణలు @DisplayName ఉల్లేఖనాన్ని ఉపయోగిస్తాయి. @DisplayName ఉల్లేఖనం మీ పరీక్ష తరగతులు మరియు పరీక్షా పద్ధతుల కోసం మరింత అర్థవంతమైన పేర్లను రూపొందించడంలో మీకు సహాయపడుతుంది.