NUnit के समान xUnit.net में परीक्षण पैरामीटर

Question

क्या NUnit की निम्नलिखित विशेषताओं के समान xUnit.net ढांचे में कोई साधन हैं?

[Test, TestCaseSource("CurrencySamples")]
public void Format_Currency(decimal value, string expected){}

static object[][] CurrencySamples = new object[][]
{
    new object[]{ 0m, "0,00"},
    new object[]{ 0.0004m, "0,00"},
    new object[]{ 5m, "5,00"},
    new object[]{ 5.1m, "5,10"},
    new object[]{ 5.12m, "5,12"},
    new object[]{ 5.1234m, "5,12"},
    new object[]{ 5.1250m, "5,13"}, // round
    new object[]{ 5.1299m, "5,13"}, // round
}

यह NUnit GUI में 8 अलग-अलग परीक्षण उत्पन्न करेगा

[TestCase((string)null, Result = "1")]
[TestCase("", Result = "1")]
[TestCase(" ", Result = "1")]
[TestCase("1", Result = "2")]
[TestCase(" 1 ", Result = "2")]
public string IncrementDocNumber(string lastNum) { return "some"; }

यह 5 अलग परीक्षण उत्पन्न करेगा और स्वचालित रूप से परिणामों की तुलना करेगा ( Assert.Equal())।

[Test]
public void StateTest(
    [Values(1, 10)]
    int input,
    [Values(State.Initial, State.Rejected, State.Stopped)]
    DocumentType docType
){}

यह 6 कॉम्बीनेटरियल परीक्षण उत्पन्न करेगा। अमूल्य।

कुछ साल पहले मैंने xUnit की कोशिश की और इसे पसंद किया लेकिन इसमें इन विशेषताओं का अभाव था। उनके बिना नहीं रह सकते। कुछ बदल गया है?

Comments

एक पूर्ण मार्गदर्शिका जो जटिल वस्तुओं को एक पैरामीटर के रूप में टेस्ट के जटिल प्रकारों को यूनिट टेस्ट में

— भेजती है

Answer 1

xUnit डेटा थ्योरी नामक कुछ के माध्यम से पैरामीटर किए गए परीक्षणों को चलाने का एक तरीका प्रदान करता है । अवधारणा NUnit में पाए जाने वाले के बराबर है, लेकिन आप बॉक्स से जो कार्यक्षमता प्राप्त करते हैं वह पूर्ण नहीं है।

यहाँ एक उदाहरण है:

[Theory]
[InlineData("Foo")]
[InlineData(9)]
[InlineData(true)]
public void Should_be_assigned_different_values(object value)
{
    Assert.NotNull(value);
}

इस उदाहरण में xUnit प्रत्येक बार Should_format_the_currency_value_correctlyहर बार InlineDataAttributeतर्क के रूप में निर्दिष्ट मान पास करने के लिए परीक्षण चलाएगा ।

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

आप इस बात का एक अच्छा व्यावहारिक उदाहरण पा सकते हैं कि AutoFixture के AutoData और InlineAutoData सिद्धांतों में xUnit के डेटा सिद्धांतों को कैसे बढ़ाया जा सकता है ।

Comments

जाहिर है, यह दशमलव मापदंडों का उपयोग करने के लिए विशेषता मापदंडों के रूप में अनुमति नहीं है ।

— सेर्गी वोल्कोव

@RubenBartelink पर आपका लिंक नहीं मिला। : यहाँ बजाय जाओ blog.benhall.me.uk/2008/01/introduction-to-xunit-net-extensions

— रोनी Overby

आपको xUnit.net की आवश्यकता होगी : एक्सटेंशन (NuGet Package) या अन्यथा [Theory]विशेषता उपलब्ध नहीं है।

— डेनियल एए पल्सेमेकर

यह बहुत अच्छा होगा यदि सबसे अधिक सिफारिश की जाने वाली .NET यूनिट टेस्टिंग फ्रेमवर्क में कुछ दस्तावेज थे ..

— इसहाक क्लेनमैन

Google कहता है कि आपके SO उत्तर xUnit प्रलेखन हैं।

— nathanchere

Answer 2

मुझे एक और नमूना यहाँ फेंकने दो, बस अगर किसी को कुछ समय बचता है तो।

[Theory]
[InlineData("goodnight moon", "moon", true)]
[InlineData("hello world", "hi", false)]
public void Contains(string input, string sub, bool expected)
{
    var actual = input.Contains(sub);
    Assert.Equal(expected, actual);
}

Comments

क्या आप दूसरी पंक्ति में एक समापन कोष्ठक को भूल गए?

— cs0815

उपयोगी, धन्यवाद :)

— Zeek2

Answer 3

अपने पहले अनुरोध पर, आप यहां पाए गए उदाहरणों का अनुसरण कर सकते हैं ।

आप परीक्षणों के संग्रह के लिए आवश्यक डेटा वाले एक स्थिर वर्ग का निर्माण कर सकते हैं

using System.Collections.Generic;

namespace PropertyDataDrivenTests
{
    public static class DemoPropertyDataSource
    {
        private static readonly List<object[]> _data = new List<object[]>
            {
                new object[] {1, true},
                new object[] {2, false},
                new object[] {-1, false},
                new object[] {0, false}
            };

        public static IEnumerable<object[]> TestData
        {
            get { return _data; }
        }
    }
}

फिर, मेम्बरडाटा विशेषता का उपयोग करके, परीक्षण को इस तरह परिभाषित करें

public class TestFile1
{
    [Theory]
    [MemberData("TestData", MemberType = typeof(DemoPropertyDataSource))]
    public void SampleTest1(int number, bool expectedResult)
    {
        var sut = new CheckThisNumber(1);
        var result = sut.CheckIfEqual(number);
        Assert.Equal(result, expectedResult);
    }
}

या यदि आप C # 6.0 का उपयोग कर रहे हैं,

[Theory]
[MemberData(nameof(PropertyDataDrivenTests.TestData), MemberType = typeof(DemoPropertyDataSource))]

MemberDataAttribute का पहला तर्क आपको उस सदस्य को परिभाषित करने की अनुमति देता है जिसे आप डेटा स्रोत के रूप में उपयोग करते हैं, इसलिए आपके पास पुन: उपयोग पर उचित मात्रा में लचीलापन है।

Answer 4

इस लेख के अनुसार xUnit में आपके पास तीन "पैराड्राइज़ेशन" विकल्प हैं:

1. InlineData
2. ClassData
3. MemberData

इनलाइनडाटा उदाहरण

[Theory]
[InlineData(1, 2)]
[InlineData(-4, -6)]
[InlineData(2, 4)]
public void FooTest(int value1, int value2)
{
    Assert.True(value1 + value2 < 7)
}

ClassData उदाहरण

public class BarTestData : IEnumerable<object[]>
{
    public IEnumerator<object[]> GetEnumerator()
    {
        yield return new object[] { 1, 2 };
        yield return new object[] { -4, -6 };
        yield return new object[] { 2, 4 };
    }

    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
}


[Theory]
[ClassData(typeof(BarTestData))]
public void BarTest(int value1, int value2)
{
    Assert.True(value1 + value2 < 7)
}

सदस्यदत्त उदाहरण

[Theory]
[MemberData(nameof(BazTestData))]
public void BazTest(int value1, int value2)
{
    Assert.True(value1 + value2 < 7)
}

public static IEnumerable<object[]> BazTestData => new List<object[]>
    {
        new object[] { 1, 2 },
        new object[] { -4, -6 },
        new object[] { 2, 4 },
    };

Answer 5

मुझे एक लाइब्रेरी मिली, जो Nunnit की एक्सयूनाइट[Values] नामक विशेषता के बराबर कार्यक्षमता पैदा करती है। कॉम्बिनेटरियल :

यह आपको पैरामीटर-स्तर मान निर्दिष्ट करने की अनुमति देता है:

[Theory, CombinatorialData]
public void CheckValidAge([CombinatorialValues(5, 18, 21, 25)] int age, 
    bool friendlyOfficer)
{
    // This will run with all combinations:
    // 5  true
    // 18 true
    // 21 true
    // 25 true
    // 5  false
    // 18 false
    // 21 false
    // 25 false
}

या आप सभी संभावित संयोजनों को कवर करने के लिए न्यूनतम इनवॉइस की संख्या का अनुमान लगा सकते हैं:

[Theory, PairwiseData]
public void CheckValidAge(bool p1, bool p2, bool p3)
{
    // Pairwise generates these 4 test cases:
    // false false false
    // false true  true
    // true  false true
    // true  true  false
}

Answer 6

मैंने यहाँ सभी उत्तरों को लिया और इसके अलावा XUnit के TheoryData<,>सामान्य प्रकारों का उपयोग किया जिससे मुझे सरल, पढ़ने में आसान और मेरे परीक्षण पर 'मेम्बरडाटा' विशेषता के लिए सुरक्षित डेटा परिभाषाएँ टाइप करें, इस उदाहरण के अनुसार:

/// must be public & static for MemberDataAttr to use
public static TheoryData<int, bool, string> DataForTest1 = new TheoryData<int, bool, string> {
    { 1, true, "First" },
    { 2, false, "Second" },
    { 3, true, "Third" }
};

[Theory(DisplayName = "My First Test"), MemberData(nameof(DataForTest1))]
public void Test1(int valA, bool valB, string valC)
{
    Debug.WriteLine($"Running {nameof(Test1)} with values: {valA}, {valB} & {valC} ");
}

---

^{NB कोर का उपयोग VS2017 (15.3.3), C # 7, और .NET कोर के लिए XUnit 2.2.0}

Comments

ये बहुत प्यारी है।

— ब्रेट रोवेबेरी