इकाई परीक्षण अपवाद संपत्ति

Question

मैं मैं परीक्षण वर्ग पार्सर जो विशिष्ट इनपुट पर ऊपर अपवाद फेंक चाहिए करने के लिए इकाई परीक्षण का उपयोग कर रहा अपवाद

class SyntaxError : Exception { 
    public SyntaxError(int l) { 
     line = l; 
    } 
    public int line; 
} 

है। मैं कोड का उपयोग कर रहा इस तरह:

[TestMethod] 
    [ExpectedException(typeof(Parser.SyntaxError))] 
    public void eolSyntaxError() 
    { 
     parser.reader = new StringReader("; alfa\n; beta\n\n\n\na"); 
     parser.eol(); 
    } 

वहाँ अगर SyntaxError.line == 1 जाँच करने के लिए किसी भी स्मार्ट आसान तरीका है?

बेस्ट मैं के साथ आ रहा है:

[TestMethod] 
    public void eolSyntaxError() 
    { 
     try { 
      parser.reader = new StringReader("; alfa\n; beta\n\n\n\na"); 
      parser.eol(); 
      Assert.Fail(); 
     } catch (SyntaxError e) { 
      Assert.AreEqual(1, e.line); 
     } 
    } 

मुझे बहुत पसंद नहीं है, वहाँ बेहतर तरीका है?

Answer 1

FluentAssertions उपयोग पर विचार करें। आपका परीक्षण तब इस तरह दिखेगा:

[TestMethod] 
public void eolSyntaxError() 
{ 
    parser.reader = new StringReader("; alfa\n; beta\n\n\n\na"); 

    Action parseEol =() => parser.eol(); 

    parseEol 
     .ShouldThrow<SyntaxError>() 
     .And.line.Should().Be(1); 
} 

अन्यथा, आपका दृष्टिकोण जितना अच्छा हो उतना अच्छा है।

Answer 2

मेरी टिप्पणी के अनुसार, यदि आप जिस वाक्य पर वाक्यविन्यास त्रुटि का सामना करते हैं, वह प्रासंगिक है, तो इसे अपने कस्टम अपवाद वर्ग में शामिल करें।

public class SyntaxError : Exception 
{ 
    public SyntaxError(int atLine) 
    { 
     AtLine = atLine; 
    } 

    public int AtLine { get; private set; } 
} 

फिर परीक्षण करना आसान है।

संपादित करें - प्रश्न पढ़ने के बाद (!) यहां एक साधारण अतिरिक्त आर्टर्ट विधि है जो आपके अपवाद दावों को साफ करेगी।

public static class xAssert 
{ 
    public static TException Throws<TException>(Action a) where TException : Exception 
    { 
     try 
     { 
      a(); 
     } 
     catch (Exception ex) 
     { 
      var throws = ex as TException; 
      if (throws != null) 
       return throws; 
     } 
     Assert.Fail(); 
     return default(TException); 
    } 
} 

प्रयोग इस प्रकार है ...

public class Subject 
{ 
    public void ThrowMyException(int someState) 
    { 
     throw new MyException(someState); 
    } 

    public void ThrowSomeOtherException() 
    { 
     throw new InvalidOperationException(); 
    } 
} 

public class MyException : Exception 
{ 
    public int SomeState { get; private set; } 

    public MyException(int someState) 
    { 
     SomeState = someState; 
    } 
} 

[TestClass] 
public class UnitTest1 
{ 
    [TestMethod] 
    public void TestMethod1() 
    { 
     var subject = new Subject(); 
     var exceptionThrown = xAssert.Throws<MyException>(() => { subject.ThrowMyException(123); }); 

     Assert.AreEqual(123, exceptionThrown.SomeState); 
    } 
} 

Answer 3

मैं इस के लिए बॉक्स समाधान के बाहर एक के बारे में पता नहीं कर रहा हूँ, लेकिन मैं उम्मीदों की अवधारणा जो इस तरह काम देखा है:

[TestMethod] 
public void EolSyntaxError() 
{ 
    Expectations.Expect<(SyntaxError>(
     () => 
     { 
      parser.reader = new StringReader("; alfa\n; beta\n\n\n\na"); 
      parser.eol(); 
     }, 
     e => 
     { 
      Assert.AreEqual(1, e.line); 
     }); 
} 

अपेक्षाओं को लागू करने की आवश्यकता है। मुझे लगता है कि वहां पुस्तकालय होंगे जो पहले से ही ऐसा करते हैं। किसी भी तरह, Expectations में Expect विधि ऐसा दिखाई दे सकता:

public static void Expect<TExpectedException>(
    System.Action action, 
    System.Action<TExpectedException> assertion) where TExpectedException : Exception 
{ 
    if (action == null) { throw new ArgumentNullException("action"); } 
    try 
    { 
     action.Invoke(); 
     Assert.Fail(string.Format("{0} expected to be thrown", typeof(TExpectedException).Name)); 
    } 
    catch (TExpectedException e) 
    { 
     assertion.Invoke(e); 
    } 
} 

Answer 4

आप एक विधि NUnit

public T Throws<T>(Action code) where T : Exception 
{ 
    Exception coughtException = null; 
    try 
    { 
     code(); 
    } 
    catch (Exception ex) 
    { 
     coughtException = ex; 
    } 

    Assert.IsNotNull(coughtException, "Test code didn't throw exception"); 
    Assert.AreEqual(coughtException.GetType(), typeof(T), "Test code didn't throw same type exception"); 

    return (T)coughtException; 
} 

से मिलता-जुलता लिख ​​सकता है और फिर आप अपने परीक्षण विधि

Parser.SyntaxError exception = Throws<Parser.SyntaxError>(() => parser.eol()); 
Assert.AreEqual(1, exception.line);