ஜூனிட் வலியுறுத்தல்கள்

6.1 வலியுறுத்துகிறது

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

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

ஒப்பிடும் வரிசை இங்கே முக்கியமானது , ஏனென்றால் இறுதி அறிக்கையில் ஜூனிட் "மதிப்பு 1 பெறப்பட்டது, ஆனால் 3 எதிர்பார்க்கப்பட்டது" போன்ற ஒன்றை எழுதும். அத்தகைய காசோலைக்கான பொதுவான வடிவம்:

assertEquals(standard , meaning)

உதாரணமாக:

@Test
public void whenAssertingEquality () {
    String expected = "3.1415";
    String actual = "3";

    assertEquals(expected, actual);
}

6.2 முறைகள் சமமானவை, உறுதியானவை, பொய்யானவை

கீழே நான் மிகவும் பிரபலமான முறைகளை பட்டியலிடுவேன் - வலியுறுத்தல்கள். அவர்களின் பெயர்களால் அவர்கள் எவ்வாறு செயல்படுகிறார்கள் என்பதை யூகிக்க முடியும். ஆனால் நான் எப்படியும் ஒரு சிறிய விளக்கத்தை எழுதுகிறேன்:

இந்த முறைகளில் சில தேவையற்றதாகத் தெரிகிறது. நீங்கள் assertTrue(a == b) என்று எழுதும் போது assertSame(a, b) ஐ ஏன் பயன்படுத்த வேண்டும் ?

வலியுறுத்தல் என்பது மிகவும் புத்திசாலித்தனமான முறை. பதிவில் பிழைத் தகவலை எழுதுவது உட்பட பல பயனுள்ள விஷயங்களை இது செய்கிறது . முதல் வழக்கில், பொருள் A எதிர்பார்க்கப்பட்டது என்று எழுதும், ஆனால் பொருள் B பெறப்பட்டது, இரண்டாவது வழக்கில், உண்மை எதிர்பார்க்கப்பட்டது என்று எழுதும் .

உங்களிடம் நூற்றுக்கணக்கான சோதனைகள் இருக்கும் போது, ​​குறிப்பாக ஒரு பிரத்யேக சோதனை சர்வரில் இயங்கும் சோதனைகள், விரிவான பதிவுகள் மிகவும் உதவியாக இருக்கும். நான் என்ன சொல்கிறேன் என்று உங்களுக்குப் புரிந்திருக்கும் என்று நினைக்கிறேன்.

வரிசை ஒப்பீடு உதாரணம்:

@Test
public void whenAssertingArraysEquality() {
    char[] expected = {'J','u','n','i','t'};
    char[] actual = "Junit".toCharArray();

    assertArrayEquals(expected, actual);
}

6.3 அனைத்து முறையையும் வலியுறுத்துகிறது

மேலே குறிப்பிட்டுள்ளபடி, உறுதிப்படுத்தல் முறை ஒரு காசோலையை மட்டும் செய்கிறது, ஆனால் பதிவுடன் ஒப்பிடக்கூடிய பொருள்களைப் பற்றிய நிறைய தகவல்களையும் எழுதுகிறது.

ஒரு ஒப்பீடு செய்வோம்:

Address address = unitUnderTest.methodUnderTest();
assertEquals("Washington", address.getCity());
assertEquals("Oracle Parkway", address.getStreet());
assertEquals("500", address.getNumber());

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

இதற்கு ஒரு சிறப்பு முறை உள்ளது - assertAll() . முதல் வாதமாக, பதிவில் ஒரு கருத்தை எழுத வேண்டும், அதன் பிறகு எத்தனை உறுதிப்படுத்தும் செயல்பாடுகள் தேவை.

எங்கள் உதாரணம் எப்படி மீண்டும் எழுதப்படும் என்பதை இங்கே காணலாம்:

Address address = unitUnderTest.methodUnderTest();
assertAll("Complex address comparison script",
    () -> assertEquals("Washington", address.getCity()),
    () -> assertEquals("Oracle Parkway", address.getStreet()),
    () -> assertEquals("500", address.getNumber())
);

முகவரி தவறாக இருந்தால், இது போன்ற ஒன்று பதிவில் எழுதப்படும்:

	Complex scenario comparison address (3 failures)
	expected: <Washington> but was: <Seattle>
    expected: <Oracle Parkway> but was: <Main Street>
    expected: <500> but was: <5772>

6.4 உறுதியான காலக்கெடு முறை

@Timeout சிறுகுறிப்பு நினைவிருக்கிறதா ? இது முழு முறையின் செயல்பாட்டு நேரத்தையும் கட்டுப்படுத்த அனுமதித்தது. ஆனால் சில நேரங்களில் குறியீட்டின் சில பகுதியை முறைக்குள் செயல்படுத்துவதில் கட்டுப்பாடுகளை அமைப்பது பயனுள்ளதாக இருக்கும். இதற்கு நீங்கள் assertTimeout() ஐப் பயன்படுத்தலாம் .

நேரம் முதல் அளவுருவாக அனுப்பப்படுகிறது, மேலும் குறிப்பிட்ட நேரத்திற்குள் செயல்படுத்தப்பட வேண்டிய குறியீடு (செயல்பாடு) இரண்டாவதாக அனுப்பப்படுகிறது. உதாரணமாக:

@Test
public void whenAssertingTimeout() {
    assertTimeout(
  	ofSeconds(2),
  	() -> {
    	// pause for one second
    	Thread.sleep(1000);
  	}
	);
}

Assert class ஆனது assertTimeout() முறையின் 12 வகைகளைக் கொண்டுள்ளது . நீங்கள் அவர்களைப் பற்றி மேலும் அறிய விரும்பினால், அதிகாரப்பூர்வ ஆவணங்களுக்கு வரவேற்கிறோம் .

6.5 assertThrows முறை

ஒரு குறிப்பிட்ட சூழ்நிலையில் குறியீடு சரியான விதிவிலக்கை வீசுகிறது என்பதை நீங்கள் உறுதிப்படுத்த வேண்டிய சூழ்நிலைகள் பெரும்பாலும் உள்ளன: இது ஒரு பிழையைக் கண்டறிந்து சரியான விதிவிலக்கை வீசுகிறது. இது மிகவும் பொதுவான நிலை.

இந்த வழக்கில், மற்றொரு பயனுள்ள உறுதியான முறை உள்ளது - இது assertThrows() . அதன் அழைப்பின் பொதுவான வடிவம்:

assertThrows(exception , code)

அடிப்படையில், இது assertTimeout() முறைக்கு மிகவும் ஒத்திருக்கிறது , குறிப்பிட்ட குறியீடு சரியான விதிவிலக்கைத் தருகிறதா என்பதை மட்டுமே இது சரிபார்க்கிறது. உதாரணமாக:

@Test
void whenAssertingException() {
    Throwable exception = assertThrows(
  	IllegalArgumentException.class,
  	() -> {
      	throw new IllegalArgumentException("Exception message");
  	}
    );
    assertEquals("Exception message", exception.getMessage());
}