யூனிட் உடன் ஜாவாவில் யூனிட் டெஸ்டிங்

ஜாவாவில் அலகு சோதனை என்றால் என்ன?

ஜாவாவில் ஜூனிட் கற்றுக்கொள்வதற்கு முன், யூனிட் டெஸ்டிங் என்றால் என்ன, அது ஏன் மிகவும் பிரபலமானது என்பதை சுருக்கமாகப் பார்ப்போம் (இது உங்களுக்கு ஏற்கனவே தெரிந்திருந்தால், 'ஜாவாவில் ஜூனிட் டெஸ்ட் எழுதுவது எப்படி?' என்பதற்குச் செல்லவும்). ஜாவாவில் யூனிட் சோதனையானது பெரிய அளவிலான மென்பொருள் மேம்பாட்டை மிகவும் திறமையாகவும் சிரமமின்றியும் செய்கிறது. இது தனிநபர்கள் மற்றும் குழுக்கள் இருவருக்கும் உதவும்.

https://junit.org/junit4/

யூனிட் டெஸ்டிங்கின் இன்றியமையாத யோசனை இதுதான்: தனிப்பட்ட அம்சங்களின் அணு சோதனைகளை எழுதவும் (அலகு சோதனைகள் என அழைக்கப்படும்) மற்றும் சோதனைக்குப் பிறகு மெதுவாக மேலும் அம்சங்களைச் சேர்க்கவும் மற்றும் முந்தையவை வேலை செய்வதை உறுதி செய்யவும். இது மிகவும் எளிமையான ஆனால் சக்திவாய்ந்த யோசனை. இந்த செயல்முறை எப்படி இருக்கும் என்பதற்கு உதாரணமாக, நீங்கள் ஒரு மெய்நிகர் அறிவியல் கால்குலேட்டரை உருவாக்குகிறீர்கள் என்று கற்பனை செய்து பாருங்கள். வெளிப்படையான எண்கணித ஆபரேட்டர்களின் மேல் ( +, -, x, %), இந்த கால்குலேட்டரில் மேம்பட்ட அம்சங்களைக் கொண்டிருக்கும், அதற்குள் மற்ற துணை அம்சங்கள் வேலை செய்ய வேண்டும். அடுக்குகளைக் கணக்கிட, உங்கள் கால்குலேட்டரை சரியாகப் பெருக்க வேண்டும். எனவே இந்த கால்குலேட்டரை உருவாக்குவதற்கும் சோதனை செய்வதற்கும் ஒரு யூனிட் சோதனை அணுகுமுறை:

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

இது மற்ற சிறிய துணை அம்சங்களை உருவாக்கும் அம்சங்கள் அவற்றின் சொந்த உரிமையில் சரியாக வேலை செய்வது மட்டுமல்லாமல், அதில் தவறான துணை அம்சங்களைக் கொண்டிருக்கவில்லை என்பதை உறுதி செய்கிறது. எடுத்துக்காட்டாக, நான் அடுக்குச் செயல்பாட்டைச் சோதித்துக்கொண்டிருந்தால், ஏதேனும் தவறு நடந்தால், பெருக்கல் செயல்பாடு ஏற்கனவே விரிவாகச் சோதிக்கப்பட்டிருப்பதால், அந்தப் பிழை அநேகமாக பெருக்கல் துணை அம்சத்தில் இல்லை என்று எனக்குத் தெரியும். பிழையைக் கண்டறிய நான் பின்னோக்கிச் சென்று ஆய்வு செய்ய வேண்டிய குறியீட்டின் மொத்த அளவை இது பெருமளவில் நீக்குகிறது. யூனிட் டெஸ்டிங்கைச் சுற்றியுள்ள சிந்தனை செயல்முறை எவ்வாறு கட்டமைக்கப்பட்டுள்ளது என்பதை இந்த அற்பமான எடுத்துக்காட்டு தெளிவாக்குகிறது என்று நம்புகிறோம். ஆனால் மீதமுள்ள மென்பொருள் மேம்பாட்டு செயல்முறையுடன் யூனிட் சோதனை எவ்வாறு தொடர்பு கொள்கிறது? நீங்கள் இன்னும் சிக்கலான அம்சங்களைக் கொண்டிருந்தால் என்ன செய்வது, ஒன்றாகச் செயல்படவும் தொடர்பு கொள்ளவும் முடியும்? இத்தகைய சிக்கலான அம்சங்கள் ஒன்றாகச் சரியாகச் செயல்படுவதை உறுதிசெய்ய அலகு சோதனை போதுமானதாக இல்லை. உண்மையில், இது மென்பொருள் சோதனையின் நான்கு நிலைகளின் முதல் படியாகும் (நான் பெரிய எழுத்துக்களைப் பயன்படுத்துகிறேன், ஏனெனில் நான் தொழில்துறை தரநிலை அல்லது மென்பொருளைச் சோதிப்பதற்கான மிகவும் பொதுவான அணுகுமுறையைக் குறிப்பிடுகிறேன்). கடைசி மூன்று படிகள்ஒருங்கிணைப்பு சோதனை , கணினி சோதனை மற்றும் ஏற்றுக்கொள்ளும் சோதனை. இவை அனைத்தும் ஒருவேளை நீங்கள் என்ன நினைக்கிறீர்களோ அதையே குறிக்கும், ஆனால் நான் தெளிவுபடுத்துகிறேன்: ஒருங்கிணைப்பு சோதனை என்பது மேலே குறிப்பிட்டுள்ள "சிக்கலான அம்சங்கள்" ஒன்றை ஒன்றுடன் ஒன்று சரியாக தொடர்புகொள்வதை உறுதிப்படுத்த நாங்கள் என்ன செய்வோம். (எ.கா., கால்குலேட்டர் “3 + 7 * 4 - 2” ஐக் கையாளும் என்பதை உறுதிசெய்தல்) கணினி சோதனை என்பது ஒரு குறிப்பிட்ட அமைப்பின் ஒட்டுமொத்த வடிவமைப்பைச் சோதிக்கிறது; ஒரு தயாரிப்பில் சிக்கலான அம்சங்களின் பல அமைப்புகள் பெரும்பாலும் ஒன்றாக வேலை செய்கின்றன, எனவே நீங்கள் இவற்றை அமைப்புகளாக தொகுத்து தனித்தனியாக சோதிக்கவும். (எ.கா. நீங்கள் ஒரு கிராஃபிங் கால்குலேட்டரை உருவாக்கினால், முதலில் எண்களைக் கையாள்வதற்காக எண்கணித 'அமைப்பு' உருவாக்க வேண்டும், அது விரும்பியபடி செயல்படும் வரை சோதனை செய்து, பின்னர் திரும்பப் பெறுவதைச் சமாளிக்க கிராஃபிங் 'சிஸ்டத்தை' உருவாக்கி சோதிக்க வேண்டும். இது எண்கணித முறையிலிருந்து கட்டமைக்கப்படும்). ஏற்றுக்கொள்ளும் சோதனை என்பது பயனர் நிலை சோதனை; பயனர்களால் ஏற்றுக்கொள்ளப்படும் முடிக்கப்பட்ட தயாரிப்பை உருவாக்க அனைத்து அமைப்புகளும் ஒத்திசைவில் செயல்பட முடியுமா என்று பார்க்கிறது (எ.கா., பயனர்கள் கால்குலேட்டரைச் சோதிக்கிறார்கள்). மென்பொருள் உருவாக்குநர்கள் சில சமயங்களில் இந்த செயல்முறையின் இறுதிப் படியை புறக்கணிக்கலாம், ஏனெனில் நிறுவனங்கள் பெரும்பாலும் மற்ற பணியாளர்கள் பயனர் (பீட்டா) சோதனைகளை தனித்தனியாக பயன்படுத்துவார்கள்.

ஜாவாவில் ஜூனிட் தேர்வை எழுதுவது எப்படி?

யூனிட் டெஸ்டிங்கின் நன்மைகள் மற்றும் வரம்புகள் பற்றிய தெளிவான யோசனை உங்களுக்கு இப்போது உள்ளது, சில குறியீட்டைப் பார்ப்போம்! JUnit எனப்படும் பிரபலமான Java சோதனை கட்டமைப்பை நாங்கள் பயன்படுத்துவோம் (மற்றொரு பிரபலமானது 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 அறியும். பின்னர், இந்த தலைப்பைப் பயன்படுத்தி குறிப்பிட்ட யூனிட் சோதனைகளை எவ்வாறு இயக்கலாம் என்பதை நான் உங்களுக்குக் காண்பிப்பேன். இரண்டாவது இறக்குமதி அறிக்கை நம்மை தட்டச்சு செய்வதில் சிறிது சேமிக்கிறது. எங்கள் செயல்பாடுகளைச் சோதிக்க நாம் பயன்படுத்தும் முதன்மையான ஜூனிட் செயல்பாடு 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]செயல்பாட்டின் எதிர்பார்க்கப்படும் வருவாய் மதிப்பு. சோதனைச் செயல்பாடுகள் எப்பொழுதும் ' ' திரும்பும் வகையைக் கொண்டிருக்கும், voidஏனெனில் முழுச் செயல்பாட்டின் முக்கிய அம்சம் இயங்குவதாகும்assertEquals, இது உங்கள் சோதனையில் தேர்ச்சி பெற்றாலும் இல்லாவிட்டாலும் கன்சோலுக்கு வெளியிடும்; வேறு எந்த தரவையும் எங்கும் திருப்பித் தர வேண்டியதில்லை. finalவரி 7: திரும்பும் வகையின் ' ' மாறியை நாங்கள் அறிவித்து Math.add (int), அதற்கு மரபுப்படி 'எதிர்பார்க்கப்பட்டது' என்று பெயரிடுவோம். அதன் மதிப்பு நாம் எதிர்பார்க்கும் பதில் (4). finalவரி 8: திரும்பும் வகையின் ' ' மாறியை நாங்கள் அறிவித்து 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()

ஜூனிட் நேர்காணல் கேள்விகள் (கூடுதல் தகவல்)

மிகவும் பிரபலமான ஜூனிட் நேர்காணல் கேள்விகளை இங்கே சேகரித்துள்ளேன். நீங்கள் சேர்க்க ஏதாவது இருந்தால் - கீழே உள்ள கருத்துகளில் இதைச் செய்யலாம். கே: தேர்வில் தானாக தோல்வியடைய உங்கள் சோதனை முறையில் எந்த முறையை அழைக்கலாம்? ப: தோல்வி ("பிழை விளக்கம் இங்கே!"); கே: நீங்கள் ஒரு நாய் வகுப்பைச் சோதிக்கிறீர்கள்; ஒரு நாய் பொருளைச் சோதிக்க, அதன் மீது சோதனைகளை நடத்துவதற்கு முன், நீங்கள் அதைத் துரிதப்படுத்த வேண்டும். எனவே நாயை உடனுக்குடன் உருவாக்க ஒரு செட்அப்() செயல்பாட்டை எழுதுகிறீர்கள். சோதனையின் போது இந்தச் செயல்பாட்டை ஒருமுறை மட்டுமே இயக்க வேண்டும். செட்அப்() செயல்பாட்டு கையொப்பத்திற்கு மேலே நீங்கள் நேரடியாக என்ன வைக்க வேண்டும், எனவே சோதனைகளை இயக்கும் முன் ஜூனிட் செட்அப்()ஐ இயக்கத் தெரியும்? ப: @BeforeClass (@அனைவருக்கும் ஜூனிட் 5ல்) கே:மேலே விவரிக்கப்பட்டுள்ள setUp() செயல்பாட்டின் செயல்பாட்டு கையொப்பம் என்னவாக இருக்க வேண்டும்? ப: பொது நிலையான வெற்றிடம். @BeforeClass (@BeforeAll in JUnit 5) அல்லது @AfterClass (@AfterAll in JUnit) உடன் எந்தச் செயல்பாடும் நிலையானதாக இருக்க வேண்டும். கே: நீங்கள் நாய் வகுப்பைச் சோதித்து முடித்துவிட்டீர்கள். ஒவ்வொரு சோதனைக்குப் பிறகும் தரவைச் சுத்தப்படுத்தி தகவலை அச்சிட்டு கன்சோல் செய்யும் void tearDown() செயல்பாட்டை நீங்கள் எழுதுகிறீர்கள். ஒவ்வொரு சோதனைக்குப் பிறகும் இந்த செயல்பாடு இயங்க வேண்டும். TearDown() செயல்பாடு கையொப்பத்திற்கு மேலே நீங்கள் நேரடியாக என்ன வைக்க வேண்டும், எனவே ஒவ்வொரு சோதனையையும் நடத்திய பிறகு TearDown() ஐ இயக்குவது JUnitக்குத் தெரியும்? ப: @பிறகு (@AfterEach in June 5)