JUnit 5: एक अपवाद को कैसे जोर दिया जाए?

Question

क्या यह दावा करने का एक बेहतर तरीका है कि एक विधि JUnit 5 में एक अपवाद फेंकता है?

वर्तमान में, मुझे यह सत्यापित करने के लिए एक @ नियम का उपयोग करना होगा कि मेरा परीक्षण एक अपवाद फेंकता है, लेकिन यह उन मामलों के लिए काम नहीं करता है जहां मुझे अपने परीक्षण में अपवादों को फेंकने के लिए कई तरीकों की उम्मीद है।

Comments

आप को देखने के लिए AssertJ की जाँच करने में रुचि हो सकती है, यह JUnit5 की तुलना में अधिक लचीला है

— user1075613

Answer 1

आप उपयोग कर सकते हैं assertThrows(), जो आपको एक ही परीक्षण के भीतर कई अपवादों का परीक्षण करने की अनुमति देता है। Java 8 में लैम्ब्डा के समर्थन के साथ, यह JUnit में अपवादों के परीक्षण के लिए विहित तरीका है।

प्रति JUnit डॉक्स :

import static org.junit.jupiter.api.Assertions.assertThrows;

@Test
void exceptionTesting() {
    MyException thrown = assertThrows(
           MyException.class,
           () -> myObject.doThing(),
           "Expected doThing() to throw, but it didn't"
    );

    assertTrue(thrown.getMessage().contains("Stuff"));
}

Comments

एक पुराने स्कूल से "मुझे जून 5 के बारे में बहुत कुछ पता नहीं है और शायद जावा 8 के बारे में पर्याप्त नहीं है ..." यह विचित्र लगता है। क्या आप कुछ और स्पष्टीकरण जोड़ना चाहेंगे; जैसे "परीक्षण के तहत वास्तविक उत्पादन कोड 'में कौन सा भाग है ... जिसे फेंकना होगा?"

— घोस्टकट

() -> एक लंबोदर अभिव्यक्ति को इंगित करता है जो शून्य तर्कों को स्वीकार करता है। इस प्रकार, "उत्पादन कोड" जो अपवाद को फेंकने की उम्मीद करता है, को इंगित किया गया कोड ब्लॉक में है (यानी, throw new...घुंघराले ब्रैकेट के भीतर बयान)।

— सैम ब्रैनन

आमतौर पर लैम्ब्डा अभिव्यक्ति परीक्षण (एसयूटी) के तहत विषय के साथ बातचीत करेगी। दूसरे शब्दों में, ऊपर दिए गए अपवाद को सीधे फेंकना प्रदर्शन प्रयोजनों के लिए है।

— सैम ब्रॉनन

उम्मीद की तरह लगता है कि यह पदावनत है। डॉक्स कहते हैं कि अब assertThrows () का उपयोग करें।

— ३६ पर डिप्रेसिव

संस्करण के रूप में 5.0.0-M4 उम्मीद है कि यह अब उपलब्ध नहीं है। केवल मुखर की अनुमति है। देखें github.com/junit-team/junit5/blob/master/documentation/src/docs/... 'निकाला गया पदावनत Assertions.expectThrows) Assertions.assertThrows के पक्ष में) (विधि (':

— gil.fernandes

Answer 2

Java 8 और JUnit 5 (बृहस्पति) में हम निम्नानुसार अपवादों पर जोर दे सकते हैं। का उपयोग करते हुएorg.junit.jupiter.api.Assertions.assertThrows

सार्वजनिक स्थैतिक <T थ्रेडेबल> T assertThrows (कक्षा <T> अपेक्षित टाइप, निष्पादन योग्य निष्पादन) का विस्तार करता है

यह दावा करता है कि आपूर्ति किए गए निष्पादन योग्य का निष्पादन अपेक्षित अपवाद को छोड़ देता है और अपवाद को वापस कर देता है।

यदि कोई अपवाद नहीं फेंका गया है, या यदि कोई भिन्न प्रकार का अपवाद फेंका गया है, तो यह विधि विफल हो जाएगी।

यदि आप अपवाद उदाहरण पर अतिरिक्त जांच नहीं करना चाहते हैं, तो केवल रिटर्न मान को अनदेखा करें।

@Test
public void itShouldThrowNullPointerExceptionWhenBlahBlah() {
    assertThrows(NullPointerException.class,
            ()->{
            //do whatever you want to do here
            //ex : objectName.thisMethodShoulThrowNullPointerExceptionForNullParameter(null);
            });
}

यही कारण है कि दृष्टिकोण कार्यात्मक इंटरफ़ेस का उपयोग करेगा Executableमें org.junit.jupiter.api।

देखें:

• http://junit.org/junit5/docs/current/user-guide/#writing-tests-assertions
• http://junit.org/junit5/docs/5.0.0-M2/api/org/junit/jupiter/api/Executable.html
• http://junit.org/junit5/docs/5.0.0-M4/api/org/junit/jupiter/api/Assertions.html#assertThrows-java.lang.Class-org.junit.jupiter.api.function। Executable-

Comments

इस एक के साथ शीर्ष करने के लिए! यह अब तक का सबसे अच्छा जवाब है जो जुन्नित 5 के साथ सबसे अद्यतित है। इसके अलावा, इंटेलीजे assertThrows(NoSuchElementException.class, myLinkedList::getFirst);

— लैंबडा

Answer 3

उन्होंने इसे JUnit 5 में बदल दिया है (उम्मीद है: InvalidArgumentException, real: invoked method) और कोड इस तरह दिखता है:

@Test
public void wrongInput() {
    Throwable exception = assertThrows(InvalidArgumentException.class,
            ()->{objectName.yourMethod("WRONG");} );
}

Answer 4

अब Junit5 अपवादों को मुखर करने का एक तरीका प्रदान करता है

आप सामान्य अपवाद और अनुकूलित अपवाद दोनों का परीक्षण कर सकते हैं

एक सामान्य अपवाद परिदृश्य:

ExpectGeneralException.java

public void validateParameters(Integer param ) {
    if (param == null) {
        throw new NullPointerException("Null parameters are not allowed");
    }
}

ExpectGeneralExceptionTest.java

@Test
@DisplayName("Test assert NullPointerException")
void testGeneralException(TestInfo testInfo) {
    final ExpectGeneralException generalEx = new ExpectGeneralException();

     NullPointerException exception = assertThrows(NullPointerException.class, () -> {
            generalEx.validateParameters(null);
        });
    assertEquals("Null parameters are not allowed", exception.getMessage());
}

आप यहाँ CustomException का परीक्षण करने के लिए एक नमूना पा सकते हैं: अपवाद कोड नमूने पर जोर दें

ExpectCustomException.java

public String constructErrorMessage(String... args) throws InvalidParameterCountException {
    if(args.length!=3) {
        throw new InvalidParameterCountException("Invalid parametercount: expected=3, passed="+args.length);
    }else {
        String message = "";
        for(String arg: args) {
            message += arg;
        }
        return message;
    }
}

ExpectCustomExceptionTest.java

@Test
@DisplayName("Test assert exception")
void testCustomException(TestInfo testInfo) {
    final ExpectCustomException expectEx = new ExpectCustomException();

     InvalidParameterCountException exception = assertThrows(InvalidParameterCountException.class, () -> {
            expectEx.constructErrorMessage("sample ","error");
        });
    assertEquals("Invalid parametercount: expected=3, passed=2", exception.getMessage());
}

Comments

इसमें कोई अंतर नहीं है कि JUnit बिल्ट-इन और कस्टम अपवादों को कैसे संभालता है।

— बारिशदेव

Answer 5

मुझे लगता है कि यह एक और भी सरल उदाहरण है

List<String> emptyList = new ArrayList<>();
Optional<String> opt2 = emptyList.stream().findFirst();
assertThrows(NoSuchElementException.class, () -> opt2.get());

get()एक खाली युक्त वैकल्पिक पर कॉल करने से एक ArrayListफेंक दिया जाएगा NoSuchElementException। assertThrowsअपेक्षित अपवाद की घोषणा करता है और एक लैम्ब्डा आपूर्तिकर्ता प्रदान करता है (कोई तर्क नहीं लेता है और एक मूल्य लौटाता है)।

उनके जवाब के लिए @prime को धन्यवाद, जो मुझे उम्मीद है कि विस्तार से बताया गया है।

Comments

विधि assertThrowsफेंके गए अपवाद को वापस करती है। तो आप NoSuchElementException e = assertThrows(NoSuchElementException.class, () -> opt2.get());नीचे पसंद कर सकते हैं, फिर आप जो चाहें उस अपवाद वस्तु पर किसी भी प्रकार के दावे कर सकते हैं।

— कप्तान मैन

Answer 6

आप उपयोग कर सकते हैं assertThrows()। मेरा उदाहरण डॉक्स http://junit.org/junit5/docs/current/user-guide/ से लिया गया है

import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;

....

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

Answer 7

एक भी सरल एक लाइनर। Java 8 और JUnit 5 का उपयोग करते हुए इस उदाहरण के लिए कोई लंबोदर भाव या घुंघराले ब्रेसिज़ की आवश्यकता नहीं है

import static org.junit.jupiter.api.Assertions.assertThrows;

@Test
void exceptionTesting() {

    assertThrows(MyException.class, myStackObject::doStackAction, "custom message if assertion fails..."); 

// note, no parenthesis on doStackAction ex ::pop NOT ::pop()
}

Answer 8

वास्तव में मुझे लगता है कि इस विशेष उदाहरण के लिए प्रलेखन में कोई त्रुटि है। जो विधि अभीष्ट है वह अपेक्षित है

public static void assertThrows(
public static <T extends Throwable> T expectThrows(

Comments

"निकाले गए अभिकारकों को हटा दिया गया है। Asections.assertThrows () के पक्ष में विधि () विधि।"

— मार्टिन श्रोडर

Junit 5 के लिए, सुनिश्चित करें कि यह org.junit.jupiter.api से है। निबंधों में org.testng.Assert नहीं है। हमारी परियोजना में जूनिट और टेस्टएनजी दोनों शामिल हैं, और मैं तब तक प्राप्त करता रहा जब तक मैंने इसे मुखर नहीं किया। यह पता चला कि मैं org.testng.Assert का उपयोग कर रहा था।

— बैरीकु

Answer 9

यहाँ एक आसान तरीका है।

@Test
void exceptionTest() {

   try{
        model.someMethod("invalidInput");
        fail("Exception Expected!");
   }
   catch(SpecificException e){

        assertTrue(true);
   }
   catch(Exception e){
        fail("wrong exception thrown");
   }

}

यह तभी सफल होता है जब आपके द्वारा अपेक्षित अपवाद फेंका जाता है।