జూనిట్ వాదనలు

6.1 నిర్ధారిస్తుంది

అసర్ట్‌లు అనేవి కోడ్‌లోని వివిధ ప్రదేశాలలో చొప్పించబడే ప్రత్యేక తనిఖీలు . ఏదో తప్పు జరిగిందని నిర్ధారించడం వారి పని. లేదా కాకుండా, ప్రతిదీ తప్పక జరుగుతుందో లేదో తనిఖీ చేయండి. ఇది "అవసరం" మరియు వారు దీన్ని వివిధ మార్గాల్లో సెట్ చేయడానికి మిమ్మల్ని అనుమతిస్తారు.

ఎగువ కోడ్‌లో మీరు ఇప్పటికే కొన్ని వాదనలను ఎదుర్కొన్నారు. మొదటిది సమానత్వం కోసం వస్తువులను తనిఖీ చేయడం. వస్తువులు సమానంగా లేకుంటే, మినహాయింపు విసిరివేయబడుతుంది మరియు పరీక్ష విఫలమవుతుంది.

పోలిక యొక్క క్రమం ఇక్కడ ముఖ్యమైనది , ఎందుకంటే తుది నివేదికలో JUnit "విలువ 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);
  	}
	);
}

అసర్ట్ క్లాస్‌లో 12 వేరియంట్‌లు ఉన్నాయి . మీరు వాటి గురించి మరింత తెలుసుకోవాలనుకుంటే, అధికారిక డాక్యుమెంటేషన్‌కు స్వాగతం .

6.5 ధృవీకరణ త్రో పద్ధతి

ఒక నిర్దిష్ట పరిస్థితిలో కోడ్ సరైన మినహాయింపును విసిరివేస్తుందని మీరు నిర్ధారించుకోవాల్సిన సందర్భాలు చాలా తరచుగా ఉన్నాయి: ఇది లోపాన్ని గుర్తించి సరైన మినహాయింపును విసురుతుంది. ఇది చాలా సాధారణ పరిస్థితి.

ఈ సందర్భంలో, మరొక ఉపయోగకరమైన నిరూపణ పద్ధతి ఉంది - ఇది assertThrows() . దాని కాల్ యొక్క సాధారణ ఆకృతి:

assertThrows(exception , code)

ప్రాథమికంగా, ఇది assertTimeout() పద్ధతికి చాలా సారూప్యంగా ఉంటుంది , పేర్కొన్న కోడ్ సరైన మినహాయింపును ఇస్తుందో లేదో తనిఖీ చేస్తుంది. ఉదాహరణ:

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