NUnit
NUnit
Nunit logo 250.png
NUnit 2.4.6 GUI on Windows
NUnit 2.4.6 GUI on Windows
Developer(s) Charlie Poole
Rob Prouse
Stable release
3.9.0 / 10 November 2017; 11 months ago (2017-11-10)
Repository Edit this at Wikidata
Written in C#
Operating system Microsoft .NET, Mono
Type Unit testing tool
License MIT License for 3.0, BSD-style (modified zlib license) for 2.x
Website www.nunit.org

NUnit is an open-source unit testing framework for Microsoft .NET. It serves the same purpose as JUnit does in the Java world, and is one of many programs in the xUnit family.[]

Features

  • Tests can be run from a console runner, within Visual Studio through a Test Adapter,[1] or through 3rd party runners.
  • Tests can be run in parallel.[2]
  • Strong support for data driven tests.[3]
  • Supports multiple platforms including .NET Core,[4]Xamarin Mobile,[5]Compact Framework[6] and Silverlight.[7]
  • Every test case can be added to one or more categories, to allow for selective running.[8]


NUnit provides a console runner (nunit3-console.exe), which is used for batch execution of tests. The console runner works through the NUnit Test Engine, which provides it with the ability to load, explore and execute tests. When tests are to be run in a separate process, the engine makes use of the nunit-agent program to run them.[]

The NUnitLite runner may be used in situations where a simpler runner is more suitable. It allows developers to create self-executing tests.[]

Assertions

NUnit provides a rich set of assertions as static methods of the Assert class. If an assertion fails, the method call does not return and an error is reported. If a test contains multiple assertions, any that follow the one that failed will not be executed. For this reason, it's usually best to try for one assertion per test.[]

Nunit 3.x is supporting multiple assertions.

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

Classical

Before NUnit 2.4, a separate method of the Assert class was used for each different assertion. It continues to be supported in NUnit, since many people prefer it.[]

Each assert method may be called without a message, with a simple text message or with a message and arguments. In the last case the message is formatted using the provided text and arguments.[]

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

Constraint based

Beginning with NUnit 2.4, a new Constraint-based model was introduced. This approach uses a single method of the Assert class for all assertions, passing a Constraint object that specifies the test to be performed. This constraint-based model is now used internally by NUnit for all assertions. The methods of the classic approach have been re-implemented on top of this new model.[]

Example

Example of an NUnit test fixture:[]

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

The NUnit framework discovers the method ExampleTestOfNUnit.TestMultiplication automatically by reflection.[]

Extensions

FireBenchmarks is an addin able to record execution time of unit tests and generate XML, CSV, XHTML performances reports with charts and history tracking. Its main purpose is to enable a developer or a team that work with an agile methodology to integrate performance metrics and analysis into the unit testing environment, to easily control and monitor the evolution of a software system in terms of algorithmic complexity and system resources load.[]

NUnit.Forms is an expansion to the core NUnit framework and is also open source. It specifically looks at expanding NUnit to be able to handle testing user interface elements in Windows Forms. As of January 2013, Nunit.Forms is in Alpha release, and no versions have been released since May 2006.[]

NUnit.ASP is a discontinued[9] expansion to the core NUnit framework and is also open source. It specifically looks at expanding NUnit to be able to handle testing user interface elements in ASP.Net.[]

See also

References

  1. ^ "NUnit 3 Test Adapter".
  2. ^ "Parallelizable Attribute".
  3. ^ "TestCaseData".
  4. ^ Prouse, Rob (2015-11-04). "Testing .NET Core using NUnit 3".
  5. ^ Prouse, Rob (2015-03-25). "NUnit 3.0 Test Runner for Android and iOS".
  6. ^ "NUnit Version 3 for Compact Framework".
  7. ^ "NUnit Version 3 for SilverLight 5.0".
  8. ^ "CategoryAttribute". Retrieved .
  9. ^ "NUnit.ASP website main page". Sourceforge. Retrieved .

Bibliography

  • Hunt, Andrew; Thomas, David (2007). Pragmatic Unit Testing in C# with NUnit, 2nd Ed. The Pragmatic Bookshelf (Raleigh), 2007. ISBN 0-9776166-7-3.
  • Newkirk, Jim; Vorontsov, Alexei (2004). Test-Driven Development 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.

External links


  This article uses material from the Wikipedia page available here. It is released under the Creative Commons Attribution-Share-Alike License 3.0.

NUnit
 



 

Connect with defaultLogic
What We've Done
Led Digital Marketing Efforts of Top 500 e-Retailers.
Worked with Top Brands at Leading Agencies.
Successfully Managed Over $50 million in Digital Ad Spend.
Developed Strategies and Processes that Enabled Brands to Grow During an Economic Downturn.
Taught Advanced Internet Marketing Strategies at the graduate level.


Manage research, learning and skills at defaultlogic.com. Create an account using LinkedIn to manage and organize your omni-channel knowledge. defaultlogic.com is like a shopping cart for information -- helping you to save, discuss and share.


  Contact Us