ஜூனிட் உடனான முதல் சோதனைகள்

ஜூனிட் கட்டமைப்பை இணைக்கிறது

ஜாவா குறியீட்டைச் சோதிப்பதற்காக, எங்களிடம் ஜூனிட் எனப்படும் சிறந்த கட்டமைப்பு உள்ளது . இது சிறப்பாக செயல்படுகிறது, இது தொடர்ந்து புதுப்பிக்கப்படுகிறது, இது மிகவும் பிரபலமானது மற்றும் நிச்சயமாக Intellij IDEA அதனுடன் மிகவும் இறுக்கமாக ஒருங்கிணைக்கப்பட்டுள்ளது.

இப்போது எல்லோரும் இந்த கட்டமைப்பின் ஐந்தாவது பதிப்பைப் பயன்படுத்துகின்றனர் - ஜூனிட் 5 , இருப்பினும் பல திட்டங்களில் நீங்கள் அதன் நான்காவது பதிப்பைக் காணலாம். அவை மிகவும் வேறுபட்டவை அல்ல, ஆனால் எப்படியிருந்தாலும் சமீபத்தியதைப் பார்ப்போம். நீங்கள் சுறுசுறுப்பாக தேர்வுகளை எழுதத் தொடங்கும் நேரத்தில், எனது விருப்பத்தை நீங்கள் அங்கீகரிப்பீர்கள் என்று நினைக்கிறேன்.

எனவே, திட்டத்தில் ஜூனிட்டை எவ்வாறு சேர்ப்பது? Maven கற்றுக்கொண்ட பிறகு அது எளிதாக இருக்கும்: இந்தக் குறியீட்டை உங்கள் 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() க்கு அனுப்பப்பட்ட அளவுருக்கள் சமமாக இல்லாவிட்டால், முறை விதிவிலக்கு அளிக்கும் மற்றும் சோதனை தோல்வியடையும். இந்த விதிவிலக்கு மற்ற சோதனைகள் இயங்குவதைத் தடுக்காது.