JUnitలో జనాదరణ పొందిన ఉల్లేఖనాలు

7.1 @Suite ఉల్లేఖన

మరియు మరికొన్ని తరచుగా ఉపయోగించే ఉల్లేఖనాలు. మీరు వాటిని ఉపయోగించకపోయినా, మీరు ఖచ్చితంగా వారితో పరీక్షలను చూస్తారు. అందువల్ల, అక్కడ వ్రాయబడిన వాటిని కనీసం సాధారణ పరంగా అర్థం చేసుకోవడం అవసరం.

పరీక్షలను సమూహాలుగా కలపవచ్చు. దీని కోసం ప్రత్యేక వ్యాఖ్యానం ఉంది @Suite. ఉదాహరణ:

@Suite
@SuiteDisplayName("JUnit Platform Suite Demo")
@SelectPackages("com.codegym.test")
@IncludeClassNamePatterns(".*Tests")
class SuiteDemo {
}

ఈ సందర్భంలో, @Suite ఉల్లేఖన ఇతర ఉల్లేఖనాలతో జత చేయబడింది.

• SuiteDisplayName- లాగ్‌లో పరీక్ష సమూహం పేరును సెట్ చేస్తుంది;
• SelectPackages- పరీక్ష తరగతుల కోసం ఎక్కడ చూడాలో ప్యాకేజీల జాబితాను సెట్ చేస్తుంది;
• IncludeClassNamePatterns- పరీక్ష తరగతి పేర్ల నమూనాను సెట్ చేస్తుంది.

ఎందుకు అలాంటి ఇబ్బందులు? ప్రాజెక్ట్ యొక్క అన్ని పరీక్షలు అమలు చేయబడతాయని బాగా ఊహించుకోండి, 50 గంటలు అనుకుందాం. మరియు ప్రతి కమిట్ తర్వాత వాటిని అమలు చేయడం చాలా ఖరీదైనది. అటువంటి సందర్భంలో, కొన్ని ప్రత్యేక పరీక్ష స్క్రిప్ట్‌లను సృష్టించడం మరియు పరీక్షను మరింత సరళమైన రీతిలో సెటప్ చేయడం ఉపయోగకరంగా ఉంటుంది.

7.2 @ఆర్డర్ ఉల్లేఖన

మరొక సాధారణ ఉల్లేఖనం @TestMethodOrder. పరీక్ష తరగతిలో పరీక్షా పద్ధతులను పిలిచే క్రమాన్ని పేర్కొనడానికి ఇది మిమ్మల్ని అనుమతిస్తుంది. పద్ధతి కాల్‌లు ఒకదానికొకటి ప్రభావితం అవుతాయని మీకు తెలిసినప్పుడు ఇది చాలా ఉపయోగకరంగా ఉంటుంది, కానీ ఒక నిర్దిష్ట క్రమంలో, ప్రతిదీ తప్పక పని చేయాలి. చాలా తరచుగా ఉపయోగిస్తారు.

మొదట, మీరు పిలవబడే పద్ధతులను అక్షర క్రమంలో సెట్ చేయవచ్చు :

@TestMethodOrder(MethodOrderer.MethodName.class)
public class AlphanumericOrderUnitTest {

}

రెండవది, ప్రతి పద్ధతి దాని ఆర్డినల్ సంఖ్యతో ప్రత్యేక ఉల్లేఖనాన్ని కలిగి ఉంటుంది.

@TestMethodOrder(OrderAnnotation.class)
public class OrderAnnotationUnitTest {

    @Test
    @Order(1)
    public void firstTest() {
    }

    @Test
    @Order(2)
    public void secondTest() {
    }
}

లేదా పరీక్షలను పిలిచే క్రమాన్ని పేర్కొనే ప్రత్యేక తరగతిని కూడా సృష్టించండి:

@TestMethodOrder(CustomOrder.class)
public class CustomOrderUnitTest {

}

//sort method names alphabetically, but ignoring case
public class CustomOrder implements MethodOrderer {
    public void orderMethods(MethodOrdererContext context) {
        context.getMethodDescriptors().sort(
        (MethodDescriptor m1, MethodDescriptor m2)->
           m1.getMethod().getName().compareToIgnoreCase(m2.getMethod().getName()));
    }
}

7.3 @DisplayName ఉల్లేఖన

చివరగా, ప్రతి పరీక్షకు ఒక పేరు ఇవ్వవచ్చు. పరీక్షలు చాలా ఉన్నాయి మరియు మీరు పరీక్షల ప్రత్యేక దృశ్యాలను (ఉపసమితులు) సృష్టించినట్లయితే ఇది సౌకర్యవంతంగా ఉంటుంది. దీని కోసం ప్రత్యేక వ్యాఖ్యానం ఉంది @DisplayName.

ఉదాహరణ:

@DisplayName("Friendly name for the test")
public class DisplayNameCustomTest {

    @Test
    @DisplayName("Input Validation")
    void inputData() {
    }

    @DisplayName("Checking critical situations")
    @Test
    void criticalCases() {
    }
}

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

@DisplayNameGeneration(DisplayNameGeneratorUnitTest.ReplaceCamelCase.class)
class DisplayNameGeneratorUnitTest {

    @Test
    void camelCaseName() {
    }

    static class ReplaceCamelCase extends DisplayNameGenerator.Standard {
        @Override
        public String generateDisplayNameForClass(Class testClass) {
            return super.generateDisplayNameForClass(testClass).toUpperCase();
        }
 }
}

ఇది ఎంత సులభమో చూడండి :)