అందువల్ల విస్తృతమైన కోడ్‌బేస్‌లతో వ్యవహరించేటప్పుడు నేర్చుకునే వక్రతను నివారించడానికి మీ అభివృద్ధి దశల్లో యూనిట్ పరీక్ష యొక్క ప్రాథమికాలను పొందడం చాలా అవసరం.
ఈ ట్యుటోరియల్‌లో, మేము C# మరియు MSTest టెస్టింగ్ లైబ్రరీని ఉపయోగించి యూనిట్ టెస్టింగ్ ఫ్రేమ్‌వర్క్‌లోకి మిమ్మల్ని పరిచయం చేస్తాము. యూనిట్ పరీక్షలను ఎలా సృష్టించాలి, వాటిని ఎలా అమలు చేయాలి మరియు పరీక్ష వైఫల్యం లేదా విజయం నుండి ఫలితాలను ఎలా అర్థం చేసుకోవాలో తెలుసుకోవడానికి మిమ్మల్ని అనుమతించే ప్రాథమిక అప్లికేషన్‌ను మేము రూపొందిస్తాము.
పర్యావరణాన్ని పరీక్షిస్తోంది
పరీక్ష పరిష్కారాన్ని మరియు మా ప్రాథమిక అప్లికేషన్‌ను ఎలా కాన్ఫిగర్ చేయాలో చర్చించడం ద్వారా ప్రారంభిద్దాం.
ఈ ట్యుటోరియల్‌లో అనువర్తనాన్ని అనుసరించడానికి మరియు పునరావృతం చేయడానికి, మీరు ఈ క్రింది వాటిని కలిగి ఉన్నారని నిర్ధారించుకోండి:
- విజువల్ స్టూడియో ఇన్‌స్టాల్ చేయబడింది
- మీ మెషీన్‌లో .NET మరియు C# టూల్స్ కాన్ఫిగర్ చేయబడింది
ఒక అప్లికేషన్ సృష్టించండి
తరువాత, విజువల్ స్టూడియోని తెరిచి, కొత్త పరిష్కారాన్ని సృష్టించండి. ఈ ట్యుటోరియల్ కోసం, మేము ప్రాథమిక కాలిక్యులేటర్ అప్లికేషన్‌ను రూపొందిస్తాము. మీరు కోరుకున్న ఏ పేరుతోనైనా దరఖాస్తును ఇవ్వవచ్చు.
తర్వాత, కొత్త ప్రాజెక్ట్‌ను సృష్టించి, ప్రాజెక్ట్ రకాన్ని MSTest టెస్ట్ ప్రాజెక్ట్‌గా ఎంచుకుని, దానికి ఏదైనా కావాల్సిన పేరును ఇవ్వండి.
'పరిష్కారానికి జోడించు'ని ఎంచుకుని, గతంలో సృష్టించిన యాప్‌ని ఎంచుకోండి.
సొల్యూషన్ ఎక్స్‌ప్లోరర్‌లో చూపిన విధంగా మీరు ప్రధాన అప్లికేషన్ మరియు యూనిట్ టెస్టింగ్ ప్రాజెక్ట్‌ను కలిగి ఉండాలి.
కాలిక్యులేటర్ అప్లికేషన్ కోసం కోడ్ వ్రాయండి
తదుపరి దశ మా కాలిక్యులేటర్ అప్లికేషన్ కోసం కోడ్‌ను వ్రాయడం. మేము దీన్ని CalcApp “program.cs” ఫైల్‌లో చేయవచ్చు.
మేము ప్రాథమిక కార్యాచరణ కోసం చూస్తున్నందున, మేము ఈ క్రింది విధంగా సోర్స్ కోడ్‌ని జోడించవచ్చు:
పబ్లిక్ క్లాస్ కాలిక్యులేటర్{
ప్రజా రెట్టింపు జోడించు ( రెట్టింపు a , రెట్టింపు బి )
{
తిరిగి a + బి ;
}
ప్రజా రెట్టింపు తీసివేయి ( రెట్టింపు a , రెట్టింపు బి )
{
తిరిగి a - బి ;
}
ప్రజా రెట్టింపు గుణించండి ( రెట్టింపు a , రెట్టింపు బి )
{
తిరిగి a * బి ;
}
ప్రజా రెట్టింపు విభజించు ( రెట్టింపు a , రెట్టింపు బి )
{
ఉంటే ( బి == 0 )
కొత్త DivideByZeroExceptionని విసిరేయండి ( ) ;
తిరిగి a / బి ;
}
}
మీరు ఊహించినట్లుగా, మునుపటి కోడ్ ప్రాథమిక అంకగణిత అనువర్తనాలను అమలు చేయగల కాలిక్యులేటర్ యాప్‌ను సృష్టిస్తుంది.
యూనిట్ పరీక్షలు రాయండి
మేము పూర్తి చేసిన తర్వాత, మేము 'కాలిక్యులేటర్' తరగతికి యూనిట్ పరీక్షలను వ్రాయవచ్చు. ఈ సందర్భంలో, మేము చేయాల్సిందల్లా ప్రాజెక్ట్ యొక్క “యూనిట్‌టెస్ట్” ఫైల్‌లో పరీక్షలను ఈ క్రింది విధంగా వ్రాయడం:
సిస్టమ్ ఉపయోగించి ;namespace CalcApp
{
పబ్లిక్ క్లాస్ కాలిక్యులేటర్
{
ప్రజా రెట్టింపు జోడించు ( రెట్టింపు a , రెట్టింపు బి )
{
తిరిగి a + బి ;
}
ప్రజా రెట్టింపు తీసివేయి ( రెట్టింపు a , రెట్టింపు బి )
{
తిరిగి a - బి ;
}
ప్రజా రెట్టింపు గుణించండి ( రెట్టింపు a , రెట్టింపు బి )
{
తిరిగి a * బి ;
}
ప్రజా రెట్టింపు విభజించు ( రెట్టింపు a , రెట్టింపు బి )
{
ఉంటే ( బి == 0 )
కొత్త DivideByZeroExceptionని విసిరేయండి ( ) ;
తిరిగి a / బి ;
}
}
}
నేమ్‌స్పేస్ కాల్‌టెస్ట్
{
[ టెస్ట్ క్లాస్ ]
పబ్లిక్ క్లాస్ కాలిక్యులేటర్ పరీక్షలు
{
ప్రైవేట్ కాలిక్యులేటర్ కాలిక్యులేటర్ ;
[ టెస్ట్ ప్రారంభించండి ]
ప్రజా శూన్యం సెటప్ ( )
{
కాలిక్యులేటర్ = కొత్త కాలిక్యులేటర్ ( ) ;
}
[ పరీక్షా విధానం ]
ప్రజా శూన్యం Add_TwoPositiveNumbers_ReturnsCorrectSum ( )
{
ఫలితంగా ఉంది = కాలిక్యులేటర్. జోడించు ( 5 , 5 ) ;
నొక్కిచెప్పండి. సమానం ( 10 , ఫలితం ) ;
}
[ పరీక్షా విధానం ]
ప్రజా శూన్యం Subtract_TwoPositiveNumbers_ReturnsCorrectDifference ( )
{
ఫలితంగా ఉంది = కాలిక్యులేటర్. తీసివేయి ( 10 , 5 ) ;
నొక్కిచెప్పండి. సమానం ( 5 , ఫలితం ) ;
}
[ పరీక్షా విధానం ]
ప్రజా శూన్యం Multiply_TwoPositiveNumbers_ReturnsCorrectProduct ( )
{
ఫలితంగా ఉంది = కాలిక్యులేటర్. గుణించండి ( 5 , 5 ) ;
నొక్కిచెప్పండి. సమానం ( 25 , ఫలితం ) ;
}
[ పరీక్షా విధానం ]
[ ఊహించిన మినహాయింపు ( రకం ( డివైడ్ బైజీరో మినహాయింపు ) ) ]
ప్రజా శూన్యం Divide_DenominatorIsZero_ThrowsDivideByZeroException ( )
{
ఫలితంగా ఉంది = కాలిక్యులేటర్. విభజించు ( 5 , 0 ) ;
}
[ పరీక్షా విధానం ]
ప్రజా శూన్యం భాగహారం_రెండు సానుకూల సంఖ్యలు_రిటర్న్‌లు సరైన గుణకం ( )
{
ఫలితంగా ఉంది = కాలిక్యులేటర్. విభజించు ( 10 , 5 ) ;
నొక్కిచెప్పండి. సమానం ( 2 , ఫలితం ) ;
}
}
}
ముగింపు
ఇది MSTest ఫ్రేమ్‌వర్క్‌ని ఉపయోగించి C#లో యూనిట్ టెస్టింగ్ యొక్క ప్రాథమిక అంశాలను కవర్ చేసే ప్రాథమిక ట్యుటోరియల్.