Parametrierung im Test xUnit.net ähnlich wie NUnit

Sind es bedeutet in xUnit.net Rahmen ähnlich der folgenden Funktionen von NUnit?

[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
}

Generiert diese 8 separate tests in NUnit-GUI

[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"; }

Generiert 5 separate tests und automatisch vergleichen Sie die Ergebnisse (Assert.Equal()).

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

Generiert diese 6 kombinatorische tests. Unbezahlbar.

Paar Jahren habe ich versucht, xUnit und liebte es, doch es fehlte diesen Funktionen. Kann nicht ohne Sie Leben. Hat sich etwas geändert?

InformationsquelleAutor der Frage UserControl | 2012-02-02

.net c#nunit unit-testing xunit.net

106

xUnit bietet eine Möglichkeit zum ausführen von parametrisierte tests durch so genannte Daten Theorien. Das Konzept entspricht dem in NUnit aber die Funktionalität, die Sie bekommen, out of the box ist nicht vollständig.

Hier ein Beispiel:
```
[Theory]
[InlineData("Foo")]
[InlineData(9)]
[InlineData(true)]
public void Should_be_assigned_different_values(object value)
{
    Assert.NotNull(value);
}
```
In diesem Beispiel xUnit laufen die Should_format_the_currency_value_correctly test einmal für jeden InlineDataAttribute jedes mal übergeben wird der angegebene Wert als argument.

Daten Theorien erweiterungspunktdie Sie verwenden können, um neue Möglichkeiten zum ausführen von parametrisierten tests. Die Art und Weise dies geschieht, ist durch neue Attribute erstellen , prüfen und Optional wirken sich auf die Argumente und Rückgabewerte der Methoden testen.

Finden Sie ein gutes praktisches Beispiel, wie xUnit Daten Theorien erweitert werden können in AutoFixture's AutoData und InlineAutoData Theorien.

InformationsquelleAutor der Antwort Enrico Campidoglio

Lassen Sie mich werfen, noch eine Probe hier, nur für den Fall, es spart einige Zeit, um jemanden.

[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);
}

InformationsquelleAutor der Antwort Sevenate

Auf Ihre erste Anfrage, können Sie die Beispiele gefunden hier.

Können Sie konstruieren eine statische Klasse, die die nötigen Daten für eine Sammlung von tests

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; }
        }
    }
}

Dann, mit der MemberData-Attribut, definieren Sie die test als solche

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);
    }
}

oder wenn Sie C# 6.0,

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

Das erste argument MemberDataAttribute können Sie definieren, Mitglied verwenden Sie als Datenquelle, so haben Sie eine Menge Flexibilität auf Wiederverwendung.

InformationsquelleAutor der Antwort LewisM

Fand ich eine Bibliothek, die produziert gleichwertige Funktionalität zu NUnit ist [Values] Attribut namens Xunit.Kombinatorische:

Es ermöglicht Ihnen die Angabe der parameter-Werte:

[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
}

Oder Sie können implizit haben, es herauszufinden, die minimale Anzahl der Aufrufe decken alle möglichen Kombinationen:

[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
}

InformationsquelleAutor der Antwort Adam

Nahm ich auf dem board alle Antworten hier und zusätzlich XUnit ist TheoryData<,> generischen Typen, um mir zu geben, einfach, leicht zu Lesen und geben sicheren Daten die Definitionen für die 'MemberData' - Attribut auf meinem test gemäß diesem Beispiel:

///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} ");
}

Parametrierung im Test xUnit.net ähnlich wie NUnit

^{NB Mit VS2017(15.3.3), C#7, & XUnit-2.2.0 .NET Core}

InformationsquelleAutor der Antwort Peter

Laut dieser Artikel in xUnit, die Sie haben drei "Parametrisierung" Optionen:

InlineData
ClassData
MemberData

InlineData Beispiel

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

ClassData Beispiel

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)
}

MemberData Beispiel

[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 },
    };

InformationsquelleAutor der Antwort itim

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.