NUnit - NUnit

Dieser Artikel befasst sich mit dem C # -Einheitentest-Framework. Informationen zum NGINX-Webanwendungsserver finden Sie unter NGINX-Einheit .
NUnit
Nunit Logo 250.png
NUnit GUI.png
NUnit 2.4.6 GUI unter Windows
Ursprüngliche Autor (en) Charlie Poole, James Newkirk, Alexei Woronzow, Michael Zwei, Philip Craig, Rob Prouse, Simone Busoli, Neil Colvin
Entwickler Das NUnit-Projekt,
.NET Foundation
Stabile Version
3.12.0 / 14. Mai 2019 ; Vor 22 Monaten  ( 2019-05-14 )
Repository Github .com / nunit
Geschrieben in C #
Betriebssystem .NET Framework , Mono
Art Unit-Test- Tool
Lizenz MIT-Lizenz für 3.0, BSD-Stil (modifizierte zlib-Lizenz ) für 2.x.
Webseite www .nunit .org

NUnit ist ein Open-Source- Unit-Test- Framework für .NET Framework und Mono . Es dient demselben Zweck wie JUnit in der Java- Welt und ist eines von vielen Programmen in der xUnit- Familie.

Eigenschaften

  • Tests können von einem Konsolenläufer in Visual Studio über einen Testadapter oder über Läufer von Drittanbietern ausgeführt werden.
  • Tests können parallel ausgeführt werden.
  • Starke Unterstützung für datengesteuerte Tests.
  • Unterstützt mehrere Plattformen, einschließlich .NET Core , Xamarin Mobile , Compact Framework und Silverlight .
  • Jeder Testfall kann einer oder mehreren Kategorien hinzugefügt werden, um ein selektives Ausführen zu ermöglichen.

NUnit bietet einen Konsolenläufer (nunit3-console.exe), der für die Stapelausführung von Tests verwendet wird. Der Konsolenläufer arbeitet mit der NUnit Test Engine, die es ihm ermöglicht, Tests zu laden, zu untersuchen und auszuführen. Wenn Tests in einem separaten Prozess ausgeführt werden sollen, verwendet die Engine das Nunit-Agent-Programm, um sie auszuführen.

Der NUnitLite-Läufer kann in Situationen verwendet werden, in denen ein einfacherer Läufer besser geeignet ist. Entwickler können damit selbstausführende Tests erstellen.

Behauptungen

NUnit bietet eine Vielzahl von Zusicherungen als statische Methoden der Assert Klasse. Wenn eine Zusicherung fehlschlägt, wird der Methodenaufruf nicht zurückgegeben und ein Fehler gemeldet. Wenn ein Test mehrere Zusicherungen enthält, werden alle, die der fehlgeschlagenen folgen, nicht ausgeführt. Aus diesem Grund ist es normalerweise am besten, eine Behauptung pro Test zu erstellen.

Nunit 3.x unterstützt mehrere Behauptungen. 

[Test]
public void ComplexNumberTest()
{
    ComplexNumber result = SomeCalculation();

    Assert.Multiple(() =>
    {
        Assert.AreEqual(5.2, result.RealPart, "Real part");
        Assert.AreEqual(3.9, result.ImaginaryPart, "Imaginary part");
    });
}

Klassik

Vor NUnit 2.4 Assert wurde für jede unterschiedliche Behauptung eine separate Methode der Klasse verwendet. Es wird weiterhin in NUnit unterstützt, da viele Leute es bevorzugen.

Jede Assert-Methode kann ohne Nachricht, mit einer einfachen Textnachricht oder mit einer Nachricht und Argumenten aufgerufen werden. Im letzten Fall wird die Nachricht mit dem bereitgestellten Text und den Argumenten formatiert. 

// Equality asserts
Assert.AreEqual(object expected, object actual);
Assert.AreEqual(object expected, object actual, string message, params object[] parms);

Assert.AreNotEqual(object expected, object actual);
Assert.AreNotEqual(object expected, object actual, string message, params object[] parms);

// Identity asserts
Assert.AreSame(object expected, object actual);
Assert.AreSame(object expected, object actual, string message, params object[] parms);

Assert.AreNotSame(object expected, object actual);
Assert.AreNotSame(object expected, object actual, string message, params object[] parms);

// Condition asserts
// (For simplicity, methods with message signatures are omitted.)
Assert.IsTrue(bool condition);
Assert.IsFalse(bool condition);

Assert.IsNull(object anObject);
Assert.IsNotNull(object anObject);

Assert.IsNaN(double aDouble);

Assert.IsEmpty(string aString);
Assert.IsNotEmpty(string aString);

Assert.IsEmpty(ICollection collection);
Assert.IsNotEmpty(ICollection collection);

Einschränkung basiert

Beginnend mit NUnit 2.4 wurde ein neues Constraint-basiertes Modell eingeführt. Dieser Ansatz verwendet eine einzige Methode der Assert Klasse für alle Zusicherungen und übergibt ein Constraint Objekt, das den durchzuführenden Test angibt. Dieses auf Einschränkungen basierende Modell wird jetzt von NUnit intern für alle Zusicherungen verwendet. Die Methoden des klassischen Ansatzes wurden zusätzlich zu diesem neuen Modell neu implementiert.

Beispiel

Beispiel einer NUnit -Testvorrichtung : 

using NUnit.Framework;
 
[TestFixture]
public class ExampleTestOfNUnit
{
    [Test]
    public void TestMultiplication()
    {
        Assert.AreEqual(4, 2*2, "Multiplication");
        
        // Equivalently, since version 2.4 NUnit offers a new and
        // more intuitive assertion syntax based on constraint objects
        // [http://www.nunit.org/index.php?p=constraintModel&r=2.4.7]:
        Assert.That(2*2, Is.EqualTo(4), "Multiplication constraint-based");
    }
}

// The following example shows different ways of writing the same exception test.

[TestFixture]
public class AssertThrowsTests
{
    [Test]
    public void Tests()
    {
        // .NET 1.x
        Assert.Throws(typeof(ArgumentException),
            new TestDelegate(MethodThatThrows));
	    
        // .NET 2.0
        Assert.Throws<ArgumentException>(MethodThatThrows);
        Assert.Throws<ArgumentException>(
	    delegate { throw new ArgumentException(); });

        // Using C# 3.0	    
        Assert.Throws<ArgumentException>(
            () => { throw new ArgumentException(); });
    }
    
    void MethodThatThrows()
    {
        throw new ArgumentException();
    }
}

// This example shows use of the return value to perform additional verification of the exception.

[TestFixture]
public class UsingReturnValue
{
    [Test]
    public void TestException()
    {
        MyException ex = Assert.Throws<MyException>(
            delegate { throw new MyException("message", 42); });
        Assert.That(ex.Message, Is.EqualTo("message"));
        Assert.That(ex.MyParam, Is.EqualTo(42)); 
    }
}

// This example does the same thing using the overload that includes a constraint.

[TestFixture]
public class UsingConstraint
{
    [Test]
    public void TestException()
    {
        Assert.Throws(Is.Typeof<MyException>()
                                 .And.Message.EqualTo("message")
                                 .And.Property("MyParam").EqualTo(42),
            delegate { throw new MyException("message", 42); });
    }
}

Das NUnit-Framework erkennt die Methode ExampleTestOfNUnit.TestMultiplication() automatisch durch Reflexion .

Erweiterungen

FireBenchmarks ist ein Addin der Lage Aufzeichnung Ausführungszeit von Unit - Tests und generieren XML , CSV , XHTML Performances Berichte mit Diagrammen und Verlaufsverfolgung. Der Hauptzweck besteht darin, einem Entwickler oder einem Team, das mit einer agilen Methodik arbeitet , die Möglichkeit zu geben, Leistungsmetriken und -analysen in die Unit-Test- Umgebung zu integrieren, um die Entwicklung eines Softwaresystems im Hinblick auf die algorithmische Komplexität und die Belastung der Systemressourcen einfach zu steuern und zu überwachen .

NUnit.Forms ist eine Erweiterung des NUnit- Kernframeworks und auch Open Source. Es geht speziell um die Erweiterung von NUnit, um das Testen von Benutzeroberflächenelementen in Windows Forms durchführen zu können . Seit Januar 2013 ist Nunit.Forms in der Alpha-Version und seit Mai 2006 wurden keine Versionen mehr veröffentlicht.

NUnit.ASP ist eine eingestellte Erweiterung des NUnit- Kernframeworks und auch Open Source. Es geht speziell um die Erweiterung von NUnit, um das Testen von Benutzeroberflächenelementen in ASP.Net zu ermöglichen.

Siehe auch

Verweise

Literaturverzeichnis

  • Hunt, Andrew; Thomas, David (2007). Pragmatischer Unit-Test in C # mit NUnit, 2. Aufl. Das Pragmatische Bücherregal (Raleigh), 2007. ISBN   0-9776166-7-3 .
  • Newkirk, Jim; Vorontsov, Alexei (2004). Testgetriebene Entwicklung in Microsoft .NET. Microsoft Press (Redmond), 2004. ISBN   0-7356-1948-4 .
  • Hamilton, Bill (2004). NUnit Pocket Reference . O'Reilly (Cambridge), 2004. ISBN   0-596-00739-6 .

Externe Links