3.1 ఉల్లేఖనాలు @BeforeEach, @AfterEach
మునుపటి ఉదాహరణలో, ప్రతి పద్ధతిలో మనం ఒక వస్తువును సృష్టించడానికి కోడ్ని వ్రాయవలసి ఉంటుందని గమనించండికాలిక్యులేటర్.
వాస్తవానికి, ఇది కేవలం ఒక లైన్ మాత్రమే, కానీ మేము నిజమైన సిస్టమ్లను పరీక్షిస్తే, మేము తరచుగా అనేక వస్తువులను సృష్టించి, కాన్ఫిగర్ చేయాల్సిన పరిస్థితిని కలిగి ఉంటాము, ఇది అనేక డజన్ల పంక్తుల కోడ్ను తీసుకోవచ్చు. ఉదాహరణ:
//Create an HttpClient object
HttpClient client = HttpClient.newBuilder()
.version(Version.HTTP_1_1)
.followRedirects(Redirect.NORMAL)
.connectTimeout(Duration.ofSeconds(20))
.proxy(ProxySelector.of(new InetSocketAddress("proxy.example.com", 80)))
.authenticator(Authenticator.getDefault())
.build();
//Create an HttpRequest object
HttpRequest request = HttpRequest.newBuilder()
.uri(new URI("https://codegym.cc"))
.headers("Content-Type", " application/octet-stream")
.POST( HttpRequest.BodyPublishers. ofInputStream ( () -> is; ))
.build();
//Call the send() method
HttpResponse response = client.send(request, BodyHandlers.ofString());
System.out.println(response.statusCode());
System.out.println(response.body());
పై ఉదాహరణలో, మేము ఒక వస్తువును సృష్టించాము మరియు కాన్ఫిగర్ చేసాముHttpClientమరియు send() పద్ధతిని పరీక్షించాలనుకుంటున్నారు .
తద్వారా ప్రతిసారీ పరీక్షా పద్ధతిలో వస్తువును సృష్టించి రాయకూడదుHttpClient, దీనిని ప్రత్యేక పద్ధతికి తరలించవచ్చు మరియు ప్రత్యేక @BeforeEach ఉల్లేఖనాన్ని ఇవ్వవచ్చు . అప్పుడు జూనిట్ ప్రతి పరీక్ష పద్ధతికి ముందు ఈ పద్ధతిని పిలుస్తాడు. ఉదాహరణ:
class HttpClientTest {
public HttpClient client;
@BeforeEach
public void init(){
client = HttpClient.newBuilder()
.version(Version.HTTP_1_1)
.followRedirects(Redirect.NORMAL)
.connectTimeout(Duration.ofSeconds(20))
.proxy(ProxySelector.of(new InetSocketAddress("proxy.example.com", 80)))
.authenticator(Authenticator.getDefault())
.build();
}
@Test
public void send200() throws Exception {
//Create an HttpRequest() object
HttpRequest request = HttpRequest.newBuilder(new URI("https://codegym.cc")).build();
//Call the send() method
HttpResponse response = client.send(request, BodyHandlers.ofString());
assertEquals(200, response.statusCode());
}
@Test
public void send404() throws Exception {
//Create an HttpRequest() object
HttpRequest request = HttpRequest.newBuilder(new URI("https://codegym.cc/unknown")).build();
//Call the send() method
HttpResponse response = client.send(request, BodyHandlers.ofString());
assertEquals(404, response.statusCode());
}
}
మీరు తదుపరి పరీక్ష పద్ధతి తర్వాత ప్రతిసారీ కాల్ చేయబడే ప్రత్యేక పద్ధతిని కూడా సృష్టించవచ్చు మరియు ఉపయోగించిన వనరులను శుభ్రపరచడం , లాగ్కు ఏదైనా వ్రాయడం మొదలైనవి చేయవచ్చు. అటువంటి పద్ధతి తప్పనిసరిగా @AfterEach ఉల్లేఖనంతో గుర్తించబడాలి .
మీకు 3 పరీక్ష పద్ధతులు ఉంటే test1() , test2() మరియు test3() , అప్పుడు కాల్ ఆర్డర్ ఇలా ఉంటుంది:
- ప్రతి పద్ధతికి ముందు
- పరీక్ష1()
- ప్రతి పద్ధతి తర్వాత
- ప్రతి పద్ధతికి ముందు
- పరీక్ష2()
- ప్రతి పద్ధతి తర్వాత
- ప్రతి పద్ధతికి ముందు
- పరీక్ష3()
- ప్రతి పద్ధతి తర్వాత
3.2 ఉల్లేఖనాలు @BeforeAll, @AfterAll
అన్ని పరీక్ష పద్ధతులకు ముందు ఒకసారి పిలవబడే పద్ధతిని జోడించడానికి కూడా JUnit మిమ్మల్ని అనుమతిస్తుంది . అటువంటి పద్ధతిని @BeforeAll తో ఉల్లేఖించాలి . ఇది జత చేసిన @AfterAll ఉల్లేఖనాన్ని కూడా కలిగి ఉంది . దానితో గుర్తించబడిన పద్ధతి అన్ని పరీక్ష పద్ధతుల తర్వాత JUnit ద్వారా పిలువబడుతుంది.
ఇది ఎలా పని చేస్తుందో బాగా అర్థం చేసుకోవడానికి మిమ్మల్ని అనుమతించే ఒక ప్రత్యేక ఉదాహరణను వ్రాద్దాం. మా కాలిక్యులేటర్ యొక్క పరీక్షను ప్రాతిపదికగా తీసుకుందాం:
class CalculatorTest {
private Calculator calc = new Calculator();
@BeforeAll
public static void init(){
System.out.println("BeforeAll init() method called");
}
@BeforeEach
public void initEach(){
System.out.println("BeforeEach initEach() method called");
}
@Test
public void add(){
System.out.println("Testing Addition");
}
@Test
public void sub() {
System.out.println("Testing Subtraction");
}
@Test
public void mul(){
System.out.println("Testing Multiplication");
}
@Test
public void div() {
System.out.println("Testing Division");
}
}
ఈ పరీక్ష కన్సోల్కు కింది వచనాన్ని ప్రింట్ చేస్తుంది:
BeforeAll init() method called
BeforeEach initEach() method called
Testing Addition
BeforeEach initEach() method called
Testing Subtraction
BeforeEach initEach() method called
Testing Multiplication
BeforeEach initEach() method called
Testing Division
GO TO FULL VERSION