मैं यह सत्यापित करने के लिए कि कैसे एक अपवाद को फेंक दिया गया है, मैं एस्टर का उपयोग कैसे करूं?


830

Assertयह सत्यापित करने के लिए कि मैं (या अन्य टेस्ट क्लास?) का उपयोग कैसे करूं ?


आप किस इकाई परीक्षण ढांचे का उपयोग कर रहे हैं?
केविन पुलिन

3
विजुअल स्टूडियो इंटीग्रेटेड
एलेक्स

4
क्या ExpectedException विशेषता मदद नहीं करती है? Ref: msdn.microsoft.com/en-us/library/…
shahkalpesh

2
मजेदार, मैंने अभी इसका उत्तर ढूंढना समाप्त किया है, इसे stackoverflow.com/questions/741029/testing-exception पर पाया है ।
dfjacobs

इसे भी देखें: stackoverflow.com/questions/741029/…
bytedev

जवाबों:


978

"विज़ुअल स्टूडियो टीम टेस्ट" के लिए यह प्रतीत होता है कि आप परीक्षण की विधि में ExpectedException विशेषता को लागू करते हैं।

यहाँ प्रलेखन से नमूना: विज़ुअल स्टूडियो टीम टेस्ट के साथ एक इकाई परीक्षण वॉकथ्रू

[TestMethod]
[ExpectedException(typeof(ArgumentException),
    "A userId of null was inappropriately allowed.")]
public void NullUserIdInConstructor()
{
   LogonInfo logonInfo = new LogonInfo(null, "P@ss0word");
}

25
NUnit में काम करता है (लेकिन [TestMethod] होना चाहिए [परीक्षण]) के ऊपर ExpectedException विशेषता।
dbkk

5
@dbkk: doesn बिल्कुल NUnit में समान काम नहीं करता है - संदेश को एक स्ट्रिंग के रूप में माना जाता है जिसे अपवाद संदेश को matcvh करने की आवश्यकता होती है (और IU लगता है कि अधिक समझ में आता है)
Ruben Bartelink

29
इस विशेषता से काम पूरा हो जाता है और यह सी # प्रोग्रामर्स के लिए एक अंतर्निहित सुविधा है, लेकिन मैं इसका उपयोग करने की अनुशंसा नहीं करता हूं क्योंकि यह पर्याप्त लचीला नहीं है। विचार करें कि क्या होता है यदि अपवाद प्रकार आपके परीक्षण सेटअप कोड द्वारा फेंक दिया जाता है: परीक्षण पास हो जाता है, लेकिन वास्तव में आपने जो उम्मीद की थी वह नहीं किया। या क्या होगा यदि आप अपवाद वस्तु की स्थिति का परीक्षण करना चाहते हैं। मैं आमतौर पर पूरे संदेश का परीक्षण करने के बजाय StringAssert.Contains (e.Message ...) का उपयोग करना चाहता हूं। अन्य उत्तर में वर्णित अनुसार एक मुखर विधि का उपयोग करें।
स्टीव

3
NUnit में ExpectedException का उपयोग करने से बचें, क्योंकि इसे NUnit 3.0 में गिरा दिया जाएगा। मैं Assert.Throws <SpecificException> () का उपयोग करना पसंद करता हूं
Terence

5
आप MsTest के भीतर Assert.ThrowsException <T> और Assert.ThrowsExceptionAsync <T> का उपयोग कर सकते हैं।
गोपाल कृष्णन

257

आमतौर पर आपके परीक्षण ढांचे के पास इसके लिए एक उत्तर होगा। लेकिन अगर यह पर्याप्त लचीला नहीं है, तो आप हमेशा ऐसा कर सकते हैं:

try {
    somethingThatShouldThrowAnException();
    Assert.Fail(); // If it gets to this line, no exception was thrown
} catch (GoodException) { }

@ जोंस बताते हैं, आधार को पकड़ने के लिए यह काम नहीं करता है:

try {
    somethingThatShouldThrowAnException();
    Assert.Fail(); // raises AssertionException
} catch (Exception) {
    // Catches the assertion exception, and the test passes
}

यदि आप बिल्कुल अपवाद को पकड़ते हैं, तो आपको Assert.Fail () को पुनर्विचार करने की आवश्यकता है। लेकिन वास्तव में, यह एक संकेत है जिसे आपको हाथ से नहीं लिखना चाहिए; विकल्पों के लिए अपने परीक्षण ढांचे की जांच करें, या देखें कि क्या आप परीक्षण के लिए अधिक सार्थक अपवाद फेंक सकते हैं।

catch (AssertionException) { throw; }

आपको जो कुछ भी पसंद है उसे इस दृष्टिकोण को अनुकूलित करने में सक्षम होना चाहिए - जिसमें यह निर्दिष्ट करना है कि किस प्रकार के अपवादों को पकड़ना है। यदि आप केवल कुछ प्रकारों की अपेक्षा करते हैं, तो catchब्लॉक को समाप्त करें :

} catch (GoodException) {
} catch (Exception) {
    // not the right kind of exception
    Assert.Fail();
}

20
+1, मैं विशेषता के बजाय इस प्रकार का उपयोग करता हूं, जब मुझे अपवाद के प्रकार से परे अभिकथन करने की आवश्यकता होती है। उदाहरण के लिए, क्या होगा अगर किसी को यह जांचने की आवश्यकता है कि अपवाद उदाहरण में कुछ फ़ील्ड कुछ मानों पर सेट हैं।
पावेल रेपिन

2
आपको त्रुटि संदेश निर्दिष्ट करने की आवश्यकता नहीं है। यह पर्याप्त है: [ExpectedException (
टाइपोफ

5
मुझे लगता है कि यह समाधान सबसे अच्छा है। [ExpectedException (टाइपोफ (ArgumentException)))] का उपयोग किया जाता है, यदि परीक्षण सरल है, लेकिन यह मेरे विचार में एक आलसी समाधान है और इसके साथ सहज होने से नुकसान हो सकता है। यह समाधान आपको अधिक सही परीक्षण करने के लिए विशिष्ट नियंत्रण प्रदान करता है, साथ ही आप अपनी परीक्षण चलाने की रिपोर्ट के लिए रिटलाइन का परीक्षण कर सकते हैं, कि अपवाद वास्तव में अपेक्षित रूप से फेंक दिया गया था।
बुराईफिश

12
इसके साथ सावधान रहें क्योंकि Assert.Fail () एक अपवाद बढ़ाते हैं, अगर आप इसे पकड़ लेते हैं, तो परीक्षा पास!
जोनास

4
@ Vinnyq12 मेरा क्या मतलब है कि ऊपर दिए गए उदाहरण में पहला परीक्षण कभी असफल नहीं होगा। एक परीक्षण विफल रहता है अगर एक अपवाद फेंक दिया जाता है (और ExpectedExceptionAttribute द्वारा "पकड़" नहीं)
जोनास

113

इसे लागू करने के लिए मेरा पसंदीदा तरीका थ्रोस नामक एक विधि लिखना है, और इसे किसी अन्य Assert विधि की तरह उपयोग करना है। दुर्भाग्यवश, .NET आपको एक स्टैटिक एक्सटेंशन विधि लिखने की अनुमति नहीं देता है, इसलिए आप इस पद्धति का उपयोग नहीं कर सकते हैं जैसे कि यह वास्तव में एस्टर क्लास में निर्मित है; बस एक और MyAssert या ऐसा ही कुछ कहा जाता है। वर्ग इस तरह दिखता है:

using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;

namespace YourProject.Tests
{
    public static class MyAssert
    {
        public static void Throws<T>( Action func ) where T : Exception
        {
            var exceptionThrown = false;
            try
            {
                func.Invoke();
            }
            catch ( T )
            {
                exceptionThrown = true;
            }

            if ( !exceptionThrown )
            {
                throw new AssertFailedException(
                    String.Format("An exception of type {0} was expected, but not thrown", typeof(T))
                    );
            }
        }
    }
}

इसका मतलब है कि आपकी इकाई परीक्षण इस तरह दिखता है:

[TestMethod()]
public void ExceptionTest()
{
    String testStr = null;
    MyAssert.Throws<NullReferenceException>(() => testStr.ToUpper());
}

जो आपके बाकी यूनिट टेस्ट सिंटैक्स की तरह दिखता है और बहुत अधिक व्यवहार करता है।


1
बूल ध्वज से छुटकारा पाएं और अधिक कॉम्पैक्ट कार्यान्वयन के लिए इनवोक के बाद सीधे लाइन पर फेंक दें।
जीई

11
केवल एक चीज जो इसे बेहतर बनाती है वह है फ़ंक्शन को पकड़ा गया अपवाद वापस करना ताकि आप यह सुनिश्चित कर सकें कि अपवाद पर मौजूद विशेषताओं जैसी चीज़ें सही हैं।
मार्क हिल्ड्रेथ

2
धन्यवाद! यह मेरे लिए सबसे अच्छा तरीका है क्योंकि यह एक विधि में कई अपवादों का परीक्षण करने का एक छोटा तरीका है। यह बहुत अधिक पठनीय है।
डेविड शेरेट

2
@MickeyPerlstein विशेषताएँ परीक्षण के लिए AAA नियम तोड़ती हैं। विशेष रूप से, यदि आपकी व्यवस्था एक्ट में आने से पहले ही अपवाद को फेंक देती है, तो आपका टेस्ट पास हो जाता है ... eek!
स्वतंत्रता-

2
Microsoft ने आखिरकार MSTest - v2 समर्थन को अपडेट करने के लिए गोल कर दिया है Assert.ThrowsException<T>और Assert.ThrowsExceptionAsync<T>देखें blogs.msdn.microsoft.com/visualstudioalm/2017/02/25/…
Quango

62

यदि आप NUNIT का उपयोग करते हैं, तो आप ऐसा कुछ कर सकते हैं:

Assert.Throws<ExpectedException>(() => methodToTest());


आगे इसे मान्य करने के लिए फेंके गए अपवाद को संग्रहीत करना भी संभव है:

ExpectedException ex = Assert.Throws<ExpectedException>(() => methodToTest());
Assert.AreEqual( "Expected message text.", ex.Message );
Assert.AreEqual( 5, ex.SomeNumber);

देखें: http://nunit.org/docs/2.5/exceptionAsserts.html


60

यदि आप MSTest का उपयोग कर रहे हैं, जिसमें मूल रूप से एक ExpectedExceptionविशेषता नहीं थी , तो आप ऐसा कर सकते हैं:

try 
{
    SomeExceptionThrowingMethod()
    Assert.Fail("no exception thrown");
}
catch (Exception ex)
{
    Assert.IsTrue(ex is SpecificExceptionType);
}

3
यह काम करता है, लेकिन मैं इसे सामान्य रूप से नहीं सुझाता क्योंकि तर्क अत्यधिक जटिल है। यह कहते हुए कि यह जटिल नहीं है, लेकिन विचार करें कि क्या आप कई परीक्षणों के लिए कोड के इस ब्लॉक को लिखते हैं - 10s, 100s परीक्षण। इस तर्क को एक अच्छी तरह से डिज़ाइन किए गए मुखर तरीके से तैयार किया जाना चाहिए। अन्य उत्तर देखें।
स्टीव

35

ExpectedException का उपयोग करने से सावधान रहें, क्योंकि यह यहाँ दिखाए गए अनुसार कई नुकसान पहुंचा सकता है:

http://geekswithblogs.net/sdorman/archive/2009/01/17/unit-testing-and-expected-exceptions.aspx

और यहाँ:

http://xunit.github.io/docs/comparisons.html

यदि आपको अपवादों का परीक्षण करने की आवश्यकता है, तो तरीकों पर कम डूबे हुए हैं। आप कोशिश कर सकते हैं {act / fail} catch {assert} विधि का उपयोग करें, जो ऐसे फ्रेमवर्क के लिए उपयोगी हो सकता है जिनके पास ExpectedException के अलावा अपवाद परीक्षणों के लिए प्रत्यक्ष समर्थन नहीं है।

एक बेहतर विकल्प xUnit.NET का उपयोग करना है, जो कि एक बहुत ही आधुनिक, आगे की ओर देखने वाली और एक्स्टेंसिबल यूनिट टेस्टिंग फ्रेमवर्क है जो अन्य सभी गलतियों से सीखा है, और बेहतर हुआ है। ऐसा ही एक सुधार Assert.Throws है, जो अपवादों को मुखर करने के लिए बहुत बेहतर सिंटैक्स प्रदान करता है।

आप xUnit.NET को github पर पा सकते हैं: http://xunit.github.io/


4
ध्यान दें कि NUnit 2.5 अब Assert.Throws स्टाइल सिंटैक्स का भी समर्थन करता है - nunit.com/index.php?p=releaseNotes&r=2.5
Alconja

ExpectedException का उपयोग करते समय इकाई परीक्षण जिस तरह से आपको अपवाद के बारे में बताने के लिए रोकती है वह मुझे पागल कर देता है। एमएस ने क्यों सोचा कि स्वचालित परीक्षणों में मैन्युअल कदम रखना एक अच्छा विचार था? लिंक के लिए धन्यवाद।
चींटी

@Ant: MS ने NUnit की नकल की ... तो असली सवाल यह है कि Nnnit को यह एक अच्छा विचार क्यों लगा?
jrista

28

MSTest (v2) में अब Assert.ThrowsException फ़ंक्शन है, जिसका उपयोग इस तरह किया जा सकता है:

Assert.ThrowsException<System.FormatException>(() =>
            {
                Story actual = PersonalSite.Services.Content.ExtractHeader(String.Empty);
            }); 

आप इसे नगेट के साथ स्थापित कर सकते हैं: Install-Package MSTest.TestFramework


2018 में यह सबसे अच्छा अभ्यास माना जाता है क्योंकि यह जांचता है कि केवल परीक्षण के तहत इकाई फेंक रही है और कुछ अन्य कोड नहीं।
CM

24

एक परियोजना में, हम इस पर काम कर रहे हैं एक और समाधान है।

पहले मुझे ExpectedExceptionAttribute becuase की तरह यह ध्यान में नहीं आता कि कौन सी विधि कॉल है जो अपवाद का कारण बनी।

मैं इसके बजाय एक सहायक के साथ ऐसा करता हूं।

परीक्षा

[TestMethod]
public void AccountRepository_ThrowsExceptionIfFileisCorrupt()
{
     var file = File.Create("Accounts.bin");
     file.WriteByte(1);
     file.Close();

     IAccountRepository repo = new FileAccountRepository();
     TestHelpers.AssertThrows<SerializationException>(()=>repo.GetAll());            
}

HelperMethod

public static TException AssertThrows<TException>(Action action) where TException : Exception
    {
        try
        {
            action();
        }
        catch (TException ex)
        {
            return ex;
        }
        Assert.Fail("Expected exception was not thrown");

        return null;
    }

नीट, यह नहीं है;)


14

यह परीक्षण विधि पर एक विशेषता है ... आप Assert का उपयोग नहीं करते हैं। इस तरह दिखता है:

[ExpectedException(typeof(ExceptionType))]
public void YourMethod_should_throw_exception()

13

आप Nuget का उपयोग करके एक पैकेज डाउनलोड कर सकते हैं: PM> Install-Package MSTestExtensions जो MsTest को nUnit / xUnit की शैली में Assert.Throws () सिंटैक्स जोड़ता है।

उच्च स्तरीय निर्देश: असेंबली को डाउनलोड करें और बेसटेस्ट से विरासत में मिला है और आप Assert.Throws () सिंटैक्स का उपयोग कर सकते हैं ।

थ्रोज़ कार्यान्वयन के लिए मुख्य विधि निम्नानुसार है:

public static void Throws<T>(Action task, string expectedMessage, ExceptionMessageCompareOptions options) where T : Exception
{
    try
    {
        task();
    }
    catch (Exception ex)
    {
        AssertExceptionType<T>(ex);
        AssertExceptionMessage(ex, expectedMessage, options);
        return;
    }

    if (typeof(T).Equals(new Exception().GetType()))
    {
        Assert.Fail("Expected exception but no exception was thrown.");
    }
    else
    {
        Assert.Fail(string.Format("Expected exception of type {0} but no exception was thrown.", typeof(T)));
    }
}

प्रकटीकरण: मैंने इस पैकेज को एक साथ रखा।

अधिक जानकारी: http://www.bradoncode.com/blog/2012/01/asserting-exception-in-mstest-with.html


उदाहरण के लिए धन्यवाद। क्या आपके पास Assert.DoesNotThrow () या समकक्ष का परीक्षण करने का एक उदाहरण है?
लेन गोल्सबी

10

आप इसे एक सरल-रेखा के साथ प्राप्त कर सकते हैं।

यदि आपका ऑपरेशन foo.bar()async है:

await Assert.ThrowsExceptionAsync<Exception>(() => foo.bar());

यदि foo.bar()एसिंक्स नहीं है

Assert.ThrowsException<Exception>(() => foo.bar());

1
अन्य बहुत सारे उत्तर हैं, मेरे लिए मैं केवल अपवाद प्रकार द्वारा ज्ञात विफल स्थितियों के परीक्षण के लिए एक आशुलिपि तरीका ढूंढ रहा था, यह सबसे आसान पठनीय परीक्षण मामलों के लिए बनाता है। नोट: अपवाद प्रकार एक मानक ट्राइ-कैच की तरह विरासत वाले अपवाद वर्गों से मेल नहीं खाता है, इसलिए उपरोक्त उदाहरण उदाहरण के लिए नहीं फँस जाएगा ArgumentException। यदि आप परीक्षण करने के लिए उन्नत मानदंड रखते हैं, तो पुराना ट्रैप कैच और अपवाद प्रतिक्रिया का परीक्षण अभी भी पसंद किया जाता है, लेकिन यह मेरे बहुत काम आता है!
क्रिस Schaller

5

मैं ExpectedException विशेषता का उपयोग करने की अनुशंसा नहीं करता (क्योंकि यह बहुत अड़चन और त्रुटि-प्रवण है) या प्रत्येक परीक्षण में एक कोशिश / कैच ब्लॉक लिखने के लिए (क्योंकि यह बहुत जटिल और त्रुटि-प्रवण है)। एक अच्छी तरह से डिज़ाइन की गई मुखर पद्धति का उपयोग करें - या तो आपके परीक्षण ढांचे द्वारा प्रदान की गई है या अपना स्वयं का लिखें। यहाँ मैंने जो लिखा और उपयोग किया है।

public static class ExceptionAssert
{
    private static T GetException<T>(Action action, string message="") where T : Exception
    {
        try
        {
            action();
        }
        catch (T exception)
        {
            return exception;
        }
        throw new AssertFailedException("Expected exception " + typeof(T).FullName + ", but none was propagated.  " + message);
    }

    public static void Propagates<T>(Action action) where T : Exception
    {
        Propagates<T>(action, "");
    }

    public static void Propagates<T>(Action action, string message) where T : Exception
    {
        GetException<T>(action, message);
    }

    public static void Propagates<T>(Action action, Action<T> validation) where T : Exception
    {
        Propagates(action, validation, "");
    }

    public static void Propagates<T>(Action action, Action<T> validation, string message) where T : Exception
    {
        validation(GetException<T>(action, message));
    }
}

उदाहरण का उपयोग करता है:

    [TestMethod]
    public void Run_PropagatesWin32Exception_ForInvalidExeFile()
    {
        (test setup that might propagate Win32Exception)
        ExceptionAssert.Propagates<Win32Exception>(
            () => CommandExecutionUtil.Run(Assembly.GetExecutingAssembly().Location, new string[0]));
        (more asserts or something)
    }

    [TestMethod]
    public void Run_PropagatesFileNotFoundException_ForExecutableNotFound()
    {
        (test setup that might propagate FileNotFoundException)
        ExceptionAssert.Propagates<FileNotFoundException>(
            () => CommandExecutionUtil.Run("NotThere.exe", new string[0]),
            e => StringAssert.Contains(e.Message, "NotThere.exe"));
        (more asserts or something)
    }

टिप्पणियाँ

सत्यापन कॉलबैक का समर्थन करने के बजाय अपवाद लौटा देना एक उचित विचार है, सिवाय इसके कि ऐसा करने के लिए कॉलिंग सिंटैक्स इस दावे का बहुत ही भिन्न उपयोग करता है जो मैं उपयोग करता है।

दूसरों के विपरीत, मैं 'फेंकता' के बजाय 'प्रोपेगेट्स' का उपयोग करता हूं क्योंकि हम केवल यह परीक्षण कर सकते हैं कि एक कॉल से कोई अपवाद फैलता है या नहीं। हम सीधे परीक्षण नहीं कर सकते कि एक अपवाद फेंक दिया गया है। लेकिन मुझे लगता है कि आप फेंकने के लिए छवि फेंक सकते हैं: फेंक दिया गया और पकड़ा नहीं गया।

अंतिम THOUGHT

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

इसलिए सारांश में, यह दृष्टिकोण खेल: आसानी से उपयोग, लचीलापन और मजबूती (इसे गलत करना कठिन है)।


4

@Richiban द्वारा प्रदान किया गया सहायक इसके अलावा महान काम करता है, यह उस स्थिति को नहीं संभालता है जहां एक अपवाद को फेंक दिया जाता है, लेकिन अपेक्षित प्रकार नहीं। निम्नलिखित पते हैं कि:

using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;

namespace YourProject.Tests
{
    public static class MyAssert
    {
        /// <summary>
        /// Helper for Asserting that a function throws an exception of a particular type.
        /// </summary>
        public static void Throws<T>( Action func ) where T : Exception
        {
            Exception exceptionOther = null;
            var exceptionThrown = false;
            try
            {
                func.Invoke();
            }
            catch ( T )
            {
                exceptionThrown = true;
            }
            catch (Exception e) {
                exceptionOther = e;
            }

            if ( !exceptionThrown )
            {
                if (exceptionOther != null) {
                    throw new AssertFailedException(
                        String.Format("An exception of type {0} was expected, but not thrown. Instead, an exception of type {1} was thrown.", typeof(T), exceptionOther.GetType()),
                        exceptionOther
                        );
                }

                throw new AssertFailedException(
                    String.Format("An exception of type {0} was expected, but no exception was thrown.", typeof(T))
                    );
            }
        }
    }
}

2
हम्म् ... मैं इस विचार को समझता हूं, लेकिन मुझे यकीन नहीं है कि मैं सहमत हूं कि यह बेहतर है। सिर्फ इसलिए कि हम एक विशिष्ट अपवाद सुनिश्चित करना चाहते हैं इसका मतलब यह नहीं है कि सभी अन्य को एक विफलता के रूप में लपेटा जाना चाहिए। IMHO एक अज्ञात अपवाद बस स्टैक को बुलबुला करना चाहिए क्योंकि यह किसी भी अन्य मुखर ऑपरेशन में होगा।
20

@Martin मैं अपवाद को शामिल करने वाला कोड हटा दूंगा और बस दूसरे कैच क्लॉज से रीथ्रो
टॉम

4

जब से तुम अन्य परीक्षण वर्गों का उपयोग उल्लेख करते हैं, से एक बेहतर विकल्प ExpectedExceptionविशेषता का उपयोग करने के लिए है Shoudly के Should.Throw

Should.Throw<DivideByZeroException>(() => { MyDivideMethod(1, 0); });

मान लीजिए कि हमारे पास एक आवश्यकता है कि ग्राहक के पास ऑर्डर बनाने के लिए एक पता होना चाहिए । यदि नहीं, तो विधि में परिणाम होना चाहिए । तब हम लिख सकते थे:CreateOrderForCustomerArgumentException

[TestMethod]
public void NullUserIdInConstructor()
{
  var customer = new Customer(name := "Justin", address := null};

  Should.Throw<ArgumentException>(() => {
    var order = CreateOrderForCustomer(customer) });
}

यह एक ExpectedExceptionविशेषता का उपयोग करने से बेहतर है क्योंकि हम इस बारे में विशिष्ट हैं कि त्रुटि क्या फेंकनी चाहिए। यह हमारे परीक्षणों को स्पष्ट करता है और परीक्षण विफल होने पर निदान को आसान बनाता है।

नोट Should.ThrowAsyncअतुल्यकालिक विधि परीक्षण के लिए भी है ।


4

एक विकल्प के रूप में आप परीक्षण के अपवादों को आज़मा सकते हैं, वास्तव में आपके परीक्षण में अगली 2 पंक्तियों के साथ फेंके जा रहे हैं।

var testDelegate = () => MyService.Method(params);
Assert.Throws<Exception>(testDelegate);

4

वी.एस. बिल्ट-इन यूनिट टेस्टिंग में यदि आप केवल यह सत्यापित करना चाहते हैं कि "कोई अपवाद" फेंका गया है, लेकिन आप प्रकार नहीं जानते हैं, तो आप एक कैच का उपयोग कर सकते हैं:

[TestMethod]
[ExpectedException(typeof(Exception), AllowDerivedTypes = true)]
public void ThrowExceptionTest()
{
    //...
}

3

वैसे मैं बहुत ज्यादा योग करूँगा कि यहाँ बाकी सभी ने पहले क्या कहा ... वैसे भी, यहाँ कोड मैं अच्छे उत्तरों के अनुसार बनाया गया है :) सभी को करना बाकी है कॉपी और उपयोग ...

/// <summary>
/// Checks to make sure that the input delegate throws a exception of type TException.
/// </summary>
/// <typeparam name="TException">The type of exception expected.</typeparam>
/// <param name="methodToExecute">The method to execute to generate the exception.</param>
public static void AssertRaises<TException>(Action methodToExecute) where TException : System.Exception
{
    try
    {
        methodToExecute();
    }
    catch (TException) {
        return;
    }  
    catch (System.Exception ex)
    {
        Assert.Fail("Expected exception of type " + typeof(TException) + " but type of " + ex.GetType() + " was thrown instead.");
    }
    Assert.Fail("Expected exception of type " + typeof(TException) + " but no exception was thrown.");  
}


2

यह इस बात पर निर्भर करने वाला है कि आप किस परीक्षण ढांचे का उपयोग कर रहे हैं?

उदाहरण के लिए, MbUnit में, आप यह सुनिश्चित करने के लिए एक विशेषता के साथ अपेक्षित अपवाद निर्दिष्ट कर सकते हैं कि आपको वह अपवाद मिल रहा है जिसकी आप वास्तव में अपेक्षा करते हैं।

[ExpectedException(typeof(ArgumentException))]

2

NUnit का उपयोग करने के मामले में , यह प्रयास करें:

Assert.That(() =>
        {
            Your_Method_To_Test();
        }, Throws.TypeOf<Your_Specific_Exception>().With.Message.EqualTo("Your_Specific_Message"));

2

एनफ्लुएंट नामक एक बहुत बढ़िया पुस्तकालय है, जो आपके लेखन के तरीके को गति देता है और इसे आसान बनाता है

एक अपवाद को फेंकने के लिए एक जोरदार लिखना बहुत सरल है:

    [Test]
    public void given_when_then()
    {
        Check.ThatCode(() => MethodToTest())
            .Throws<Exception>()
            .WithMessage("Process has been failed");
    }

1

हालांकि यह एक पुराना सवाल है, मैं चर्चा में एक नई सोच जोड़ना चाहूंगा। मैंने Expected, Arrange, Act, Assert होने के लिए Arrange, Act, Assert पैटर्न को बढ़ाया है। आप एक अपेक्षित अपवाद सूचक बना सकते हैं, फिर यह दावा करें कि इसे सौंपा गया था। यह आपके एस्कॉर्ट्स को कैच ब्लॉक में करने से ज्यादा साफ लगता है, अपने एक्ट सेक्शन को कोड की एक लाइन के लिए टेस्ट के तहत कॉल करने के लिए। आपको कोड में कई बिंदुओं से Assert.Fail();या उसके पास नहीं है return। फेंके गए किसी अन्य अपवाद के कारण परीक्षण विफल हो जाएगा, क्योंकि यह पकड़ा नहीं जाएगा, और यदि आपके अपेक्षित प्रकार के अपवाद को फेंक दिया जाता है, लेकिन यह वह नहीं था जिसकी आप उम्मीद कर रहे थे, संदेश या अन्य गुणों के खिलाफ जोर देना अपवाद मदद सुनिश्चित करें कि आपका परीक्षण अनजाने में पारित नहीं होगा।

[TestMethod]
public void Bar_InvalidDependency_ThrowsInvalidOperationException()
{
    // Expectations
    InvalidOperationException expectedException = null;
    string expectedExceptionMessage = "Bar did something invalid.";

    // Arrange
    IDependency dependency = DependencyMocks.Create();
    Foo foo = new Foo(dependency);

    // Act
    try
    {
        foo.Bar();
    }
    catch (InvalidOperationException ex)
    {
        expectedException = ex;
    }

    // Assert
    Assert.IsNotNull(expectedException);
    Assert.AreEqual(expectedExceptionMessage, expectedException.Message);
}
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.