జూనిట్‌తో మొదటి పరీక్షలు

JUnit ఫ్రేమ్‌వర్క్‌ను కనెక్ట్ చేస్తోంది

జావా కోడ్‌ని పరీక్షించడం కోసం, మేము JUnit అనే గొప్ప ఫ్రేమ్‌వర్క్‌ని కలిగి ఉన్నాము . ఇది గొప్పగా పనిచేస్తుంది, ఇది నిరంతరం నవీకరించబడుతుంది, ఇది చాలా ప్రజాదరణ పొందింది మరియు Intellij IDEA దానితో చాలా కఠినంగా విలీనం చేయబడింది.

ఇప్పుడు ప్రతి ఒక్కరూ ఈ ఫ్రేమ్‌వర్క్ యొక్క ఐదవ సంస్కరణను ఉపయోగిస్తున్నారు - JUnit 5 , అయితే అనేక ప్రాజెక్ట్‌లలో మీరు ఇప్పటికీ దాని నాల్గవ సంస్కరణను కనుగొనవచ్చు. అవి చాలా భిన్నమైనవి కావు, అయితే మేము తాజాదాన్ని ఏమైనప్పటికీ పరిశీలిస్తాము. మీరు చురుకుగా పరీక్షలు రాయడం ప్రారంభించే సమయానికి, మీరు నా ఎంపికను ఆమోదిస్తారని నేను భావిస్తున్నాను.

కాబట్టి, ప్రాజెక్ట్‌కి JUnitని ఎలా జోడించాలి? మావెన్ నేర్చుకున్న తర్వాత ఇది సులభం అవుతుంది: ఈ కోడ్‌ని మీ pom.xmlకి జోడించండి:

<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter-engine</artifactId>
	<version>5.8.1</version>
	<scope>test</scope>
</dependency>

మార్గం ద్వారా, మీరు మావెన్ మీ పరీక్షలను బిల్డ్ దశలో ( పరీక్ష దశ ) అమలు చేయాలనుకుంటే, మీరు pom.xmlకి మరో భాగాన్ని జోడించాలి:

<plugin>
    <artifactId>maven-surefire-plugin</artifactId>
	<version>2.19.1</version>
	<dependencies>
    	<dependency>
            <groupId>org.junit.platform</groupId>
            <artifactId>junit-platform-surefire-provider</artifactId>
            <version>1.3.2</version>
    	</dependency>
	</dependencies>
</plugin>

@పరీక్ష ఉల్లేఖన

మీరు పరీక్షించాలనుకునే తరగతి మీకు ఉందని చెప్పండి. దీన్ని చేయడానికి ఉత్తమ మార్గం ఏమిటి? కొన్ని ఉదాహరణలతో ప్రారంభిద్దాం, ఎందుకంటే వియుక్త తరగతిని పరీక్షించడం కష్టం :)

మనం 4 ప్రాథమిక కార్యకలాపాలను నిర్వహించగల కాలిక్యులేటర్ తరగతిని కలిగి ఉన్నామని అనుకుందాం: కూడిక, తీసివేత, గుణకారం మరియు భాగహారం. దానిని వ్రాస్దాము:

class Calculator {
    	public int add(int a, int b) {
        	return a+b;
    	}

    	public int sub(int a, int b) {
        	return a-b;
    	}

    	public int mul (int a, int b) {
        	return a*b;
    	}

    	public int div(int a, int b) {
        	return a/b;
    	}
}

మేము ఈ తరగతి పద్ధతులను పరీక్షించాలనుకుంటున్నాము. మీకు ఎప్పటికీ తెలియదు, భవిష్యత్తులో వారు ఏదో మార్చుకుంటారు మరియు ప్రతిదీ పని చేయడం ఆగిపోతుంది. దానికి పరీక్షలు ఎలా రాయగలం?

మేము మరొక తరగతిని సృష్టించాలి. దీన్ని చేయడానికి, వారు సాధారణంగా అదే పేరును తీసుకుంటారు మరియు టెస్ట్ ప్రత్యయాన్ని జోడిస్తారు . ప్రతి పద్ధతికి, మీరు తప్పనిసరిగా కనీసం ఒక పరీక్ష పద్ధతిని జోడించాలి. ఉదాహరణ:

class CalculatorTest {
   	@Test
    	public void add() {
    	}
   	@Test
    	public void sub() {
        }
   	@Test
    	public void mul() {
    	}
   	@Test
    	public void div() {
    	}
}

పద్ధతి పేరు పరీక్ష అనే పదంతో ప్రారంభం కావాలనే నిబంధన ఉండేది , కానీ ఇది ఇకపై అవసరం లేదు.

జూనిట్ పరీక్ష ఉదాహరణలు

మన కాలిక్యులేటర్ టెస్ట్ క్లాస్ యొక్క పద్ధతులను పరీక్షించే కొన్ని ఉదాహరణలను వ్రాద్దాం :

class CalculatorTest {
   	@Test
    	public void add() {
        	Calculator calc = new Calculator();
        	int result = calc.add(2, 3);
        	assertEquals(5, result);
    	}

   	@Test
    	public void sub() {
        	Calculator calc = new Calculator();
        	int result = calc.sub(10, 10);
        	assertEquals(0, result);
        }

   	@Test
    	public void mul() {
        	Calculator calc = new Calculator();
        	int result = calc.mul(-5, -3);
        	assertEquals(15, result);
    	}

   	@Test
    	public void div() {
        	Calculator calc = new Calculator();
        	int result = calc.div(2, 3);
        	assertEquals(0, result);
    	}
}

సాధారణ జూనిట్ పరీక్ష ఇలా ఉంటుంది. ఆసక్తికరమైన నుండి: ప్రత్యేక పద్ధతి assertEquals() ఇక్కడ ఉపయోగించబడింది : ఇది దాని పేరులో సమానం అనే పదం ద్వారా సూచించబడిన విధంగా దానికి పంపబడిన పారామితులను పోల్చింది.

assertEquals() కి పాస్ చేసిన పారామితులు సమానంగా లేకుంటే, పద్ధతి మినహాయింపును ఇస్తుంది మరియు పరీక్ష విఫలమవుతుంది. ఈ మినహాయింపు ఇతర పరీక్షలను అమలు చేయకుండా నిరోధించదు.