యూనిట్ టెస్టింగ్ అంటే ఏమిటి?
దేనిని అర్థం చేసుకోవడం మొదటి దశ యూనిట్ పరీక్ష అర్థం. యూనిట్ పరీక్ష చిన్న కోడ్ యూనిట్లు లేదా మాడ్యూల్‌లు ప్రతి ఒక్కటి ఆశించిన విధంగా పనిచేస్తాయని నిర్ధారించడానికి పరీక్షించే ప్రక్రియను సూచిస్తుంది. యూనిట్ పరీక్ష కోడ్ నుండి సమస్యలను తొలగించడానికి, కోడ్ స్థిరత్వాన్ని మెరుగుపరచడానికి మరియు కోడ్‌ను నవీకరిస్తున్నప్పుడు ఖచ్చితత్వాన్ని నిర్ధారించడానికి ఉపయోగించబడుతుంది. సాఫ్ట్‌వేర్ పరీక్ష యొక్క ప్రారంభ దశ యూనిట్ పరీక్ష , దీని తర్వాత UI పరీక్ష మరియు ఇంటిగ్రేషన్ పరీక్ష ఉంటుంది.
టెస్టింగ్ ప్యాకేజీ
గోలాంగ్‌లో, యూనిట్ పరీక్ష అనే ప్యాకేజీని ఉపయోగించి నిర్వహించబడుతుంది పరీక్ష . ప్యాకేజీ మన కోడ్‌ని పరీక్షించడానికి అనుమతించే వివిధ విధులను అందిస్తుంది. టెస్టింగ్ ప్యాకేజీ సహాయంతో గో కోడ్ స్వయంచాలకంగా పరీక్షించబడుతుంది.
పరీక్షించడానికి ఉదాహరణ ప్రోగ్రామ్
మేము ఏదైనా వ్రాయడానికి ముందు మా పరీక్షలను విశ్లేషించడానికి మాకు కొంత కోడ్ అవసరం యూనిట్ పరీక్షలు . మేము రెండు సంఖ్యలను జోడించే చిన్న ప్రోగ్రామ్‌ను సృష్టిస్తాము.
ప్యాకేజీ ప్రధాన
దిగుమతి (
'fmt'
)
funcAdd ( a int , బి int ) int {
తిరిగి a + బి
}
ఫంక్ మెయిన్ ( ) {
fmt Println ( జోడించు ( 2 , 3 ) )
}
పై కోడ్ నిర్వచిస్తుంది జోడించు() ఫంక్షన్, ఇది రెండు సంఖ్యలను జోడిస్తుంది, a మరియు బి , ఇన్‌పుట్‌లుగా మరియు ఫలితాన్ని పూర్ణాంకంగా అవుట్‌పుట్ చేస్తుంది. 2 మరియు 3 సంఖ్యలను జోడించడం ఫలితాన్ని ముద్రించే ముందు ప్రధాన విధి చేస్తుంది.
ప్రయాణంలో యూనిట్ పరీక్షలు రాయడం యొక్క సమావేశం
ప్రతి గో ప్రాజెక్ట్‌కు ఆ ప్రాజెక్ట్‌కు సంబంధించిన అన్ని పరీక్షలను కలిగి ఉండే ప్రత్యేక టెస్ట్ ఫైల్ ఉండాలి. ఫైల్‌కు పరీక్షిస్తున్న ఫైల్‌కు అదే పేరు ఉండాలి మరియు కలిగి ఉండాలి _test.go ఫైల్ పేరు చివర జోడించబడింది. ఉదాహరణకు, మనం పేరు పెట్టబడిన ఫైల్‌ను పరీక్షించాలనుకుంటే calculator.go , మేము మా పరీక్ష ఫైల్‌కు పేరు పెట్టాలి calculator_test.go .
ఇది ప్రామాణిక అభ్యాసం ఫైళ్లను పరీక్షించడానికి వెళ్ళండి వారు మూల్యాంకనం చేస్తున్న కోడ్ వలె అదే ప్యాకేజీ లేదా డైరెక్టరీలో ఉండాలి. మీరు గో బిల్డ్ కమాండ్‌ను ఉపయోగించినప్పుడు, కంపైలర్ ఈ ఫైల్‌లను సృష్టించదు, కాబట్టి అవి డిప్లాయ్‌మెంట్‌లలో కనిపించడం గురించి మీరు ఆందోళన చెందాల్సిన అవసరం లేదు.
వ్రాయడానికి a యూనిట్ పరీక్ష గోలో, మనం ఉపయోగించాలి పరీక్ష ప్యాకేజీ. మేము ప్రతి పరీక్ష ఫంక్షన్‌ను పదంతో ప్రారంభించవచ్చు పరీక్ష ఆపై మనం పరీక్షించాలనుకుంటున్న దాని వివరణను జోడించండి. ఉదాహరణకి, పరీక్ష అదనంగా లేదా టెస్ట్ తీసివేత . మేము పరీక్షిస్తున్న ఫంక్షన్ ఆశించిన ఫలితాలను ఇస్తుందో లేదో తనిఖీ చేసే పరీక్ష కోడ్‌ను వ్రాయవచ్చు.
గోలో, ప్రతి టెస్ట్ ఫంక్షన్ స్టేట్‌మెంట్‌తో ప్రారంభం కావాలి t := testing.T{}. ఈ ప్రకటన కొత్తదనాన్ని సృష్టిస్తుంది పరీక్ష పరీక్ష ఉత్తీర్ణత సాధించిందా లేదా విఫలమైందా అని తనిఖీ చేయడానికి మనం ఉపయోగించే వస్తువు. మేము అప్పుడు ఉపయోగించవచ్చు t.Errorf() పరీక్ష విఫలమైతే దోష సందేశాన్ని ప్రింట్ చేసే పని.
టెస్టింగ్ కోడ్ ఎలా వ్రాయాలి?
గోలో యూనిట్ పరీక్షలు రాయడం విషయానికి వస్తే, మీరు పరీక్షించాలనుకుంటున్న ప్యాకేజీని పేర్కొనడం ద్వారా ప్రారంభించడం చాలా ముఖ్యం. టెస్టింగ్ ప్యాకేజీని దిగుమతి చేసిన తర్వాత, మీరు ప్యాకేజీ ఎగుమతి చేసే వివిధ రకాలు మరియు పద్ధతులను యాక్సెస్ చేయవచ్చు పరీక్ష.T రకం. టెస్టింగ్ లాజిక్ కూడా కీవర్డ్‌తో ప్రారంభమయ్యే ఫంక్షన్‌లో వ్రాయబడుతుంది 'పరీక్ష' వంటి వివరణాత్మక పేరు తర్వాత టెస్ట్ యాడ్() . ఈ ఫంక్షన్‌లో, మీరు పరీక్ష కోసం కోడ్‌ను మరియు ఆశించిన ప్రవర్తనను ధృవీకరించడానికి అవసరమైన ఏవైనా ప్రకటనలను చేర్చవచ్చు.
సంగ్రహంగా చెప్పాలంటే, గోలో పరీక్ష యొక్క లక్షణాలు క్రింది విధంగా ఉన్నాయి:
- ఒకే మరియు మాత్రమే అవసరమైన పరామితి t * testing.టి
- టెస్టింగ్ ఫంక్షన్ టెస్ట్ అనే పదంతో ప్రారంభమవుతుంది మరియు తర్వాత పెద్ద అక్షరంతో ప్రారంభమయ్యే పదం లేదా పదబంధం ఉంటుంది.
- వైఫల్యాన్ని సూచించడానికి, పరీక్ష ఫంక్షన్ ఏదైనా కాల్ చేయాలి t.తప్పు లేదా t.ఫెయిల్, మరియు వైఫల్యం కలిగించకుండా అదనపు డీబగ్ సమాచారాన్ని అందించడానికి, t.Log ఉపయోగించవచ్చు.
- విఫలం కాని డీబగ్ సమాచారాన్ని అందించడానికి, t.Logని ఉపయోగించండి.
- పరీక్షలు పేరుతో ఫైల్‌లలో నిల్వ చేయబడతాయి foo_test.go , ఉదాహరణకి, math_test.go .
ఫైల్‌ను సేవ్ చేసిన తర్వాత దాన్ని మూసివేయండి.
ప్యాకేజీ ప్రధానదిగుమతి (
'పరీక్ష'
)
funcTestAdd ( t * పరీక్ష. టి ) {
ఫలితం := జోడించు ( 2 , 3 )
ఉంటే ఫలితం != 5 {
t. లోపం ( 'జోడించు(2, 3) = %d; 5 కావాలి' , ఫలితం )
}
}
ది జోడించు() ద్వారా ఫంక్షన్ పరీక్షించబడుతుంది టెస్ట్ యాడ్() ఫంక్షన్, ఇది ఈ పరీక్షలో నిర్వచించబడింది. ఇది యాడ్‌కి కాల్ చేయడానికి 2 మరియు 3 నంబర్‌లను ఉపయోగిస్తుంది, ఆపై ఫలితం 5 అని నిర్ధారిస్తుంది. ఫలితం 5 కంటే తక్కువగా ఉంటే ఎర్రర్ మెసేజ్ ప్రింట్ చేయబడుతుంది t.Errorf() ఆవాహన చేస్తారు.
చివరగా, గో అనే అంతర్నిర్మిత పరీక్ష సాధనం ఉందని తెలుసుకోవడం ముఖ్యం పరీక్షకు వెళ్ళు. ఈ సాధనం ప్రాజెక్ట్‌లోని అన్ని పరీక్షలను అమలు చేస్తుంది మరియు ఫలితాల నివేదికను అందిస్తుంది. పరీక్షకు వెళ్లు పరీక్షలను ప్రారంభించడానికి ప్రాజెక్ట్ డైరెక్టరీలో ఉన్నప్పుడు తప్పనిసరిగా టెర్మినల్‌లో టైప్ చేయాలి. ఆ డైరెక్టరీలోని అన్ని పరీక్షలు ఫలితంగా నడుస్తాయి.
< బలమైన > పరీక్షకు వెళ్ళు < పరీక్ష - ఫైల్ - పేరు > _పరీక్ష. వెళ్ళండి బలమైన > 
యూనిట్ పరీక్ష ఫలితాలు
అవుట్‌పుట్ మీకు పాస్ అయిన, విఫలమైన లేదా దాటవేయబడిన పరీక్ష ఫంక్షన్‌లను చూపుతుంది.
పాస్ లేదా సరే కోడ్ ఉద్దేశించిన విధంగా పనిచేస్తుందని సూచిస్తుంది. మీరు అందుకుంటారు ఫెయిల్ ఒక పరీక్ష విఫలమైతే.
ది _test.go గో టెస్ట్ సబ్‌కమాండ్ ఫైల్‌లలో తనిఖీ చేసే ప్రత్యయం మాత్రమే. ఆ తర్వాత, ఫంక్ వంటి ఏదైనా ప్రత్యేక ఫంక్షన్‌ల కోసం గో టెస్ట్ ఆ ఫైల్(ల)ని శోధిస్తుంది టెస్ట్Xxx మరియు అనేక ఇతర. Go test ఈ ఫంక్షన్‌లను సరిగ్గా బిల్డ్ చేస్తుంది మరియు కాల్ చేస్తుంది, వాటిని అమలు చేస్తుంది, సేకరిస్తుంది మరియు ఫలితాలను రిపోర్ట్ చేస్తుంది మరియు చివరకు తాత్కాలిక ప్రధాన ప్యాకేజీలో ప్రతిదీ శుభ్రపరుస్తుంది.
మీ డెవలప్‌మెంట్ వర్క్‌ఫ్లో మీ పరీక్షలను ఏకీకృతం చేయడం చివరి దశ. మీరు మీ కోడ్‌ను రిపోజిటరీకి అప్పగించిన ప్రతిసారీ మీ పరీక్షలను అమలు చేయడం ఉత్తమ అభ్యాసం. మీ డెవలప్‌మెంట్ వర్క్‌ఫ్లోలో మీ టెస్ట్‌ల ఏకీకరణ మీ కోడ్ నిరంతరం పరీక్షించబడుతుందని నిర్ధారిస్తుంది మరియు ఏవైనా సమస్యలు అమలు చేయడానికి ముందే పరిష్కరించబడతాయి.
ముగింపు
రాయడం యూనిట్ పరీక్షలు సాఫ్ట్‌వేర్ డెవలప్‌మెంట్‌లో కీలకమైన భాగం ఎందుకంటే ఇది మీ కోడ్ స్కేలబుల్, ఫంక్షనల్ మరియు ప్రభావవంతమైనదని హామీ ఇస్తుంది. గో టెస్టింగ్ లైబ్రరీ అప్రయత్నంగా మరియు ఉపయోగించడానికి సులభమైనది. మీరు గోలాంగ్‌ని సృష్టించగలగాలి యూనిట్ పరీక్షలు పైన పేర్కొన్న విధానాలను అనుసరించడం ద్వారా అత్యధిక నాణ్యతతో. మీ కోడ్ నిరంతరం పరీక్షించబడుతుందని మరియు అమలు చేయడానికి ముందు ఏవైనా సమస్యలు పరిష్కరించబడతాయని నిర్ధారించుకోవడానికి మీ పరీక్షలను మీ డెవలప్‌మెంట్ వర్క్‌ఫ్లోలో ఏకీకృతం చేయాలని గుర్తుంచుకోండి.