ஜூனிட்டில் பிரபலமான சிறுகுறிப்புகள்

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();
        }
 }
}

இது எவ்வளவு எளிது என்று பாருங்கள் :)