JUnitతో జావాలో యూనిట్ టెస్టింగ్

జావాలో యూనిట్ టెస్టింగ్ అంటే ఏమిటి?

మనం జావాలో జూనిట్ నేర్చుకునే ముందు, యూనిట్ టెస్టింగ్ అంటే ఏమిటి మరియు అది ఎందుకు బాగా ప్రాచుర్యం పొందిందో క్లుప్తంగా చూద్దాం (మీకు ఈ విషయం ఇప్పటికే తెలిస్తే, 'నేను జావాలో జూనిట్ టెస్ట్ ఎలా రాయాలి?'కి దాటవేయండి). జావాలో యూనిట్ టెస్టింగ్ పెద్ద ఎత్తున సాఫ్ట్‌వేర్ డెవలప్‌మెంట్‌ను మరింత సమర్థవంతంగా మరియు అప్రయత్నంగా చేస్తుంది. ఇది వ్యక్తులకు మరియు బృందాలకు లెక్కలేనన్ని గంటలపాటు డీబగ్గింగ్‌ను తగ్గించడంలో సహాయపడుతుంది మరియు సహకార ప్రక్రియను అపారంగా క్రమబద్ధం చేస్తుంది.

https://junit.org/junit4/

యూనిట్ టెస్టింగ్ యొక్క ముఖ్యమైన ఆలోచన ఇది: వ్యక్తిగత లక్షణాల యొక్క పరమాణు పరీక్షలను వ్రాయండి (యూనిట్ పరీక్షలు అని పిలుస్తారు) మరియు పరీక్షించిన తర్వాత మరియు మునుపటి వాటిని పని చేసేలా చూసుకున్న తర్వాత నెమ్మదిగా మరిన్ని ఫీచర్లను జోడించండి. ఇది చాలా సులభమైన కానీ శక్తివంతమైన ఆలోచన. ఈ ప్రక్రియ ఎలా ఉంటుందో ఉదాహరణగా, మీరు వర్చువల్ సైంటిఫిక్ కాలిక్యులేటర్‌ని నిర్మిస్తున్నారని ఊహించుకోండి. స్పష్టమైన అంకగణిత ఆపరేటర్‌ల పైన ( +, -, x, %), ఈ కాలిక్యులేటర్ దానిలో పని చేయడానికి ఇతర ఉప ఫీచర్లు అవసరమయ్యే అధునాతన లక్షణాలను కలిగి ఉంటుంది. ఘాతాంకాలను గణించడానికి, మీ కాలిక్యులేటర్ సరిగ్గా గుణించగలగాలి. కాబట్టి ఈ కాలిక్యులేటర్‌ని నిర్మించడానికి మరియు పరీక్షించడానికి యూనిట్ టెస్టింగ్ విధానం ఇలా ఉంటుంది:

• అదనంగా ఫంక్షన్ వ్రాయండి. దీన్ని జాగ్రత్తగా పరీక్షించండి, మార్చండి, అది పనిచేసే వరకు పునరావృతం చేయండి.
• తీసివేత, గుణకారం, భాగహారం ఫంక్షన్ల కోసం అదే చేయండి.
• ఎక్స్‌పోనెంట్‌ల వంటి మరింత అధునాతన ఆపరేటర్ ఫంక్షన్‌లను వ్రాయడానికి ఈ బేస్ ఆపరేటర్‌లను ఉపయోగించండి, ఆపై ఆ ఫంక్షన్‌లను కూడా పరీక్షించండి.

ఇతర చిన్న ఉప ఫీచర్లను నిర్మించే ఫీచర్లు వాటి స్వంత హక్కులో సరిగ్గా పని చేయడమే కాకుండా దానిలో తప్పు ఉప ఫీచర్లను కలిగి ఉండవని ఇది నిర్ధారిస్తుంది. ఉదాహరణకు, నేను ఘాతాంకం ఫంక్షన్‌ని పరీక్షిస్తున్నట్లయితే మరియు ఏదో తప్పు జరుగుతుంటే, గుణకారం ఫంక్షన్ ఇప్పటికే విస్తృతంగా పరీక్షించబడినందున బగ్ బహుశా గుణకార ఉపలక్షణంలో లేదని నాకు తెలుసు. ఇది బగ్‌ను కనుగొనడానికి నేను బ్యాక్‌ట్రేస్ మరియు ఇన్‌స్పెక్ట్ చేయాల్సిన మొత్తం కోడ్‌ను చాలా వరకు తొలగిస్తుంది. ఆశాజనక, ఈ అల్పమైన ఉదాహరణ యూనిట్ టెస్టింగ్ చుట్టూ ఉన్న ఆలోచన ప్రక్రియ ఎలా నిర్మితమైందో స్పష్టం చేస్తుంది. అయితే మిగిలిన సాఫ్ట్‌వేర్ డెవలప్‌మెంట్ ప్రాసెస్‌తో యూనిట్ టెస్టింగ్ ఎలా ఇంటరాక్ట్ అవుతుంది? మీరు కలిసి పని చేయడానికి మరియు కమ్యూనికేట్ చేయడానికి మరింత సంక్లిష్టమైన లక్షణాలను కలిగి ఉంటే ఏమి చేయాలి? అటువంటి సంక్లిష్ట లక్షణాలు సరిగ్గా కలిసి పనిచేయగలవని నిర్ధారించడానికి యూనిట్ పరీక్ష సరిపోదు. వాస్తవానికి, ఇది సాఫ్ట్‌వేర్ టెస్టింగ్ యొక్క నాలుగు స్థాయిలలో మొదటి దశ మాత్రమే (నేను పెద్ద అక్షరాలను ఉపయోగిస్తాను ఎందుకంటే నేను పరిశ్రమ ప్రమాణాన్ని లేదా సాఫ్ట్‌వేర్‌ను పరీక్షించడానికి అత్యంత సాధారణ విధానాన్ని సూచిస్తాను). చివరి మూడు దశలుఇంటిగ్రేషన్ టెస్టింగ్ , సిస్టమ్ టెస్టింగ్ , మరియు యాక్సెప్టెన్స్ టెస్టింగ్. వీటన్నింటికీ బహుశా వారు ఏమి చేస్తారని మీరు అనుకుంటున్నారో ఖచ్చితంగా అర్థం చేసుకోవచ్చు, కానీ నేను స్పష్టం చేస్తాను: ఇంటిగ్రేషన్ టెస్టింగ్ అంటే పైన పేర్కొన్న "సంక్లిష్ట లక్షణాలు" ఒకదానితో ఒకటి సరిగ్గా ఇంటరాక్ట్ అవ్వడానికి మేము ఏమి చేస్తాము. (ఉదా, కాలిక్యులేటర్ “3 + 7 * 4 - 2”ని నిర్వహించగలదని నిర్ధారించుకోవడం) సిస్టమ్ పరీక్ష అనేది నిర్దిష్ట సిస్టమ్ యొక్క మొత్తం రూపకల్పనను పరీక్షిస్తోంది; ఒక ఉత్పత్తిలో సంక్లిష్ట లక్షణాల యొక్క బహుళ సిస్టమ్‌లు కలిసి పని చేస్తాయి, కాబట్టి మీరు వీటిని సిస్టమ్‌లుగా సమూహపరచండి మరియు వాటిని ఒక్కొక్కటిగా పరీక్షించండి. (ఉదా. మీరు గ్రాఫింగ్ కాలిక్యులేటర్‌ను రూపొందిస్తున్నట్లయితే, మీరు మొదట సంఖ్యలతో వ్యవహరించడానికి అంకగణిత 'సిస్టమ్'ను రూపొందించాలి, అది ఉద్దేశించిన విధంగా పని చేసే వరకు పరీక్షించండి, ఆపై మీరు ఉపసంహరణను ఎదుర్కోవడానికి గ్రాఫింగ్ 'సిస్టమ్'ని నిర్మించి పరీక్షించాలి. ఇది అంకగణిత వ్యవస్థను నిర్మిస్తుంది). అంగీకార పరీక్ష అనేది వినియోగదారు స్థాయి పరీక్ష; వినియోగదారులు ఆమోదించడానికి సిద్ధంగా ఉన్న తుది ఉత్పత్తిని సృష్టించడానికి అన్ని సిస్టమ్‌లు సమకాలీకరణలో పని చేయవచ్చో లేదో చూస్తోంది (ఉదా, వినియోగదారులు కాలిక్యులేటర్‌ని పరీక్షిస్తున్నారు). సాఫ్ట్‌వేర్ డెవలపర్‌లు కొన్నిసార్లు ఈ ప్రక్రియ యొక్క చివరి దశను విస్మరించవచ్చు, ఎందుకంటే కంపెనీలు తరచుగా ఇతర ఉద్యోగులు వినియోగదారు (బీటా) పరీక్షలను విడిగా అమలు చేస్తాయి.

నేను జావాలో జూనిట్ పరీక్షను ఎలా వ్రాయగలను?

ఇప్పుడు యూనిట్ టెస్టింగ్ యొక్క ప్రయోజనాలు మరియు పరిమితుల గురించి మీకు స్పష్టమైన ఆలోచన ఉంది, కొన్ని కోడ్‌లను పరిశీలిద్దాం! మేము JUnit అనే జనాదరణ పొందిన జావా టెస్టింగ్ ఫ్రేమ్‌వర్క్‌ని ఉపయోగిస్తాము (మరొక ప్రసిద్ధమైనది TestNG, ఇది మీకు నచ్చితే మీరు కూడా ఉపయోగించవచ్చు. అవి చాలా సారూప్యమైనవి, వాక్యనిర్మాణం; TestNG JUnit నుండి ప్రేరణ పొందింది). మీరు ఇక్కడ JUnitని డౌన్‌లోడ్ చేసి, ఇన్‌స్టాల్ చేసుకోవచ్చు . ఈ ఉదాహరణ కోడ్ కోసం, నేను ఇంతకు ముందు పేర్కొన్న 'శాస్త్రీయ కాలిక్యులేటర్' ఉదాహరణను మేము కొనసాగిస్తాము; మీ తల చుట్టూ చుట్టుకోవడం చాలా సులభం మరియు పరీక్ష కోడ్ చాలా సులభం. మీ ప్రతి తరగతికి వేర్వేరుగా పరీక్షా తరగతులు రాయడం సంప్రదాయ అభ్యాసం, కాబట్టి మేము అదే చేస్తాము. Math.javaఈ సమయంలో, మన వద్ద అన్ని గణిత విధులు (తో సహా) ఉన్న ఫైల్ ఉందని అనుకుందాం Math.addమరియు మనం ఒక వ్రాస్తున్నాముMathTests.javaఅదే ప్యాకేజీలో ఫైల్. ఇప్పుడు దిగుమతి స్టేట్‌మెంట్‌లు మరియు క్లాస్ బాడీని సెటప్ చేద్దాం: (జూనిట్ ఇంటర్వ్యూ ప్రశ్న: మీ జూనిట్ పరీక్షను ఎక్కడ ఉంచాలి మరియు మీ సోర్స్ ఫైల్‌లను దిగుమతి చేసుకోవాలా వద్దా అని మిమ్మల్ని అడగవచ్చు. మీరు మీ టెస్ట్ క్లాస్‌లను అదే ప్యాకేజీలో వ్రాస్తున్నట్లయితే మీ ప్రధాన తరగతులు, పరీక్ష తరగతిలో మీ సోర్స్ ఫైల్‌ల కోసం మీకు ఎలాంటి దిగుమతి స్టేట్‌మెంట్‌లు అవసరం లేదు. లేకపోతే, మీరు మీ సోర్స్ ఫైల్‌లను దిగుమతి చేసుకుంటున్నారని నిర్ధారించుకోండి!)

import org.junit.jupiter.Test;    //gives us the @Test header
import static org.junit.jupiter.api.Assertions.assertEquals; //less typing :) 

public class MathTests {
	//...
}

మొదటి దిగుమతి ప్రకటన మాకు @Testహెడర్ ఇస్తుంది. మేము @Testప్రతి టెస్ట్ ఫంక్షన్ డెఫినిషన్ పైన నేరుగా ' ' అని వ్రాస్తాము, తద్వారా ఇది విడిగా అమలు చేయగల ఏకైక యూనిట్ పరీక్ష అని JUnitకి తెలుస్తుంది. తరువాత, మీరు ఈ హెడర్‌ని ఉపయోగించి నిర్దిష్ట యూనిట్ పరీక్షలను ఎలా అమలు చేయవచ్చో నేను మీకు చూపుతాను. రెండవ దిగుమతి స్టేట్‌మెంట్ మనకు టైపింగ్‌ను కొద్దిగా ఆదా చేస్తుంది. మా ఫంక్షన్‌లను పరీక్షించడానికి మేము ఉపయోగించే ప్రాథమిక JUnit ఫంక్షన్ టు Assert.assertEquals(), ఇది రెండు పారామితులను తీసుకుంటుంది (వాస్తవ విలువ మరియు అంచనా విలువ) మరియు అవి సమానంగా ఉన్నాయని నిర్ధారిస్తుంది. assertEquals(...ఈ రెండవ దిగుమతి ప్రకటనను కలిగి ఉండటం వలన అది ఏ ప్యాకేజీలో భాగమో ప్రతిసారీ పేర్కొనడానికి బదులుగా ' ' అని టైప్ చేయడానికి అనుమతిస్తుంది . ఇప్పుడు 2 + 2 నిజానికి 4 అని ధృవీకరించడానికి చాలా సులభమైన పరీక్ష కేసును వ్రాద్దాం!

import org.junit.jupiter.Test; // gives us the @Test header
import static org.junit.jupiter.api.Assertions.assertEquals; // less typing :) 


public class MathTests {
	@Test
	public void add_twoPlusTwo_returnsFour(){
	final int expected = 4;
	final int actual = Math.add(2, 2);
	assertEquals(“2+2 is 4”, actual, expected);
	}
}

టెస్ట్ ఫంక్షన్ యొక్క ప్రతి ఐదు లైన్‌లను మరియు అవి ఏమి చేస్తాయో చూద్దాం: పంక్తి 5: @Testదిగువ ఫంక్షన్ నిర్వచనం add_twoPlusTwo_returnsFour()నిజానికి JUnit విడిగా అమలు చేయగల టెస్ట్ ఫంక్షన్ అని ఈ హెడర్ నిర్దేశిస్తుంది. 6వ పంక్తి: ఇది మా పరీక్ష కేసుకు సంబంధించిన ఫంక్షన్ సిగ్నేచర్. పరీక్ష కేసులు ఎల్లప్పుడూ చాలా ఏకవచనం; వారు 2+2=4 వంటి ఒక నిర్దిష్ట ఉదాహరణను మాత్రమే పరీక్షిస్తారు. మీరు పరీక్షిస్తున్న ఫంక్షన్ పేరు, మీరు పరీక్షిస్తున్న నిర్దిష్ట ఉదాహరణ పారామితులు మరియు ఫంక్షన్ యొక్క ఆశించిన రిటర్న్ విలువ అయిన " [function]_[params]_returns[expected]()" రూపంలో మీ పరీక్ష కేసులకు పేరు పెట్టడం సంప్రదాయం . టెస్ట్ ఫంక్షన్‌లు దాదాపు ఎల్లప్పుడూ ' ' రిటర్న్ రకాన్ని కలిగి ఉంటాయి ఎందుకంటే మొత్తం ఫంక్షన్ యొక్క ప్రధాన అంశం అమలు చేయడమే[function][params][expected]voidassertEquals, ఇది మీ పరీక్షలో ఉత్తీర్ణత సాధించినా కాకపోయినా కన్సోల్‌కు అవుట్‌పుట్ చేస్తుంది; మీరు ఎక్కడికీ తిరిగి ఏ ఇతర డేటా అవసరం లేదు. పంక్తి 7: మేము finalరిటర్న్ టైప్ యొక్క ' ' వేరియబుల్‌ని ప్రకటిస్తాము Math.add (int)మరియు దానికి కన్వెన్షన్ ద్వారా 'అంచనా' అని పేరు పెడతాము. దాని విలువ మనం ఆశించే సమాధానం (4). పంక్తి 8: మేము finalరిటర్న్ టైప్ యొక్క ' ' వేరియబుల్‌ని ప్రకటిస్తాము Math.add (int)మరియు దానికి సంప్రదాయం ప్రకారం 'అసలు' అని పేరు పెడతాము. దీని విలువ ఫలితం Math.add(2, 2). లైన్ 9: గోల్డెన్ లైన్. ఇది అసలైన మరియు ఊహించిన వాటిని పోల్చి చూసే లైన్ మరియు అవి సమానంగా ఉంటేనే మనం పరీక్షలో ఉత్తీర్ణులయ్యామని చెబుతుంది. "2+2 ఈజ్ 4" పాస్ చేసిన మొదటి పరామితి పరీక్ష ఫంక్షన్ యొక్క వివరణ.

ఒకవేళ నా ఫంక్షన్ మినహాయింపుని ఇస్తే?

మీ నిర్దిష్ట పరీక్ష ఉదాహరణ వాస్తవమైన మరియు ఆశించిన విలువ సమానంగా ఉంటుందని నొక్కిచెప్పడానికి బదులుగా మినహాయింపును అందించినట్లయితే, JUnit హెడర్‌లో దీనిని స్పష్టం చేసే మార్గాన్ని కలిగి ఉంటుంది @Test. క్రింద ఒక ఉదాహరణను పరిశీలిద్దాం. Math.javaకాల్‌లో మనకు ఒక ఫంక్షన్ ఉందని ఊహిస్తే Math.divide, ఇన్‌పుట్‌లను 0తో భాగించలేమని నిర్ధారించుకోవాలి. బదులుగా, Math.divide(a, 0)ఏదైనా 'a' విలువ కోసం కాల్ చేయడానికి ప్రయత్నిస్తే మినహాయింపు ( ArithmeticException.class) వేయాలి. మేము హెడర్‌లో ఇలా పేర్కొన్నాము:

import org.junit.jupiter.Test; // gives us the @Test header
import static org.junit.jupiter.api.Assertions.assertEquals; // less typing :) 


public class MathTests {
	@Test (expectedExceptions = ArithmeticException.class)
	public void divide_byZero_throwsException() throws ArithmeticException{
	Math.divide(1, 0);
	}
}

మీరు కోసం ఒకటి కంటే ఎక్కువ మినహాయింపులను కలిగి ఉండవచ్చు expectedExceptions, మీ మినహాయింపు తరగతులను జాబితా చేయడానికి బ్రాకెట్‌లు మరియు కామాలను ఉపయోగించాలని నిర్ధారించుకోండి:

expectedException = {FirstException.class, SecondException.class, … }

నేను జావాలో నా జూనిట్ పరీక్షలను ఎలా అమలు చేయాలి?

IntelliJకి JUnitని ఎలా జోడించాలి: https://stackoverflow.com/questions/19330832/setting-up-junit-with-intellij-idea మీరు సాధారణంగా పరీక్షలను అమలు చేస్తున్నట్లే మీ ప్రాజెక్ట్‌ను అమలు చేయవచ్చు. పరీక్ష తరగతిలో అన్ని పరీక్షలను అమలు చేయడం వలన అవి అక్షర క్రమంలో అమలు చేయబడతాయి. జూన్ 5లో, మీరు ట్యాగ్‌ని జోడించడం ద్వారా పరీక్షలకు ప్రాధాన్యతను జోడించవచ్చు @Order. ఒక ఉదాహరణ:

@TestMethodOrder(OrderAnnotation.class)
public class Tests {
…
@Test
@Order(2)
public void a_test() { … }

@Test
@Order (1)
public void b_test() { … }
…
}

అక్షరక్రమంలో మరియు కోడ్‌లో a_test()ముందు వచ్చినప్పటికీ , ఇక్కడ ముందు రన్ అవుతుంది , ఎందుకంటే క్రమంలో 2 కంటే ముందు 1 వస్తుంది. కాబట్టి ఇది జూనిట్ యొక్క ప్రాథమిక అంశాలకు సంబంధించినది. ఇప్పుడు, కొన్ని సాధారణ జూనిట్ ఇంటర్వ్యూ ప్రశ్నలను పరిష్కరిద్దాం, అలాగే జూనిట్ గురించి మరికొన్ని తెలుసుకుందాం! b_test()b_test()a_test()

జూనిట్ ఇంటర్వ్యూ ప్రశ్నలు (అదనపు సమాచారం)

ఇక్కడ నేను అత్యంత ప్రజాదరణ పొందిన జూనిట్ ఇంటర్వ్యూ ప్రశ్నలను సేకరించాను. మీరు జోడించడానికి ఏదైనా ఉంటే - దిగువ వ్యాఖ్యలలో దీన్ని చేయడానికి సంకోచించకండి. ప్ర: పరీక్షలో స్వయంచాలకంగా విఫలం కావడానికి మీరు మీ పరీక్ష పద్ధతిలో ఏ పద్ధతిని కాల్ చేయవచ్చు? A: విఫలం ("లోపం వివరణ ఇక్కడ!"); ప్ర: మీరు డాగ్ క్లాస్‌ని పరీక్షిస్తున్నారు; డాగ్ ఆబ్జెక్ట్‌ను పరీక్షించడానికి, మీరు దానిపై పరీక్షలను అమలు చేయడానికి ముందు మీరు దానిని తక్షణం చేయాలి. కాబట్టి మీరు కుక్కను ఇన్‌స్టాంటియేట్ చేయడానికి సెటప్() ఫంక్షన్‌ను వ్రాస్తారు. మీరు అన్ని పరీక్షల సమయంలో ఈ ఫంక్షన్‌ని ఒకసారి మాత్రమే అమలు చేయాలనుకుంటున్నారు. మీరు సెటప్() ఫంక్షన్ సిగ్నేచర్ పైన నేరుగా ఏమి ఉంచాలి కాబట్టి పరీక్షలను అమలు చేయడానికి ముందు సెటప్()ని అమలు చేయాలని JUnitకి తెలుసు? A: @BeforeClass (@BeforeAll in Junit 5) ప్ర:పైన వివరించిన సెటప్() ఫంక్షన్ ఫంక్షన్ సిగ్నేచర్ ఏమై ఉండాలి? జ: పబ్లిక్ స్టాటిక్ శూన్యం. @BeforeClass (@BeforeAll in JUnit 5) లేదా @AfterClass (@AfterAll in JUnit 5)తో ఏదైనా ఫంక్షన్ స్టాటిక్‌గా ఉండాలి. ప్ర: మీరు డాగ్ క్లాస్‌ని పరీక్షించడం పూర్తి చేసారు. మీరు ప్రతి పరీక్ష తర్వాత కన్సోల్ చేయడానికి డేటాను శుభ్రపరుస్తుంది మరియు సమాచారాన్ని ప్రింట్ చేసే శూన్యమైన tearDown() ఫంక్షన్‌ను వ్రాస్తారు. మీరు ఈ ఫంక్షన్ ప్రతి ఒక్క పరీక్ష తర్వాత అమలు చేయాలనుకుంటున్నారు. TearDown() ఫంక్షన్ సిగ్నేచర్ పైన మీరు నేరుగా ఏమి ఉంచాలి కాబట్టి ప్రతి పరీక్షను అమలు చేసిన తర్వాత TearDown()ని అమలు చేయాలని JUnitకి తెలుసు? జ: @తర్వాత (జూనిట్ 5లో @AfterEach)