ExpectedException जोर

Question

मैं अगले समारोह के लिए एक इकाई परीक्षण लिखने के लिए की जरूरत है और मैंने देखा कि मैं उपयोग कर सकते हैं [ExpectedException]

इस समारोह का परीक्षण किया जा रहा है। फेंक दिया जा करने के लिए

public static T FailIfEnumIsNotDefined<T>(this T enumValue, string message = null) 
     where T:struct 
    { 
     var enumType = typeof (T); 

     if (!enumType.IsEnum) 
     { 
      throw new ArgumentOutOfRangeException(string.Format("Type {0} is not an Enum, therefore it cannot be checked if it is Defined not have defined.", enumType.FullName)); 
     } 
     else if (!Enum.IsDefined(enumType, enumValue)) 
     { 
      throw new ArgumentOutOfRangeException(string.Format("{1} Value {0} is not does not have defined value in Enum of type {0}. It should not be...", enumType.FullName, message ?? "")); 
     } 

     return enumValue; 
    } 

और यहाँ अपवाद है कि अपेक्षा की जाती है परीक्षण करने के लिए कोड जाना होगा

[TestMethod] 
    [ExpectedException(ArgumentOutOfRangeException(ArgumentException), "message")] 
    public void FailIfEnumIsNotDefined_Check_That_The_Value_Is_Not_Enum() 
    { 
     // PREPARE 
     // EXECUTE 
     // ASSERT 
    } 

मैं विचार नहीं है या तो अपवाद के लिए ज़ोर बनाने के लिए किया है।

Answer 1

ExpectedException सिर्फ निर्दिष्ट प्रकार की है कि अपवाद का दावा परीक्षण विधि से फेंक दिया जाएगा:

[TestMethod] 
[ExpectedException(typeof(ArgumentOutOfRangeException))] 
public void FailIfEnumIsNotDefined_Check_That_The_Value_Is_Not_Enum() 
{ 
    // PREPARE 
    // EXECUTE 
    // NO ASSERT!! 
} 

आप अपवाद के अन्य मानकों पर जोर चाहते हैं, तो आप अपने परीक्षा पद्धति में try..catch उपयोग करना चाहिए:

[TestMethod]  
public void FailIfEnumIsNotDefined_Check_That_The_Value_Is_Not_Enum() 
{ 
    // PREPARE 

    try 
    { 
     // EXECUTE 
     Assert.Fail() 
    } 
    catch(Exception exception) 
    {   
     // ASSERT EXCEPTION DETAILS 
    } 
} 

---

आप उसी परीक्षण कोड को बार-बार दोहराने से बचने के लिए अपवाद डालने के लिए अपना स्वयं का तरीका लिख ​​सकते हैं:

public TException AssertCatch<TException>(Action action) 
    where TException : Exception 
{ 
    try 
    { 
     action(); 
    } 
    catch (TException exception) 
    { 
     return exception; 
    } 

    throw new AssertFailedException("Expected exception of type " + 
            typeof(TException) + " was not thrown"); 
} 

उपयोग:

var exception = AssertCatch<ArgumentOutOfRangeException>(() => /* EXECUTE */); 
Assert.AreEqual("foo", exception.Message); 

Answer 2

आप ExpectedException अलग ढंग से उपयोग करना चाहिए:

[TestMethod] 
[ExpectedException(typeof(ArgumentOutOfRangeException))] 
public void MyTestSomething() 

और फिर अपने परीक्षण कोड ताकि उम्मीद अपवाद फेंक दिया जाता है।

Answer 3

यदि आप ExpectedException विशेषता का उपयोग कर रहे हैं तो आपको किसी दावे की आवश्यकता नहीं है, वास्तव में आपका कोड दावा पर पहुंचने में सक्षम नहीं होना चाहिए।

देखो: http://msdn.microsoft.com/en-us/library/microsoft.visualstudio.testtools.unittesting.expectedexceptionattribute.aspx

क्या आप वाकई अपवाद फेंक दिया जाता है आप आपरेशन कि इस मामले में अपवाद फेंक चाहिए अगर अपवाद नहीं है के बाद एक Assert.Fail() रखना चाहिए होना चाहते हैं, परीक्षण असफल हो जाएगा।

Answer 4

शायद आप अधिक अनुकूलित अपवाद हैंडलिंग देखना चाहते हैं। एमएसटीएस्ट एक्सपेक्टेड अपवाद एआरआर में कई त्रुटियां हैं। this दृष्टिकोण का उपयोग करने का प्रयास करें, जो आपको फेंकने वाले अपवाद पर अच्छा नियंत्रण प्रदान करता है। नहीं किया जा सकता

var ex = Assert.Throws<Exception>(() => _foo.DoSomething(a, b, c)); 
Assert.That(ex.Message, Is.EqualTo("Your exception message")); 

Answer 5

अपवाद जोर के साथ सही अपवाद संदेश के साथ फेंक है:

अपने स्वयं के अपेक्षित अपवाद सत्यापन को लागू करके।आप अतिरिक्त जानकारी और आवश्यकताओं को निर्दिष्ट कर सकते हैं कि में निर्मित ऐसे रूप ExpectedExceptionAttribute वर्ग संभाल सकते हैं के तरीकों, निम्नलिखित:

• अपवाद की स्थिति का सत्यापन करना।
• एक से अधिक प्रकार के अपवाद की अपेक्षा।
• एक गलत प्रकार का अपवाद फेंकने पर एक कस्टम संदेश प्रदर्शित करना।
• नकारात्मक परीक्षण के परिणाम को नियंत्रित करना।

आपके मामले में, यह कुछ इस तरह दिख सकता है:

public sealed class ExpectedExceptionMessageAttribute<T> : ExpectedExceptionBaseAttribute 
{ 
    readonly string _expectedMessage; 
    public ExpectedExceptionMessageAttribute(string expectedMessage) 
    { 
     _expectedMessage = expectedMessage; 
    } 

    protected override void Verify(System.Exception exception) 
    { 
     // Handle assertion exceptions from assertion failures in the test method 
     base.RethrowIfAssertException(exception); 

     Assert.IsInstanceOfType(exception, typeof(T), "wrong exception type"); 
     Assert.AreEqual(_expectedMessage, exception.Message, "wrong exception message"); 
    } 
} 

कहा कि, मैं अभी भी प्रत्यक्ष try उपयोग करने के लिए इच्छुक हो जाएगा - हालांकि के रूप में यह में अधिक विशिष्ट है catch दृष्टिकोण

public static void Throws<T>(Action action, Predicate<T> predicate = null) 
        where T : Exception 
{ 
    try 
    { 
     action(); 
    } 
    catch (T e) 
    { 
     if (predicate == null || predicate(e)) 
     { 
      return; 
     } 

     Assert.Fail($"Exception of type {typeof(T)} thrown as expected, but the provided predicate rejected it: {e}"); 
    } 
    catch (Exception e) 
    { 
     Assert.Fail($"Expected exception of type {typeof(T)} but a different exception was thrown: {e}"); 
    } 

    Assert.Fail($"No exception thrown, expected {typeof(T)}"); 
} 

Answer 6

जबकि ExpectedException अपवाद के संदेश को सत्यापित करने के लिए के रूप में है, तो आप ExpectedExceptionBaseAttribute से इनहेरिट द्वारा अपने स्वयं के अपवाद मान्यता तर्क को लागू कर सकते हैं: