NUnit-2.6.0.12051/ 0000775 0001750 0001750 00000000000 11742560362 013165 5 ustar jtaylor jtaylor NUnit-2.6.0.12051/samples/ 0000775 0001750 0001750 00000000000 11742560362 014631 5 ustar jtaylor jtaylor NUnit-2.6.0.12051/samples/vb/ 0000775 0001750 0001750 00000000000 11742560362 015240 5 ustar jtaylor jtaylor NUnit-2.6.0.12051/samples/vb/money/ 0000775 0001750 0001750 00000000000 11742560362 016367 5 ustar jtaylor jtaylor NUnit-2.6.0.12051/samples/vb/money/vb-money.build 0000664 0001750 0001750 00000000551 11504175260 021140 0 ustar jtaylor jtaylor
NUnit-2.6.0.12051/samples/vb/money/MoneyBag.vb 0000664 0001750 0001750 00000011731 11504175260 020417 0 ustar jtaylor jtaylor ' ****************************************************************
' This is free software licensed under the NUnit license. You
' may obtain a copy of the license as well as information regarding
' copyright ownership at http://nunit.org/?p=license&r=2.4.
' ****************************************************************
Option Explicit On
Namespace NUnit.Samples
Public Class MoneyBag
Implements IMoney
Private fmonies As ArrayList = New ArrayList(5)
Private Sub New()
End Sub
Public Sub New(ByVal bag As Money())
For Each m As Money In bag
If Not m.IsZero Then
AppendMoney(m)
End If
Next
End Sub
Public Sub New(ByVal m1 As Money, ByVal m2 As Money)
AppendMoney(m1)
AppendMoney(m2)
End Sub
Public Sub New(ByVal m As Money, ByVal bag As MoneyBag)
AppendMoney(m)
AppendBag(bag)
End Sub
Public Sub New(ByVal m1 As MoneyBag, ByVal m2 As MoneyBag)
AppendBag(m1)
AppendBag(m2)
End Sub
Public Function Add(ByVal m As IMoney) As IMoney Implements IMoney.Add
Return m.AddMoneyBag(Me)
End Function
Public Function AddMoney(ByVal m As Money) As IMoney Implements IMoney.AddMoney
Return New MoneyBag(m, Me).Simplify
End Function
Public Function AddMoneyBag(ByVal s As MoneyBag) As IMoney Implements IMoney.AddMoneyBag
Return New MoneyBag(s, Me).Simplify()
End Function
Private Sub AppendBag(ByVal aBag As MoneyBag)
For Each m As Money In aBag.fmonies
AppendMoney(m)
Next
End Sub
Private Sub AppendMoney(ByVal aMoney As Money)
Dim old As Money = FindMoney(aMoney.Currency)
If old Is Nothing Then
fmonies.Add(aMoney)
Return
End If
fmonies.Remove(old)
Dim sum As IMoney = old.Add(aMoney)
If (sum.IsZero) Then
Return
End If
fmonies.Add(sum)
End Sub
Private Function Contains(ByVal aMoney As Money) As Boolean
Dim m As Money = FindMoney(aMoney.Currency)
Return m.Amount.Equals(aMoney.Amount)
End Function
Public Overloads Overrides Function Equals(ByVal anObject As Object) As Boolean
If IsZero Then
If TypeOf anObject Is IMoney Then
Dim aMoney As IMoney = anObject
Return aMoney.IsZero
End If
End If
If TypeOf anObject Is MoneyBag Then
Dim aMoneyBag As MoneyBag = anObject
If Not aMoneyBag.fmonies.Count.Equals(fmonies.Count) Then
Return False
End If
For Each m As Money In fmonies
If Not aMoneyBag.Contains(m) Then
Return False
End If
Return True
Next
End If
Return False
End Function
Private Function FindMoney(ByVal currency As String) As Money
For Each m As Money In fmonies
If m.Currency.Equals(currency) Then
Return m
End If
Next
Return Nothing
End Function
Public Overrides Function GetHashCode() As Int32
Dim hash As Int32 = 0
For Each m As Money In fmonies
hash += m.GetHashCode()
Next
Return hash
End Function
Public ReadOnly Property IsZero() As Boolean Implements IMoney.IsZero
Get
Return fmonies.Count.Equals(0)
End Get
End Property
Public Function Multiply(ByVal factor As Integer) As IMoney Implements IMoney.Multiply
Dim result As New MoneyBag
If Not factor.Equals(0) Then
For Each m As Money In fmonies
result.AppendMoney(m.Multiply(factor))
Next
End If
Return result
End Function
Public Function Negate() As IMoney Implements IMoney.Negate
Dim result As New MoneyBag
For Each m As Money In fmonies
result.AppendMoney(m.Negate())
Next
Return result
End Function
Private Function Simplify() As IMoney
If fmonies.Count.Equals(1) Then
Return fmonies(0)
End If
Return Me
End Function
Public Function Subtract(ByVal m As IMoney) As IMoney Implements IMoney.Subtract
Return Add(m.Negate())
End Function
End Class
End Namespace
NUnit-2.6.0.12051/samples/vb/money/MoneyTest.vb 0000664 0001750 0001750 00000016761 11504175260 020655 0 ustar jtaylor jtaylor ' ****************************************************************
' This is free software licensed under the NUnit license. You
' may obtain a copy of the license as well as information regarding
' copyright ownership at http://nunit.org/?p=license&r=2.4.
' ****************************************************************
Option Explicit On
Imports System
Imports NUnit.Framework
Namespace NUnit.Samples
_
Public Class MoneyTest
Private f12CHF As Money
Private f14CHF As Money
Private f7USD As Money
Private f21USD As Money
Private fMB1 As MoneyBag
Private fMB2 As MoneyBag
_
Protected Sub SetUp()
f12CHF = New Money(12, "CHF")
f14CHF = New Money(14, "CHF")
f7USD = New Money(7, "USD")
f21USD = New Money(21, "USD")
fMB1 = New MoneyBag(f12CHF, f7USD)
fMB2 = New MoneyBag(f14CHF, f21USD)
End Sub
_
Public Sub BagMultiply()
' {[12 CHF][7 USD]} *2 == {[24 CHF][14 USD]}
Dim bag() As Money = New Money() {New Money(24, "CHF"), New Money(14, "USD")}
Dim expected As New MoneyBag(bag)
Assert.AreEqual(expected, fMB1.Multiply(2))
Assert.AreEqual(fMB1, fMB1.Multiply(1))
Assert.IsTrue(fMB1.Multiply(0).IsZero)
End Sub
_
Public Sub BagNegate()
' {[12 CHF][7 USD]} negate == {[-12 CHF][-7 USD]}
Dim bag() As Money = New Money() {New Money(-12, "CHF"), New Money(-7, "USD")}
Dim expected As New MoneyBag(bag)
Assert.AreEqual(expected, fMB1.Negate())
End Sub
_
Public Sub BagSimpleAdd()
' {[12 CHF][7 USD]} + [14 CHF] == {[26 CHF][7 USD]}
Dim bag() As Money = New Money() {New Money(26, "CHF"), New Money(7, "USD")}
Dim expected As New MoneyBag(bag)
Assert.AreEqual(expected, fMB1.Add(f14CHF))
End Sub
_
Public Sub BagSubtract()
' {[12 CHF][7 USD]} - {[14 CHF][21 USD] == {[-2 CHF][-14 USD]}
Dim bag() As Money = New Money() {New Money(-2, "CHF"), New Money(-14, "USD")}
Dim expected As New MoneyBag(bag)
Assert.AreEqual(expected, fMB1.Subtract(fMB2))
End Sub
_
Public Sub BagSumAdd()
' {[12 CHF][7 USD]} + {[14 CHF][21 USD]} == {[26 CHF][28 USD]}
Dim bag() As Money = New Money() {New Money(26, "CHF"), New Money(28, "USD")}
Dim expected As New MoneyBag(bag)
Assert.AreEqual(expected, fMB1.Add(fMB2))
End Sub
_
Public Sub IsZero()
Assert.IsTrue(fMB1.Subtract(fMB1).IsZero)
Dim bag() As Money = New Money() {New Money(0, "CHF"), New Money(0, "USD")}
Assert.IsTrue(New MoneyBag(bag).IsZero)
End Sub
_
Public Sub MixedSimpleAdd()
' [12 CHF] + [7 USD] == {[12 CHF][7 USD]}
Dim bag() As Money = New Money() {f12CHF, f7USD}
Dim expected As New MoneyBag(bag)
Assert.AreEqual(expected, f12CHF.Add(f7USD))
End Sub
_
Public Sub MoneyBagEquals()
' NOTE: Normally we use Assert.AreEqual to test whether two
' objects are equal. But here we are testing the MoneyBag.Equals()
' method itself, so using AreEqual would not serve the purpose.
Assert.IsFalse(fMB1.Equals(Nothing))
Assert.IsTrue(fMB1.Equals(fMB1))
Dim equal As MoneyBag = New MoneyBag(New Money(12, "CHF"), New Money(7, "USD"))
Assert.IsTrue(fMB1.Equals(equal))
Assert.IsFalse(fMB1.Equals(f12CHF))
Assert.IsFalse(f12CHF.Equals(fMB1))
Assert.IsFalse(fMB1.Equals(fMB2))
End Sub
_
Public Sub MoneyBagHash()
Dim equal As MoneyBag = New MoneyBag(New Money(12, "CHF"), New Money(7, "USD"))
Assert.AreEqual(fMB1.GetHashCode(), equal.GetHashCode())
End Sub
_
Public Sub MoneyEquals()
' NOTE: Normally we use Assert.AreEqual to test whether two
' objects are equal. But here we are testing the MoneyBag.Equals()
' method itself, so using AreEqual would not serve the purpose.
Assert.IsFalse(f12CHF.Equals(Nothing))
Dim equalMoney As Money = New Money(12, "CHF")
Assert.IsTrue(f12CHF.Equals(f12CHF))
Assert.IsTrue(f12CHF.Equals(equalMoney))
Assert.IsFalse(f12CHF.Equals(f14CHF))
End Sub
_
Public Sub MoneyHash()
Assert.IsFalse(f12CHF.Equals(Nothing))
Dim equal As Money = New Money(12, "CHF")
Assert.AreEqual(f12CHF.GetHashCode(), equal.GetHashCode())
End Sub
_
Public Sub Normalize()
Dim bag() As Money = New Money() {New Money(26, "CHF"), New Money(28, "CHF"), New Money(6, "CHF")}
Dim moneyBag As New MoneyBag(bag)
Dim expected() As Money = New Money() {New Money(60, "CHF")}
' // note: expected is still a MoneyBag
Dim expectedBag As New MoneyBag(expected)
Assert.AreEqual(expectedBag, moneyBag)
End Sub
_
Public Sub Normalize2()
' {[12 CHF][7 USD]} - [12 CHF] == [7 USD]
Dim expected As Money = New Money(7, "USD")
Assert.AreEqual(expected, fMB1.Subtract(f12CHF))
End Sub
_
Public Sub Normalize3()
' {[12 CHF][7 USD]} - {[12 CHF][3 USD]} == [4 USD]
Dim s1() As Money = New Money() {New Money(12, "CHF"), New Money(3, "USD")}
Dim ms1 As New MoneyBag(s1)
Dim expected As New Money(4, "USD")
Assert.AreEqual(expected, fMB1.Subtract(ms1))
End Sub
_
Public Sub Normalize4()
' [12 CHF] - {[12 CHF][3 USD]} == [-3 USD]
Dim s1() As Money = New Money() {New Money(12, "CHF"), New Money(3, "USD")}
Dim ms1 As New MoneyBag(s1)
Dim expected As New Money(-3, "USD")
Assert.AreEqual(expected, f12CHF.Subtract(ms1))
End Sub
_
Public Sub Print()
Assert.AreEqual("[12 CHF]", f12CHF.ToString())
End Sub
_
Public Sub SimpleAdd()
' [12 CHF] + [14 CHF] == [26 CHF]
Dim expected As Money = New Money(26, "CHF")
Assert.AreEqual(expected, f12CHF.Add(f14CHF))
End Sub
_
Public Sub SimpleNegate()
' [14 CHF] negate == [-14 CHF]
Dim expected As New Money(-14, "CHF")
Assert.AreEqual(expected, f14CHF.Negate())
End Sub
_
Public Sub SimpleSubtract()
' [14 CHF] - [12 CHF] == [2 CHF]
Dim expected As New Money(2, "CHF")
Assert.AreEqual(expected, f14CHF.Subtract(f12CHF))
End Sub
_
Public Sub SimpleMultiply()
' [14 CHF] *2 == [28 CHF]
Dim expected As New Money(28, "CHF")
Assert.AreEqual(expected, f14CHF.Multiply(2))
End Sub
End Class
End Namespace
NUnit-2.6.0.12051/samples/vb/money/Money.vb 0000664 0001750 0001750 00000006425 11504175260 020011 0 ustar jtaylor jtaylor ' ****************************************************************
' This is free software licensed under the NUnit license. You
' may obtain a copy of the license as well as information regarding
' copyright ownership at http://nunit.org/?p=license&r=2.4.
' ****************************************************************
Option Explicit On
Namespace NUnit.Samples
' A Simple Money.
Public Class Money
Implements IMoney
Private fAmount As Int32
Private fCurrency As String
' Constructs a money from a given amount and currency.
Public Sub New(ByVal amount As Int32, ByVal currency As String)
Me.fAmount = amount
Me.fCurrency = currency
End Sub
' Adds a money to this money. Forwards the request
' to the AddMoney helper.
Public Overloads Function Add(ByVal m As IMoney) As IMoney Implements IMoney.Add
Return m.AddMoney(Me)
End Function
Public Overloads Function AddMoney(ByVal m As Money) As IMoney Implements IMoney.AddMoney
If m.Currency.Equals(Currency) Then
Return New Money(Amount + m.Amount, Currency)
End If
Return New MoneyBag(Me, m)
End Function
Public Function AddMoneyBag(ByVal s As MoneyBag) As IMoney Implements IMoney.AddMoneyBag
Return s.AddMoney(Me)
End Function
Public ReadOnly Property Amount() As Integer
Get
Return fAmount
End Get
End Property
Public ReadOnly Property Currency() As String
Get
Return fCurrency
End Get
End Property
Public Overloads Overrides Function Equals(ByVal anObject As Object) As Boolean
If IsZero And TypeOf anObject Is IMoney Then
Dim aMoney As IMoney = anObject
Return aMoney.IsZero
End If
If TypeOf anObject Is Money Then
Dim aMoney As Money = anObject
If (IsZero) Then
Return aMoney.IsZero
End If
Return Currency.Equals(aMoney.Currency) And Amount.Equals(aMoney.Amount)
End If
Return False
End Function
Public Overrides Function GetHashCode() As Int32
Return fCurrency.GetHashCode() + fAmount
End Function
Public ReadOnly Property IsZero() As Boolean Implements IMoney.IsZero
Get
Return Amount.Equals(0)
End Get
End Property
Public Function Multiply(ByVal factor As Integer) As IMoney Implements IMoney.Multiply
Return New Money(Amount * factor, Currency)
End Function
Public Function Negate() As IMoney Implements IMoney.Negate
Return New Money(-Amount, Currency)
End Function
Public Function Subtract(ByVal m As IMoney) As IMoney Implements IMoney.Subtract
Return Add(m.Negate())
End Function
Public Overrides Function ToString() As String
Return String.Format("[{0} {1}]", Amount, Currency)
End Function
End Class
End Namespace
NUnit-2.6.0.12051/samples/vb/money/AssemblyInfo.vb 0000664 0001750 0001750 00000002024 11504175260 021304 0 ustar jtaylor jtaylor Imports System
Imports System.Reflection
Imports System.Runtime.InteropServices
' General Information about an assembly is controlled through the following
' set of attributes. Change these attribute values to modify the information
' associated with an assembly.
' Review the values of the assembly attributes
'The following GUID is for the ID of the typelib if this project is exposed to COM
' Version information for an assembly consists of the following four values:
'
' Major Version
' Minor Version
' Build Number
' Revision
'
' You can specify all the values or you can default the Build and Revision Numbers
' by using the '*' as shown below:
NUnit-2.6.0.12051/samples/vb/money/vb-money.vbproj 0000664 0001750 0001750 00000004241 11720516414 021343 0 ustar jtaylor jtaylor NUnit-2.6.0.12051/samples/vb/money/IMoney.vb 0000664 0001750 0001750 00000002410 11504175260 020110 0 ustar jtaylor jtaylor ' ****************************************************************
' This is free software licensed under the NUnit license. You
' may obtain a copy of the license as well as information regarding
' copyright ownership at http://nunit.org/?p=license&r=2.4.
' ****************************************************************
Namespace NUnit.Samples
'The common interface for simple Monies and MoneyBags.
Public Interface IMoney
'Adds a money to this money
Function Add(ByVal m As IMoney) As IMoney
'Adds a simple Money to this money. This is a helper method for
'implementing double dispatch.
Function AddMoney(ByVal m As Money) As IMoney
'Adds a MoneyBag to this money. This is a helper method for
'implementing double dispatch.
Function AddMoneyBag(ByVal s As MoneyBag) As IMoney
'True if this money is zero.
ReadOnly Property IsZero() As Boolean
'Multiplies a money by the given factor.
Function Multiply(ByVal factor As Int32) As IMoney
'Negates this money.
Function Negate() As IMoney
'Subtracts a money from this money.
Function Subtract(ByVal m As IMoney) As IMoney
End Interface
End Namespace
NUnit-2.6.0.12051/samples/vb/syntax/ 0000775 0001750 0001750 00000000000 11742560362 016566 5 ustar jtaylor jtaylor NUnit-2.6.0.12051/samples/vb/syntax/vb-syntax.build 0000664 0001750 0001750 00000000415 11504175260 021535 0 ustar jtaylor jtaylor
NUnit-2.6.0.12051/samples/vb/syntax/AssertSyntaxTests.vb 0000664 0001750 0001750 00000065233 11504175260 022616 0 ustar jtaylor jtaylor ' ****************************************************************
' Copyright 2007, Charlie Poole
' This is free software licensed under the NUnit license. You may
' obtain a copy of the license at http:'nunit.org/?p=license&r=2.4
' ****************************************************************
Option Explicit On
Imports System
Imports NUnit.Framework
Imports NUnit.Framework.Constraints
Imports Text = NUnit.Framework.Text
Namespace NUnit.Samples
' This test fixture attempts to exercise all the syntactic
' variations of Assert without getting into failures, errors
' or corner cases. Thus, some of the tests may be duplicated
' in other fixtures.
'
' Each test performs the same operations using the classic
' syntax (if available) and the new syntax in both the
' helper-based and inherited forms.
'
' This Fixture will eventually be duplicated in other
' supported languages.
_
Public Class AssertSyntaxTests
Inherits AssertionHelper
#Region "Simple Constraint Tests"
_
Public Sub IsNull()
Dim nada As Object = Nothing
' Classic syntax
Assert.IsNull(nada)
' Helper syntax
Assert.That(nada, Iz.Null)
' Inherited syntax
Expect(nada, Null)
End Sub
_
Public Sub IsNotNull()
' Classic syntax
Assert.IsNotNull(42)
' Helper syntax
Assert.That(42, Iz.Not.Null)
' Inherited syntax
Expect(42, Iz.Not.Null)
End Sub
_
Public Sub IsTrue()
' Classic syntax
Assert.IsTrue(2 + 2 = 4)
' Helper syntax
Assert.That(2 + 2 = 4, Iz.True)
Assert.That(2 + 2 = 4)
' Inherited syntax
Expect(2 + 2 = 4, Iz.True)
Expect(2 + 2 = 4)
End Sub
_
Public Sub IsFalse()
' Classic syntax
Assert.IsFalse(2 + 2 = 5)
' Helper syntax
Assert.That(2 + 2 = 5, Iz.False)
' Inherited syntax
Expect(2 + 2 = 5, Iz.False)
End Sub
_
Public Sub IsNaN()
Dim d As Double = Double.NaN
Dim f As Single = Single.NaN
' Classic syntax
Assert.IsNaN(d)
Assert.IsNaN(f)
' Helper syntax
Assert.That(d, Iz.NaN)
Assert.That(f, Iz.NaN)
' Inherited syntax
Expect(d, NaN)
Expect(f, NaN)
End Sub
_
Public Sub EmptyStringTests()
' Classic syntax
Assert.IsEmpty("")
Assert.IsNotEmpty("Hello!")
' Helper syntax
Assert.That("", Iz.Empty)
Assert.That("Hello!", Iz.Not.Empty)
' Inherited syntax
Expect("", Empty)
Expect("Hello!", Iz.Not.Empty)
End Sub
_
Public Sub EmptyCollectionTests()
Dim boolArray As Boolean() = New Boolean() {}
Dim nonEmpty As Integer() = New Integer() {1, 2, 3}
' Classic syntax
Assert.IsEmpty(boolArray)
Assert.IsNotEmpty(nonEmpty)
' Helper syntax
Assert.That(boolArray, Iz.Empty)
Assert.That(nonEmpty, Iz.Not.Empty)
' Inherited syntax
Expect(boolArray, Iz.Empty)
Expect(nonEmpty, Iz.Not.Empty)
End Sub
#End Region
#Region "TypeConstraint Tests"
_
Public Sub ExactTypeTests()
' Classic syntax workarounds
Assert.AreEqual(GetType(String), "Hello".GetType())
Assert.AreEqual("System.String", "Hello".GetType().FullName)
Assert.AreNotEqual(GetType(Integer), "Hello".GetType())
Assert.AreNotEqual("System.Int32", "Hello".GetType().FullName)
' Helper syntax
Assert.That("Hello", Iz.TypeOf(GetType(String)))
Assert.That("Hello", Iz.Not.TypeOf(GetType(Integer)))
' Inherited syntax
Expect("Hello", Iz.TypeOf(GetType(String)))
Expect("Hello", Iz.Not.TypeOf(GetType(Integer)))
End Sub
_
Public Sub InstanceOfTypeTests()
' Classic syntax
Assert.IsInstanceOf(GetType(String), "Hello")
Assert.IsNotInstanceOf(GetType(String), 5)
' Helper syntax
Assert.That("Hello", Iz.InstanceOf(GetType(String)))
Assert.That(5, Iz.Not.InstanceOf(GetType(String)))
' Inherited syntax
Expect("Hello", InstanceOf(GetType(String)))
Expect(5, Iz.Not.InstanceOf(GetType(String)))
End Sub
_
Public Sub AssignableFromTypeTests()
' Classic syntax
Assert.IsAssignableFrom(GetType(String), "Hello")
Assert.IsNotAssignableFrom(GetType(String), 5)
' Helper syntax
Assert.That("Hello", Iz.AssignableFrom(GetType(String)))
Assert.That(5, Iz.Not.AssignableFrom(GetType(String)))
' Inherited syntax
Expect("Hello", AssignableFrom(GetType(String)))
Expect(5, Iz.Not.AssignableFrom(GetType(String)))
End Sub
#End Region
#Region "StringConstraintTests"
_
Public Sub SubstringTests()
Dim phrase As String = "Hello World!"
Dim array As String() = New String() {"abc", "bad", "dba"}
' Classic Syntax
StringAssert.Contains("World", phrase)
' Helper syntax
Assert.That(phrase, Text.Contains("World"))
' Only available using new syntax
Assert.That(phrase, Text.DoesNotContain("goodbye"))
Assert.That(phrase, Text.Contains("WORLD").IgnoreCase)
Assert.That(phrase, Text.DoesNotContain("BYE").IgnoreCase)
Assert.That(array, Text.All.Contains("b"))
' Inherited syntax
Expect(phrase, Contains("World"))
' Only available using new syntax
Expect(phrase, Text.DoesNotContain("goodbye"))
Expect(phrase, Contains("WORLD").IgnoreCase)
Expect(phrase, Text.DoesNotContain("BYE").IgnoreCase)
Expect(array, All.Contains("b"))
End Sub
_
Public Sub StartsWithTests()
Dim phrase As String = "Hello World!"
Dim greetings As String() = New String() {"Hello!", "Hi!", "Hola!"}
' Classic syntax
StringAssert.StartsWith("Hello", phrase)
' Helper syntax
Assert.That(phrase, Text.StartsWith("Hello"))
' Only available using new syntax
Assert.That(phrase, Text.DoesNotStartWith("Hi!"))
Assert.That(phrase, Text.StartsWith("HeLLo").IgnoreCase)
Assert.That(phrase, Text.DoesNotStartWith("HI").IgnoreCase)
Assert.That(greetings, Text.All.StartsWith("h").IgnoreCase)
' Inherited syntax
Expect(phrase, StartsWith("Hello"))
' Only available using new syntax
Expect(phrase, Text.DoesNotStartWith("Hi!"))
Expect(phrase, StartsWith("HeLLo").IgnoreCase)
Expect(phrase, Text.DoesNotStartWith("HI").IgnoreCase)
Expect(greetings, All.StartsWith("h").IgnoreCase)
End Sub
_
Public Sub EndsWithTests()
Dim phrase As String = "Hello World!"
Dim greetings As String() = New String() {"Hello!", "Hi!", "Hola!"}
' Classic Syntax
StringAssert.EndsWith("!", phrase)
' Helper syntax
Assert.That(phrase, Text.EndsWith("!"))
' Only available using new syntax
Assert.That(phrase, Text.DoesNotEndWith("?"))
Assert.That(phrase, Text.EndsWith("WORLD!").IgnoreCase)
Assert.That(greetings, Text.All.EndsWith("!"))
' Inherited syntax
Expect(phrase, EndsWith("!"))
' Only available using new syntax
Expect(phrase, Text.DoesNotEndWith("?"))
Expect(phrase, EndsWith("WORLD!").IgnoreCase)
Expect(greetings, All.EndsWith("!"))
End Sub
_
Public Sub EqualIgnoringCaseTests()
Dim phrase As String = "Hello World!"
Dim array1 As String() = New String() {"Hello", "World"}
Dim array2 As String() = New String() {"HELLO", "WORLD"}
Dim array3 As String() = New String() {"HELLO", "Hello", "hello"}
' Classic syntax
StringAssert.AreEqualIgnoringCase("hello world!", phrase)
' Helper syntax
Assert.That(phrase, Iz.EqualTo("hello world!").IgnoreCase)
'Only available using new syntax
Assert.That(phrase, Iz.Not.EqualTo("goodbye world!").IgnoreCase)
Assert.That(array1, Iz.EqualTo(array2).IgnoreCase)
Assert.That(array3, Iz.All.EqualTo("hello").IgnoreCase)
' Inherited syntax
Expect(phrase, EqualTo("hello world!").IgnoreCase)
'Only available using new syntax
Expect(phrase, Iz.Not.EqualTo("goodbye world!").IgnoreCase)
Expect(array1, EqualTo(array2).IgnoreCase)
Expect(array3, All.EqualTo("hello").IgnoreCase)
End Sub
_
Public Sub RegularExpressionTests()
Dim phrase As String = "Now is the time for all good men to come to the aid of their country."
Dim quotes As String() = New String() {"Never say never", "It's never too late", "Nevermore!"}
' Classic syntax
StringAssert.IsMatch("all good men", phrase)
StringAssert.IsMatch("Now.*come", phrase)
' Helper syntax
Assert.That(phrase, Text.Matches("all good men"))
Assert.That(phrase, Text.Matches("Now.*come"))
' Only available using new syntax
Assert.That(phrase, Text.DoesNotMatch("all.*men.*good"))
Assert.That(phrase, Text.Matches("ALL").IgnoreCase)
Assert.That(quotes, Text.All.Matches("never").IgnoreCase)
' Inherited syntax
Expect(phrase, Matches("all good men"))
Expect(phrase, Matches("Now.*come"))
' Only available using new syntax
Expect(phrase, Text.DoesNotMatch("all.*men.*good"))
Expect(phrase, Matches("ALL").IgnoreCase)
Expect(quotes, All.Matches("never").IgnoreCase)
End Sub
#End Region
#Region "Equality Tests"
_
Public Sub EqualityTests()
Dim i3 As Integer() = {1, 2, 3}
Dim d3 As Double() = {1.0, 2.0, 3.0}
Dim iunequal As Integer() = {1, 3, 2}
' Classic Syntax
Assert.AreEqual(4, 2 + 2)
Assert.AreEqual(i3, d3)
Assert.AreNotEqual(5, 2 + 2)
Assert.AreNotEqual(i3, iunequal)
' Helper syntax
Assert.That(2 + 2, Iz.EqualTo(4))
Assert.That(2 + 2 = 4)
Assert.That(i3, Iz.EqualTo(d3))
Assert.That(2 + 2, Iz.Not.EqualTo(5))
Assert.That(i3, Iz.Not.EqualTo(iunequal))
' Inherited syntax
Expect(2 + 2, EqualTo(4))
Expect(2 + 2 = 4)
Expect(i3, EqualTo(d3))
Expect(2 + 2, Iz.Not.EqualTo(5))
Expect(i3, Iz.Not.EqualTo(iunequal))
End Sub
_
Public Sub EqualityTestsWithTolerance()
' CLassic syntax
Assert.AreEqual(5.0R, 4.99R, 0.05R)
Assert.AreEqual(5.0F, 4.99F, 0.05F)
' Helper syntax
Assert.That(4.99R, Iz.EqualTo(5.0R).Within(0.05R))
Assert.That(4D, Iz.Not.EqualTo(5D).Within(0.5D))
Assert.That(4.99F, Iz.EqualTo(5.0F).Within(0.05F))
Assert.That(4.99D, Iz.EqualTo(5D).Within(0.05D))
Assert.That(499, Iz.EqualTo(500).Within(5))
Assert.That(4999999999L, Iz.EqualTo(5000000000L).Within(5L))
' Inherited syntax
Expect(4.99R, EqualTo(5.0R).Within(0.05R))
Expect(4D, Iz.Not.EqualTo(5D).Within(0.5D))
Expect(4.99F, EqualTo(5.0F).Within(0.05F))
Expect(4.99D, EqualTo(5D).Within(0.05D))
Expect(499, EqualTo(500).Within(5))
Expect(4999999999L, EqualTo(5000000000L).Within(5L))
End Sub
_
Public Sub EqualityTestsWithTolerance_MixedFloatAndDouble()
' Bug Fix 1743844
Assert.That(2.20492R, Iz.EqualTo(2.2R).Within(0.01F), _
"Double actual, Double expected, Single tolerance")
Assert.That(2.20492R, Iz.EqualTo(2.2F).Within(0.01R), _
"Double actual, Single expected, Double tolerance")
Assert.That(2.20492R, Iz.EqualTo(2.2F).Within(0.01F), _
"Double actual, Single expected, Single tolerance")
Assert.That(2.20492F, Iz.EqualTo(2.2F).Within(0.01R), _
"Single actual, Single expected, Double tolerance")
Assert.That(2.20492F, Iz.EqualTo(2.2R).Within(0.01R), _
"Single actual, Double expected, Double tolerance")
Assert.That(2.20492F, Iz.EqualTo(2.2R).Within(0.01F), _
"Single actual, Double expected, Single tolerance")
End Sub
_
Public Sub EqualityTestsWithTolerance_MixingTypesGenerally()
' Extending tolerance to all numeric types
Assert.That(202.0R, Iz.EqualTo(200.0R).Within(2), _
"Double actual, Double expected, int tolerance")
Assert.That(4.87D, Iz.EqualTo(5).Within(0.25R), _
"Decimal actual, int expected, Double tolerance")
Assert.That(4.87D, Iz.EqualTo(5L).Within(1), _
"Decimal actual, long expected, int tolerance")
Assert.That(487, Iz.EqualTo(500).Within(25), _
"int actual, int expected, int tolerance")
Assert.That(487L, Iz.EqualTo(500).Within(25), _
"long actual, int expected, int tolerance")
End Sub
#End Region
#Region "Comparison Tests"
_
Public Sub ComparisonTests()
' Classic Syntax
Assert.Greater(7, 3)
Assert.GreaterOrEqual(7, 3)
Assert.GreaterOrEqual(7, 7)
' Helper syntax
Assert.That(7, Iz.GreaterThan(3))
Assert.That(7, Iz.GreaterThanOrEqualTo(3))
Assert.That(7, Iz.AtLeast(3))
Assert.That(7, Iz.GreaterThanOrEqualTo(7))
Assert.That(7, Iz.AtLeast(7))
' Inherited syntax
Expect(7, GreaterThan(3))
Expect(7, GreaterThanOrEqualTo(3))
Expect(7, AtLeast(3))
Expect(7, GreaterThanOrEqualTo(7))
Expect(7, AtLeast(7))
' Classic syntax
Assert.Less(3, 7)
Assert.LessOrEqual(3, 7)
Assert.LessOrEqual(3, 3)
' Helper syntax
Assert.That(3, Iz.LessThan(7))
Assert.That(3, Iz.LessThanOrEqualTo(7))
Assert.That(3, Iz.AtMost(7))
Assert.That(3, Iz.LessThanOrEqualTo(3))
Assert.That(3, Iz.AtMost(3))
' Inherited syntax
Expect(3, LessThan(7))
Expect(3, LessThanOrEqualTo(7))
Expect(3, AtMost(7))
Expect(3, LessThanOrEqualTo(3))
Expect(3, AtMost(3))
End Sub
#End Region
#Region "Collection Tests"
_
Public Sub AllItemsTests()
Dim ints As Object() = {1, 2, 3, 4}
Dim doubles As Object() = {0.99, 2.1, 3.0, 4.05}
Dim strings As Object() = {"abc", "bad", "cab", "bad", "dad"}
' Classic syntax
CollectionAssert.AllItemsAreNotNull(ints)
CollectionAssert.AllItemsAreInstancesOfType(ints, GetType(Integer))
CollectionAssert.AllItemsAreInstancesOfType(strings, GetType(String))
CollectionAssert.AllItemsAreUnique(ints)
' Helper syntax
Assert.That(ints, Iz.All.Not.Null)
Assert.That(ints, Has.None.Null)
Assert.That(ints, Iz.All.InstanceOfType(GetType(Integer)))
Assert.That(ints, Has.All.InstanceOfType(GetType(Integer)))
Assert.That(strings, Iz.All.InstanceOfType(GetType(String)))
Assert.That(strings, Has.All.InstanceOfType(GetType(String)))
Assert.That(ints, Iz.Unique)
' Only available using new syntax
Assert.That(strings, Iz.Not.Unique)
Assert.That(ints, Iz.All.GreaterThan(0))
Assert.That(ints, Has.All.GreaterThan(0))
Assert.That(ints, Has.None.LessThanOrEqualTo(0))
Assert.That(strings, Text.All.Contains("a"))
Assert.That(strings, Has.All.Contains("a"))
Assert.That(strings, Has.Some.StartsWith("ba"))
Assert.That(strings, Has.Some.Property("Length").EqualTo(3))
Assert.That(strings, Has.Some.StartsWith("BA").IgnoreCase)
Assert.That(doubles, Has.Some.EqualTo(1.0).Within(0.05))
' Inherited syntax
Expect(ints, All.Not.Null)
Expect(ints, None.Null)
Expect(ints, All.InstanceOfType(GetType(Integer)))
Expect(strings, All.InstanceOfType(GetType(String)))
Expect(ints, Unique)
' Only available using new syntax
Expect(strings, Iz.Not.Unique)
Expect(ints, All.GreaterThan(0))
Expect(strings, All.Contains("a"))
Expect(strings, Some.StartsWith("ba"))
Expect(strings, Some.StartsWith("BA").IgnoreCase)
Expect(doubles, Some.EqualTo(1.0).Within(0.05))
End Sub
_
Public Sub SomeItemsTests()
Dim mixed As Object() = {1, 2, "3", Nothing, "four", 100}
Dim strings As Object() = {"abc", "bad", "cab", "bad", "dad"}
' Not available using the classic syntax
' Helper syntax
Assert.That(mixed, Has.Some.Null)
Assert.That(mixed, Has.Some.InstanceOfType(GetType(Integer)))
Assert.That(mixed, Has.Some.InstanceOfType(GetType(String)))
Assert.That(strings, Has.Some.StartsWith("ba"))
Assert.That(strings, Has.Some.Not.StartsWith("ba"))
' Inherited syntax
Expect(mixed, Some.Null)
Expect(mixed, Some.InstanceOfType(GetType(Integer)))
Expect(mixed, Some.InstanceOfType(GetType(String)))
Expect(strings, Some.StartsWith("ba"))
Expect(strings, Some.Not.StartsWith("ba"))
End Sub
_
Public Sub NoItemsTests()
Dim ints As Object() = {1, 2, 3, 4, 5}
Dim strings As Object() = {"abc", "bad", "cab", "bad", "dad"}
' Not available using the classic syntax
' Helper syntax
Assert.That(ints, Has.None.Null)
Assert.That(ints, Has.None.InstanceOfType(GetType(String)))
Assert.That(ints, Has.None.GreaterThan(99))
Assert.That(strings, Has.None.StartsWith("qu"))
' Inherited syntax
Expect(ints, None.Null)
Expect(ints, None.InstanceOfType(GetType(String)))
Expect(ints, None.GreaterThan(99))
Expect(strings, None.StartsWith("qu"))
End Sub
_
Public Sub CollectionContainsTests()
Dim iarray As Integer() = {1, 2, 3}
Dim sarray As String() = {"a", "b", "c"}
' Classic syntax
Assert.Contains(3, iarray)
Assert.Contains("b", sarray)
CollectionAssert.Contains(iarray, 3)
CollectionAssert.Contains(sarray, "b")
CollectionAssert.DoesNotContain(sarray, "x")
' Showing that Contains uses NUnit equality
CollectionAssert.Contains(iarray, 1.0R)
' Helper syntax
Assert.That(iarray, Has.Member(3))
Assert.That(sarray, Has.Member("b"))
Assert.That(sarray, Has.No.Member("x"))
' Showing that Contains uses NUnit equality
Assert.That(iarray, Has.Member(1.0R))
' Only available using the new syntax
' Note that EqualTo and SameAs do NOT give
' identical results to Contains because
' Contains uses Object.Equals()
Assert.That(iarray, Has.Some.EqualTo(3))
Assert.That(iarray, Has.Member(3))
Assert.That(sarray, Has.Some.EqualTo("b"))
Assert.That(sarray, Has.None.EqualTo("x"))
Assert.That(iarray, Has.None.SameAs(1.0R))
Assert.That(iarray, Has.All.LessThan(10))
Assert.That(sarray, Has.All.Length.EqualTo(1))
Assert.That(sarray, Has.None.Property("Length").GreaterThan(3))
' Inherited syntax
Expect(iarray, Contains(3))
Expect(sarray, Contains("b"))
Expect(sarray, Has.No.Member("x"))
' Only available using new syntax
' Note that EqualTo and SameAs do NOT give
' identical results to Contains because
' Contains uses Object.Equals()
Expect(iarray, Some.EqualTo(3))
Expect(sarray, Some.EqualTo("b"))
Expect(sarray, None.EqualTo("x"))
Expect(iarray, All.LessThan(10))
Expect(sarray, All.Length.EqualTo(1))
Expect(sarray, None.Property("Length").GreaterThan(3))
End Sub
_
Public Sub CollectionEquivalenceTests()
Dim ints1to5 As Integer() = {1, 2, 3, 4, 5}
Dim twothrees As Integer() = {1, 2, 3, 3, 4, 5}
Dim twofours As Integer() = {1, 2, 3, 4, 4, 5}
' Classic syntax
CollectionAssert.AreEquivalent(New Integer() {2, 1, 4, 3, 5}, ints1to5)
CollectionAssert.AreNotEquivalent(New Integer() {2, 2, 4, 3, 5}, ints1to5)
CollectionAssert.AreNotEquivalent(New Integer() {2, 4, 3, 5}, ints1to5)
CollectionAssert.AreNotEquivalent(New Integer() {2, 2, 1, 1, 4, 3, 5}, ints1to5)
CollectionAssert.AreNotEquivalent(twothrees, twofours)
' Helper syntax
Assert.That(New Integer() {2, 1, 4, 3, 5}, Iz.EquivalentTo(ints1to5))
Assert.That(New Integer() {2, 2, 4, 3, 5}, Iz.Not.EquivalentTo(ints1to5))
Assert.That(New Integer() {2, 4, 3, 5}, Iz.Not.EquivalentTo(ints1to5))
Assert.That(New Integer() {2, 2, 1, 1, 4, 3, 5}, Iz.Not.EquivalentTo(ints1to5))
Assert.That(twothrees, Iz.Not.EquivalentTo(twofours))
' Inherited syntax
Expect(New Integer() {2, 1, 4, 3, 5}, EquivalentTo(ints1to5))
End Sub
_
Public Sub SubsetTests()
Dim ints1to5 As Integer() = {1, 2, 3, 4, 5}
' Classic syntax
CollectionAssert.IsSubsetOf(New Integer() {1, 3, 5}, ints1to5)
CollectionAssert.IsSubsetOf(New Integer() {1, 2, 3, 4, 5}, ints1to5)
CollectionAssert.IsNotSubsetOf(New Integer() {2, 4, 6}, ints1to5)
CollectionAssert.IsNotSubsetOf(New Integer() {1, 2, 2, 2, 5}, ints1to5)
' Helper syntax
Assert.That(New Integer() {1, 3, 5}, Iz.SubsetOf(ints1to5))
Assert.That(New Integer() {1, 2, 3, 4, 5}, Iz.SubsetOf(ints1to5))
Assert.That(New Integer() {2, 4, 6}, Iz.Not.SubsetOf(ints1to5))
' Inherited syntax
Expect(New Integer() {1, 3, 5}, SubsetOf(ints1to5))
Expect(New Integer() {1, 2, 3, 4, 5}, SubsetOf(ints1to5))
Expect(New Integer() {2, 4, 6}, Iz.Not.SubsetOf(ints1to5))
End Sub
#End Region
#Region "Property Tests"
_
Public Sub PropertyTests()
Dim array As String() = {"abc", "bca", "xyz", "qrs"}
Dim array2 As String() = {"a", "ab", "abc"}
Dim list As New ArrayList(array)
' Not available using the classic syntax
' Helper syntax
' Assert.That(list, Has.Property("Count"))
' Assert.That(list, Has.No.Property("Length"))
Assert.That("Hello", Has.Length.EqualTo(5))
Assert.That("Hello", Has.Property("Length").EqualTo(5))
Assert.That("Hello", Has.Property("Length").GreaterThan(3))
Assert.That(array, Has.Property("Length").EqualTo(4))
Assert.That(array, Has.Length.EqualTo(4))
Assert.That(array, Has.Property("Length").LessThan(10))
Assert.That(array, Has.All.Property("Length").EqualTo(3))
Assert.That(array, Has.All.Length.EqualTo(3))
Assert.That(array, Iz.All.Length.EqualTo(3))
Assert.That(array, Has.All.Property("Length").EqualTo(3))
Assert.That(array, Iz.All.Property("Length").EqualTo(3))
Assert.That(array2, Iz.Not.Property("Length").EqualTo(4))
Assert.That(array2, Iz.Not.Length.EqualTo(4))
Assert.That(array2, Has.No.Property("Length").GreaterThan(3))
' Inherited syntax
' Expect(list, Has.Property("Count"))
' Expect(list, Has.No.Property("Nada"))
Expect(array, All.Property("Length").EqualTo(3))
Expect(array, All.Length.EqualTo(3))
End Sub
#End Region
#Region "Not Tests"
_
Public Sub NotTests()
' Not available using the classic syntax
' Helper syntax
Assert.That(42, Iz.Not.Null)
Assert.That(42, Iz.Not.True)
Assert.That(42, Iz.Not.False)
Assert.That(2.5, Iz.Not.NaN)
Assert.That(2 + 2, Iz.Not.EqualTo(3))
Assert.That(2 + 2, Iz.Not.Not.EqualTo(4))
Assert.That(2 + 2, Iz.Not.Not.Not.EqualTo(5))
' Inherited syntax
Expect(42, Iz.Not.Null)
Expect(42, Iz.Not.True)
Expect(42, Iz.Not.False)
Expect(2.5, Iz.Not.NaN)
Expect(2 + 2, Iz.Not.EqualTo(3))
Expect(2 + 2, Iz.Not.Not.EqualTo(4))
Expect(2 + 2, Iz.Not.Not.Not.EqualTo(5))
End Sub
#End Region
End Class
End Namespace
NUnit-2.6.0.12051/samples/vb/syntax/AssemblyInfo.vb 0000664 0001750 0001750 00000002024 11504175260 021503 0 ustar jtaylor jtaylor Imports System
Imports System.Reflection
Imports System.Runtime.InteropServices
' General Information about an assembly is controlled through the following
' set of attributes. Change these attribute values to modify the information
' associated with an assembly.
' Review the values of the assembly attributes
'The following GUID is for the ID of the typelib if this project is exposed to COM
' Version information for an assembly consists of the following four values:
'
' Major Version
' Minor Version
' Build Number
' Revision
'
' You can specify all the values or you can default the Build and Revision Numbers
' by using the '*' as shown below:
NUnit-2.6.0.12051/samples/vb/syntax/vb-syntax.vbproj 0000664 0001750 0001750 00000004313 11720516414 021741 0 ustar jtaylor jtaylor NUnit-2.6.0.12051/samples/vb/failures/ 0000775 0001750 0001750 00000000000 11742560362 017052 5 ustar jtaylor jtaylor NUnit-2.6.0.12051/samples/vb/failures/vb-failures.build 0000664 0001750 0001750 00000000410 11504175260 022300 0 ustar jtaylor jtaylor
NUnit-2.6.0.12051/samples/vb/failures/AssemblyInfo.vb 0000664 0001750 0001750 00000002010 11504175260 021762 0 ustar jtaylor jtaylor Imports System.Reflection
Imports System.Runtime.InteropServices
' General Information about an assembly is controlled through the following
' set of attributes. Change these attribute values to modify the information
' associated with an assembly.
' Review the values of the assembly attributes
'The following GUID is for the ID of the typelib if this project is exposed to COM
' Version information for an assembly consists of the following four values:
'
' Major Version
' Minor Version
' Build Number
' Revision
'
' You can specify all the values or you can default the Build and Revision Numbers
' by using the '*' as shown below:
NUnit-2.6.0.12051/samples/vb/failures/vb-failures.vbproj 0000664 0001750 0001750 00000003652 11720516414 022516 0 ustar jtaylor jtaylor NUnit-2.6.0.12051/samples/vb/failures/SimpleVBTest.vb 0000664 0001750 0001750 00000003246 11504175260 021724 0 ustar jtaylor jtaylor ' ****************************************************************
' This is free software licensed under the NUnit license. You
' may obtain a copy of the license as well as information regarding
' copyright ownership at http://nunit.org/?p=license&r=2.4.
' ****************************************************************
Option Explicit On
Imports System
Imports NUnit.Framework
Namespace NUnit.Samples
Public Class SimpleVBTest
Private fValue1 As Integer
Private fValue2 As Integer
Public Sub New()
MyBase.New()
End Sub
Public Sub Init()
fValue1 = 2
fValue2 = 3
End Sub
Public Sub Add()
Dim result As Double
result = fValue1 + fValue2
Assert.AreEqual(6, result)
End Sub
Public Sub DivideByZero()
Dim zero As Integer
Dim result As Integer
zero = 0
result = 8 / zero
End Sub
Public Sub TestEquals()
Assert.AreEqual(12, 12)
Assert.AreEqual(CLng(12), CLng(12))
Assert.AreEqual(12, 13, "Size")
Assert.AreEqual(12, 11.99, 0, "Capacity")
End Sub
Public Sub ExpectAnException()
Throw New InvalidCastException()
End Sub
Public Sub IgnoredTest()
' does not matter what we type the test is not run
Throw New ArgumentException()
End Sub
End Class
End Namespace NUnit-2.6.0.12051/samples/vb/vb-samples.sln 0000664 0001750 0001750 00000003605 11504175260 020026 0 ustar jtaylor jtaylor Microsoft Visual Studio Solution File, Format Version 8.00
Project("{F184B08F-C81C-45F6-A57F-5ABD9991F28F}") = "vb-failures", "failures\vb-failures.vbproj", "{F199991B-6C8E-4AB0-9AAA-703CD4897700}"
ProjectSection(ProjectDependencies) = postProject
EndProjectSection
EndProject
Project("{F184B08F-C81C-45F6-A57F-5ABD9991F28F}") = "vb-money", "money\vb-money.vbproj", "{95394B96-A794-48EA-9879-0E4EC79C5724}"
ProjectSection(ProjectDependencies) = postProject
EndProjectSection
EndProject
Project("{F184B08F-C81C-45F6-A57F-5ABD9991F28F}") = "vb-syntax", "syntax\vb-syntax.vbproj", "{6BEF566A-2691-4EE8-91AF-0390CCCDDAF1}"
ProjectSection(ProjectDependencies) = postProject
EndProjectSection
EndProject
Global
GlobalSection(SolutionConfiguration) = preSolution
Debug = Debug
Release = Release
EndGlobalSection
GlobalSection(ProjectConfiguration) = postSolution
{F199991B-6C8E-4AB0-9AAA-703CD4897700}.Debug.ActiveCfg = Debug|.NET
{F199991B-6C8E-4AB0-9AAA-703CD4897700}.Debug.Build.0 = Debug|.NET
{F199991B-6C8E-4AB0-9AAA-703CD4897700}.Release.ActiveCfg = Release|.NET
{F199991B-6C8E-4AB0-9AAA-703CD4897700}.Release.Build.0 = Release|.NET
{95394B96-A794-48EA-9879-0E4EC79C5724}.Debug.ActiveCfg = Debug|.NET
{95394B96-A794-48EA-9879-0E4EC79C5724}.Debug.Build.0 = Debug|.NET
{95394B96-A794-48EA-9879-0E4EC79C5724}.Release.ActiveCfg = Release|.NET
{95394B96-A794-48EA-9879-0E4EC79C5724}.Release.Build.0 = Release|.NET
{6BEF566A-2691-4EE8-91AF-0390CCCDDAF1}.Debug.ActiveCfg = Debug|.NET
{6BEF566A-2691-4EE8-91AF-0390CCCDDAF1}.Debug.Build.0 = Debug|.NET
{6BEF566A-2691-4EE8-91AF-0390CCCDDAF1}.Release.ActiveCfg = Release|.NET
{6BEF566A-2691-4EE8-91AF-0390CCCDDAF1}.Release.Build.0 = Release|.NET
EndGlobalSection
GlobalSection(ExtensibilityGlobals) = postSolution
EndGlobalSection
GlobalSection(ExtensibilityAddIns) = postSolution
EndGlobalSection
EndGlobal
NUnit-2.6.0.12051/samples/cpp/ 0000775 0001750 0001750 00000000000 11742560362 015413 5 ustar jtaylor jtaylor NUnit-2.6.0.12051/samples/cpp/managed/ 0000775 0001750 0001750 00000000000 11742560362 017007 5 ustar jtaylor jtaylor NUnit-2.6.0.12051/samples/cpp/managed/managed-cpp.sln 0000664 0001750 0001750 00000001652 11504175260 021700 0 ustar jtaylor jtaylor Microsoft Visual Studio Solution File, Format Version 8.00
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "cpp-managed-failures", "failures\cpp-managed-failures.vcproj", "{7E5849C7-0469-4AD2-91B9-C87203934254}"
ProjectSection(ProjectDependencies) = postProject
EndProjectSection
EndProject
Global
GlobalSection(SolutionConfiguration) = preSolution
Debug = Debug
Release = Release
EndGlobalSection
GlobalSection(ProjectConfiguration) = postSolution
{7E5849C7-0469-4AD2-91B9-C87203934254}.Debug.ActiveCfg = Debug|Win32
{7E5849C7-0469-4AD2-91B9-C87203934254}.Debug.Build.0 = Debug|Win32
{7E5849C7-0469-4AD2-91B9-C87203934254}.Release.ActiveCfg = Release|Win32
{7E5849C7-0469-4AD2-91B9-C87203934254}.Release.Build.0 = Release|Win32
EndGlobalSection
GlobalSection(ExtensibilityGlobals) = postSolution
EndGlobalSection
GlobalSection(ExtensibilityAddIns) = postSolution
EndGlobalSection
EndGlobal
NUnit-2.6.0.12051/samples/cpp/managed/failures/ 0000775 0001750 0001750 00000000000 11742560362 020621 5 ustar jtaylor jtaylor NUnit-2.6.0.12051/samples/cpp/managed/failures/AssemblyInfo.cpp 0000664 0001750 0001750 00000004405 11504175260 023716 0 ustar jtaylor jtaylor using namespace System::Reflection;
using namespace System::Runtime::CompilerServices;
//
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
//
[assembly:AssemblyTitleAttribute("")];
[assembly:AssemblyDescriptionAttribute("")];
[assembly:AssemblyConfigurationAttribute("")];
[assembly:AssemblyCompanyAttribute("")];
[assembly:AssemblyProductAttribute("")];
[assembly:AssemblyCopyrightAttribute("")];
[assembly:AssemblyTrademarkAttribute("")];
[assembly:AssemblyCultureAttribute("")];
//
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// You can specify all the value or you can default the Revision and Build Numbers
// by using the '*' as shown below:
[assembly:AssemblyVersionAttribute("2.2.0.0")];
//
// In order to sign your assembly you must specify a key to use. Refer to the
// Microsoft .NET Framework documentation for more information on assembly signing.
//
// Use the attributes below to control which key is used for signing.
//
// Notes:
// (*) If no key is specified, the assembly is not signed.
// (*) KeyName refers to a key that has been installed in the Crypto Service
// Provider (CSP) on your machine. KeyFile refers to a file which contains
// a key.
// (*) If the KeyFile and the KeyName values are both specified, the
// following processing occurs:
// (1) If the KeyName can be found in the CSP, that key is used.
// (2) If the KeyName does not exist and the KeyFile does exist, the key
// in the KeyFile is installed into the CSP and used.
// (*) In order to create a KeyFile, you can use the sn.exe (Strong Name) utility.
// When specifying the KeyFile, the location of the KeyFile should be
// relative to the project directory.
// (*) Delay Signing is an advanced option - see the Microsoft .NET Framework
// documentation for more information on this.
//
[assembly:AssemblyDelaySignAttribute(false)];
[assembly:AssemblyKeyFileAttribute("")];
[assembly:AssemblyKeyNameAttribute("")];
NUnit-2.6.0.12051/samples/cpp/managed/failures/cppsample.h 0000664 0001750 0001750 00000001437 11504175260 022756 0 ustar jtaylor jtaylor // ****************************************************************
// This is free software licensed under the NUnit license. You
// may obtain a copy of the license as well as information regarding
// copyright ownership at http://nunit.org/?p=license&r=2.4.
// ****************************************************************
#pragma once
using namespace System;
using namespace NUnit::Framework;
namespace NUnitSamples
{
[TestFixture]
public __gc class SimpleCPPSample
{
int fValue1;
int fValue2;
public:
[SetUp] void Init();
[Test] void Add();
[Test] void DivideByZero();
[Test] void Equals();
[Test] [Ignore("ignored test")] void IgnoredTest();
[Test] [ExpectedException(__typeof(InvalidOperationException))] void ExpectAnException();
};
}
NUnit-2.6.0.12051/samples/cpp/managed/failures/cpp-managed-failures.build 0000664 0001750 0001750 00000001743 11504175260 025626 0 ustar jtaylor jtaylor
NUnit-2.6.0.12051/samples/cpp/managed/failures/cppsample.cpp 0000664 0001750 0001750 00000002144 11504175260 023305 0 ustar jtaylor jtaylor // ****************************************************************
// This is free software licensed under the NUnit license. You
// may obtain a copy of the license as well as information regarding
// copyright ownership at http://nunit.org/?p=license&r=2.4.
// ****************************************************************
#include "cppsample.h"
namespace NUnitSamples {
void SimpleCPPSample::Init() {
fValue1 = 2;
fValue2 = 3;
}
void SimpleCPPSample::Add() {
int result = fValue1 + fValue2;
Assert::AreEqual(6,result);
}
void SimpleCPPSample::DivideByZero()
{
int zero= 0;
int result= 8/zero;
}
void SimpleCPPSample::Equals() {
Assert::AreEqual(12, 12, "Integer");
Assert::AreEqual(12L, 12L, "Long");
Assert::AreEqual('a', 'a', "Char");
Assert::AreEqual(12, 13, "Expected Failure (Integer)");
Assert::AreEqual(12.0, 11.99, 0.0, "Expected Failure (Double)");
}
void SimpleCPPSample::IgnoredTest()
{
throw new InvalidCastException();
}
void SimpleCPPSample::ExpectAnException()
{
throw new InvalidCastException();
}
}
NUnit-2.6.0.12051/samples/cpp/managed/failures/cpp-managed-failures.vcproj 0000664 0001750 0001750 00000007177 11504175260 026041 0 ustar jtaylor jtaylor
NUnit-2.6.0.12051/samples/cpp/cpp-cli/ 0000775 0001750 0001750 00000000000 11742560362 016742 5 ustar jtaylor jtaylor NUnit-2.6.0.12051/samples/cpp/cpp-cli/cpp-cli.sln 0000664 0001750 0001750 00000005030 11504175260 021000 0 ustar jtaylor jtaylor Microsoft Visual Studio Solution File, Format Version 9.00
# Visual Studio 2005
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "cpp-cli-failures", "failures\cpp-cli-failures.vcproj", "{A0987BCD-AFE6-40E4-95A8-ADA7ADB7E97D}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "cpp-cli-syntax", "syntax\cpp-cli-syntax.vcproj", "{72448C2D-17C9-419E-B28D-3B533E7E0CD5}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Any CPU = Debug|Any CPU
Debug|Mixed Platforms = Debug|Mixed Platforms
Debug|Win32 = Debug|Win32
Release|Any CPU = Release|Any CPU
Release|Mixed Platforms = Release|Mixed Platforms
Release|Win32 = Release|Win32
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{A0987BCD-AFE6-40E4-95A8-ADA7ADB7E97D}.Debug|Any CPU.ActiveCfg = Debug|Win32
{A0987BCD-AFE6-40E4-95A8-ADA7ADB7E97D}.Debug|Mixed Platforms.ActiveCfg = Debug|Win32
{A0987BCD-AFE6-40E4-95A8-ADA7ADB7E97D}.Debug|Mixed Platforms.Build.0 = Debug|Win32
{A0987BCD-AFE6-40E4-95A8-ADA7ADB7E97D}.Debug|Win32.ActiveCfg = Debug|Win32
{A0987BCD-AFE6-40E4-95A8-ADA7ADB7E97D}.Debug|Win32.Build.0 = Debug|Win32
{A0987BCD-AFE6-40E4-95A8-ADA7ADB7E97D}.Release|Any CPU.ActiveCfg = Release|Win32
{A0987BCD-AFE6-40E4-95A8-ADA7ADB7E97D}.Release|Mixed Platforms.ActiveCfg = Release|Win32
{A0987BCD-AFE6-40E4-95A8-ADA7ADB7E97D}.Release|Mixed Platforms.Build.0 = Release|Win32
{A0987BCD-AFE6-40E4-95A8-ADA7ADB7E97D}.Release|Win32.ActiveCfg = Release|Win32
{A0987BCD-AFE6-40E4-95A8-ADA7ADB7E97D}.Release|Win32.Build.0 = Release|Win32
{72448C2D-17C9-419E-B28D-3B533E7E0CD5}.Debug|Any CPU.ActiveCfg = Debug|Win32
{72448C2D-17C9-419E-B28D-3B533E7E0CD5}.Debug|Mixed Platforms.ActiveCfg = Debug|Win32
{72448C2D-17C9-419E-B28D-3B533E7E0CD5}.Debug|Mixed Platforms.Build.0 = Debug|Win32
{72448C2D-17C9-419E-B28D-3B533E7E0CD5}.Debug|Win32.ActiveCfg = Debug|Win32
{72448C2D-17C9-419E-B28D-3B533E7E0CD5}.Debug|Win32.Build.0 = Debug|Win32
{72448C2D-17C9-419E-B28D-3B533E7E0CD5}.Release|Any CPU.ActiveCfg = Release|Win32
{72448C2D-17C9-419E-B28D-3B533E7E0CD5}.Release|Mixed Platforms.ActiveCfg = Release|Win32
{72448C2D-17C9-419E-B28D-3B533E7E0CD5}.Release|Mixed Platforms.Build.0 = Release|Win32
{72448C2D-17C9-419E-B28D-3B533E7E0CD5}.Release|Win32.ActiveCfg = Release|Win32
{72448C2D-17C9-419E-B28D-3B533E7E0CD5}.Release|Win32.Build.0 = Release|Win32
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
EndGlobalSection
EndGlobal
NUnit-2.6.0.12051/samples/cpp/cpp-cli/syntax/ 0000775 0001750 0001750 00000000000 11742560362 020270 5 ustar jtaylor jtaylor NUnit-2.6.0.12051/samples/cpp/cpp-cli/syntax/cpp-cli-syntax.vcproj 0000664 0001750 0001750 00000010256 11504175260 024367 0 ustar jtaylor jtaylor
NUnit-2.6.0.12051/samples/cpp/cpp-cli/syntax/AssemblyInfo.cpp 0000664 0001750 0001750 00000002474 11504175260 023371 0 ustar jtaylor jtaylor #include "stdafx.h"
using namespace System;
using namespace System::Reflection;
using namespace System::Runtime::CompilerServices;
using namespace System::Runtime::InteropServices;
using namespace System::Security::Permissions;
//
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
//
[assembly:AssemblyTitleAttribute("cppclisyntax")];
[assembly:AssemblyDescriptionAttribute("")];
[assembly:AssemblyConfigurationAttribute("")];
[assembly:AssemblyCompanyAttribute("")];
[assembly:AssemblyProductAttribute("cppclisyntax")];
[assembly:AssemblyCopyrightAttribute("Copyright (c) 2007")];
[assembly:AssemblyTrademarkAttribute("")];
[assembly:AssemblyCultureAttribute("")];
//
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// You can specify all the value or you can default the Revision and Build Numbers
// by using the '*' as shown below:
[assembly:AssemblyVersionAttribute("1.0.*")];
[assembly:ComVisible(false)];
[assembly:CLSCompliantAttribute(true)];
[assembly:SecurityPermission(SecurityAction::RequestMinimum, UnmanagedCode = true)];
NUnit-2.6.0.12051/samples/cpp/cpp-cli/syntax/cpp-cli-syntax.cpp 0000664 0001750 0001750 00000046155 11504175260 023655 0 ustar jtaylor jtaylor // ****************************************************************
// This is free software licensed under the NUnit license. You
// may obtain a copy of the license as well as information regarding
// copyright ownership at http://nunit.org/?p=license&r=2.4.
// ****************************************************************
using namespace NUnit::Framework;
using NUnit::Framework::Is;
using NUnit::Framework::Text;
using NUnit::Framework::List;
using NUnit::Framework::Has;
using System::String;
namespace NUnitSamples
{
[TestFixture]
public ref class AssertSyntaxTests : AssertionHelper
{
public:
[Test]
void IsNull()
{
Object ^nada = nullptr;
// Classic syntax
Assert::IsNull(nada);
// Helper syntax
Assert::That(nada, Is::Null);
// Inherited syntax
Expect(nada, Null);
}
[Test]
void IsNotNull()
{
// Classic syntax
Assert::IsNotNull(42);
// Helper syntax
Assert::That(42, Is::Not->Null);
// Inherited syntax
Expect( 42, Not->Null );
}
[Test]
void IsTrue()
{
// Classic syntax
Assert::IsTrue(2+2==4);
// Helper syntax
Assert::That(2+2==4, Is::True);
Assert::That(2+2==4);
// Inherited syntax
Expect(2+2==4, True);
Expect(2+2==4);
}
[Test]
void IsFalse()
{
// Classic syntax
Assert::IsFalse(2+2==5);
// Helper syntax
Assert::That(2+2==5, Is::False);
// Inherited syntax
Expect(2+2==5, False);
}
[Test]
void IsNaN()
{
double d = double::NaN;
float f = float::NaN;
// Classic syntax
Assert::IsNaN(d);
Assert::IsNaN(f);
// Helper syntax
Assert::That(d, Is::NaN);
Assert::That(f, Is::NaN);
// Inherited syntax
Expect(d, NaN);
Expect(f, NaN);
}
[Test]
void EmptyStringTests()
{
// Classic syntax
Assert::IsEmpty("");
Assert::IsNotEmpty("Hello!");
// Helper syntax
Assert::That("", Is::Empty);
Assert::That("Hello!", Is::Not->Empty);
// Inherited syntax
Expect("", Empty);
Expect("Hello!", Not->Empty);
}
[Test]
void EmptyCollectionTests()
{
// Classic syntax
Assert::IsEmpty(gcnew array(0));
Assert::IsNotEmpty(gcnew array(3));
// Helper syntax
Assert::That(gcnew array(0), Is::Empty);
Assert::That(gcnew array(3), Is::Not->Empty);
// Inherited syntax
Expect(gcnew array(0), Empty);
Expect(gcnew array(3), Not->Empty);
}
[Test]
void ExactTypeTests()
{
// Classic syntax workarounds)
String^ greeting = "Hello";
Assert::AreEqual(String::typeid, greeting->GetType());
Assert::AreEqual("System.String", greeting->GetType()->FullName);
Assert::AreNotEqual(int::typeid, greeting->GetType());
Assert::AreNotEqual("System.Int32", greeting->GetType()->FullName);
// Helper syntax
Assert::That(greeting, Is::TypeOf(String::typeid));
Assert::That(greeting, Is::Not->TypeOf(int::typeid));
// Inherited syntax
Expect( "Hello", TypeOf(String::typeid));
Expect( "Hello", Not->TypeOf(int::typeid));
}
[Test]
void InstanceOfTypeTests()
{
// Classic syntax
Assert::IsInstanceOfType(String::typeid, "Hello");
Assert::IsNotInstanceOfType(String::typeid, 5);
// Helper syntax
Assert::That("Hello", Is::InstanceOfType(String::typeid));
Assert::That(5, Is::Not->InstanceOfType(String::typeid));
// Inherited syntax
Expect("Hello", InstanceOfType(String::typeid));
Expect(5, Not->InstanceOfType(String::typeid));
}
[Test]
void AssignableFromTypeTests()
{
// Classic syntax
Assert::IsAssignableFrom(String::typeid, "Hello");
Assert::IsNotAssignableFrom(String::typeid, 5);
// Helper syntax
Assert::That( "Hello", Is::AssignableFrom(String::typeid));
Assert::That( 5, Is::Not->AssignableFrom(String::typeid));
// Inherited syntax
Expect( "Hello", AssignableFrom(String::typeid));
Expect( 5, Not->AssignableFrom(String::typeid));
}
[Test]
void SubstringTests()
{
String^ phrase = "Hello World!";
array^ strings = {"abc", "bad", "dba" };
// Classic Syntax
StringAssert::Contains("World", phrase);
// Helper syntax
Assert::That(phrase, Contains("World"));
// Only available using new syntax
Assert::That(phrase, Text::DoesNotContain("goodbye"));
Assert::That(phrase, Text::Contains("WORLD")->IgnoreCase);
Assert::That(phrase, Text::DoesNotContain("BYE")->IgnoreCase);
Assert::That(strings, Text::All->Contains( "b" ) );
// Inherited syntax
Expect(phrase, Contains("World"));
// Only available using new syntax
Expect(phrase, Not->Contains("goodbye"));
Expect(phrase, Contains("WORLD")->IgnoreCase);
Expect(phrase, Not->Contains("BYE")->IgnoreCase);
Expect(strings, All->Contains("b"));
}
[Test]
void StartsWithTests()
{
String^ phrase = "Hello World!";
array^ greetings = { "Hello!", "Hi!", "Hola!" };
// Classic syntax
StringAssert::StartsWith("Hello", phrase);
// Helper syntax
Assert::That(phrase, Text::StartsWith("Hello"));
// Only available using new syntax
Assert::That(phrase, Text::DoesNotStartWith("Hi!"));
Assert::That(phrase, Text::StartsWith("HeLLo")->IgnoreCase);
Assert::That(phrase, Text::DoesNotStartWith("HI")->IgnoreCase);
Assert::That(greetings, Text::All->StartsWith("h")->IgnoreCase);
// Inherited syntax
Expect(phrase, StartsWith("Hello"));
// Only available using new syntax
Expect(phrase, Not->StartsWith("Hi!"));
Expect(phrase, StartsWith("HeLLo")->IgnoreCase);
Expect(phrase, Not->StartsWith("HI")->IgnoreCase);
Expect(greetings, All->StartsWith("h")->IgnoreCase);
}
[Test]
void EndsWithTests()
{
String^ phrase = "Hello World!";
array^ greetings = { "Hello!", "Hi!", "Hola!" };
// Classic Syntax
StringAssert::EndsWith("!", phrase);
// Helper syntax
Assert::That(phrase, Text::EndsWith("!"));
// Only available using new syntax
Assert::That(phrase, Text::DoesNotEndWith("?"));
Assert::That(phrase, Text::EndsWith("WORLD!")->IgnoreCase);
Assert::That(greetings, Text::All->EndsWith("!"));
// Inherited syntax
Expect(phrase, EndsWith("!"));
// Only available using new syntax
Expect(phrase, Not->EndsWith("?"));
Expect(phrase, EndsWith("WORLD!")->IgnoreCase);
Expect(greetings, All->EndsWith("!") );
}
[Test]
void EqualIgnoringCaseTests()
{
String^ phrase = "Hello World!";
// Classic syntax
StringAssert::AreEqualIgnoringCase("hello world!",phrase);
// Helper syntax
Assert::That(phrase, Is::EqualTo("hello world!")->IgnoreCase);
//Only available using new syntax
Assert::That(phrase, Is::Not->EqualTo("goodbye world!")->IgnoreCase);
Assert::That(gcnew array { "Hello", "World" },
Is::EqualTo(gcnew array { "HELLO", "WORLD" })->IgnoreCase);
Assert::That(gcnew array {"HELLO", "Hello", "hello" },
Is::All->EqualTo( "hello" )->IgnoreCase);
// Inherited syntax
Expect(phrase, EqualTo("hello world!")->IgnoreCase);
//Only available using new syntax
Expect(phrase, Not->EqualTo("goodbye world!")->IgnoreCase);
Expect(gcnew array { "Hello", "World" },
EqualTo(gcnew array { "HELLO", "WORLD" })->IgnoreCase);
Expect(gcnew array {"HELLO", "Hello", "hello" },
All->EqualTo( "hello" )->IgnoreCase);
}
[Test]
void RegularExpressionTests()
{
String^ phrase = "Now is the time for all good men to come to the aid of their country.";
array^ quotes = { "Never say never", "It's never too late", "Nevermore!" };
// Classic syntax
StringAssert::IsMatch( "all good men", phrase );
StringAssert::IsMatch( "Now.*come", phrase );
// Helper syntax
Assert::That( phrase, Text::Matches( "all good men" ) );
Assert::That( phrase, Text::Matches( "Now.*come" ) );
// Only available using new syntax
Assert::That(phrase, Text::DoesNotMatch("all.*men.*good"));
Assert::That(phrase, Text::Matches("ALL")->IgnoreCase);
Assert::That(quotes, Text::All->Matches("never")->IgnoreCase);
// Inherited syntax
Expect( phrase, Matches( "all good men" ) );
Expect( phrase, Matches( "Now.*come" ) );
// Only available using new syntax
Expect(phrase, Not->Matches("all.*men.*good"));
Expect(phrase, Matches("ALL")->IgnoreCase);
Expect(quotes, All->Matches("never")->IgnoreCase);
}
[Test]
void EqualityTests()
{
array^ i3 = { 1, 2, 3 };
array^ d3 = { 1.0, 2.0, 3.0 };
array^ iunequal = { 1, 3, 2 };
// Classic Syntax
Assert::AreEqual(4, 2 + 2);
Assert::AreEqual(i3, d3);
Assert::AreNotEqual(5, 2 + 2);
Assert::AreNotEqual(i3, iunequal);
// Helper syntax
Assert::That(2 + 2, Is::EqualTo(4));
Assert::That(2 + 2 == 4);
Assert::That(i3, Is::EqualTo(d3));
Assert::That(2 + 2, Is::Not->EqualTo(5));
Assert::That(i3, Is::Not->EqualTo(iunequal));
// Inherited syntax
Expect(2 + 2, EqualTo(4));
Expect(2 + 2 == 4);
Expect(i3, EqualTo(d3));
Expect(2 + 2, Not->EqualTo(5));
Expect(i3, Not->EqualTo(iunequal));
}
[Test]
void EqualityTestsWithTolerance()
{
// CLassic syntax
Assert::AreEqual(5.0, 4.99, 0.05);
Assert::AreEqual(5.0F, 4.99F, 0.05F);
// Helper syntax
Assert::That(4.99L, Is::EqualTo(5.0L)->Within(0.05L));
Assert::That(4.99f, Is::EqualTo(5.0f)->Within(0.05f));
// Inherited syntax
Expect(4.99L, EqualTo(5.0L)->Within(0.05L));
Expect(4.99f, EqualTo(5.0f)->Within(0.05f));
}
[Test]
void ComparisonTests()
{
// Classic Syntax
Assert::Greater(7, 3);
Assert::GreaterOrEqual(7, 3);
Assert::GreaterOrEqual(7, 7);
// Helper syntax
Assert::That(7, Is::GreaterThan(3));
Assert::That(7, Is::GreaterThanOrEqualTo(3));
Assert::That(7, Is::AtLeast(3));
Assert::That(7, Is::GreaterThanOrEqualTo(7));
Assert::That(7, Is::AtLeast(7));
// Inherited syntax
Expect(7, GreaterThan(3));
Expect(7, GreaterThanOrEqualTo(3));
Expect(7, AtLeast(3));
Expect(7, GreaterThanOrEqualTo(7));
Expect(7, AtLeast(7));
// Classic syntax
Assert::Less(3, 7);
Assert::LessOrEqual(3, 7);
Assert::LessOrEqual(3, 3);
// Helper syntax
Assert::That(3, Is::LessThan(7));
Assert::That(3, Is::LessThanOrEqualTo(7));
Assert::That(3, Is::AtMost(7));
Assert::That(3, Is::LessThanOrEqualTo(3));
Assert::That(3, Is::AtMost(3));
// Inherited syntax
Expect(3, LessThan(7));
Expect(3, LessThanOrEqualTo(7));
Expect(3, AtMost(7));
Expect(3, LessThanOrEqualTo(3));
Expect(3, AtMost(3));
}
[Test]
void AllItemsTests()
{
array^ ints = { 1, 2, 3, 4 };
array^ strings = { "abc", "bad", "cab", "bad", "dad" };
// Classic syntax
CollectionAssert::AllItemsAreNotNull(ints);
CollectionAssert::AllItemsAreInstancesOfType(ints, int::typeid);
CollectionAssert::AllItemsAreInstancesOfType(strings, String::typeid);
CollectionAssert::AllItemsAreUnique(ints);
// Helper syntax
Assert::That(ints, Is::All->Not->Null);
Assert::That(ints, Is::All->InstanceOfType(int::typeid));
Assert::That(strings, Is::All->InstanceOfType(String::typeid));
Assert::That(ints, Is::Unique);
// Only available using new syntax
Assert::That(strings, Is::Not->Unique);
Assert::That(ints, Is::All->GreaterThan(0));
Assert::That(strings, Text::All->Contains( "a" ) );
Assert::That(strings, Has::Some->StartsWith( "ba" ) );
// Inherited syntax
Expect(ints, All->Not->Null);
Expect(ints, All->InstanceOfType(int::typeid));
Expect(strings, All->InstanceOfType(String::typeid));
Expect(ints, Unique);
// Only available using new syntax
Expect(strings, Not->Unique);
Expect(ints, All->GreaterThan(0));
Expect(strings, All->Contains( "a" ) );
Expect(strings, Some->StartsWith( "ba" ) );
}
[Test]
void SomeItemsTests()
{
array^ mixed = { 1, 2, "3", nullptr, "four", 100 };
array^ strings = { "abc", "bad", "cab", "bad", "dad" };
// Not available using the classic syntax
// Helper syntax
Assert::That(mixed, Has::Some->Null);
Assert::That(mixed, Has::Some->InstanceOfType(int::typeid));
Assert::That(mixed, Has::Some->InstanceOfType(String::typeid));
Assert::That(strings, Has::Some->StartsWith( "ba" ) );
Assert::That(strings, Has::Some->Not->StartsWith( "ba" ) );
// Inherited syntax
Expect(mixed, Some->Null);
Expect(mixed, Some->InstanceOfType(int::typeid));
Expect(mixed, Some->InstanceOfType(String::typeid));
Expect(strings, Some->StartsWith( "ba" ) );
Expect(strings, Some->Not->StartsWith( "ba" ) );
}
[Test]
void NoItemsTests()
{
array^ ints = { 1, 2, 3, 4, 5 };
array^ strings = { "abc", "bad", "cab", "bad", "dad" };
// Not available using the classic syntax
// Helper syntax
Assert::That(ints, Has::None->Null);
Assert::That(ints, Has::None->InstanceOfType(String::typeid));
Assert::That(ints, Has::None->GreaterThan(99));
Assert::That(strings, Has::None->StartsWith( "qu" ) );
// Inherited syntax
Expect(ints, None->Null);
Expect(ints, None->InstanceOfType(String::typeid));
Expect(ints, None->GreaterThan(99));
Expect(strings, None->StartsWith( "qu" ) );
}
[Test]
void CollectionContainsTests()
{
array^ iarray = { 1, 2, 3 };
array^ sarray = { "a", "b", "c" };
// Classic syntax
Assert::Contains(3, iarray);
Assert::Contains("b", sarray);
CollectionAssert::Contains(iarray, 3);
CollectionAssert::Contains(sarray, "b");
CollectionAssert::DoesNotContain(sarray, "x");
// Helper syntax
Assert::That(iarray, Has::Member(3));
Assert::That(sarray, Has::Member("b"));
Assert::That(sarray, Has::No->Member("x")); // Yuck!
Assert::That(sarray, !Has::Member("x"));
// Inherited syntax
Expect(iarray, Contains(3));
Expect(sarray, Contains("b"));
Expect(sarray, Not->Contains("x"));
Expect(sarray, !Contains("x"));
}
[Test]
void CollectionEquivalenceTests()
{
array^ ints1to5 = { 1, 2, 3, 4, 5 };
// Classic syntax
CollectionAssert::AreEquivalent(gcnew array { 2, 1, 4, 3, 5 }, ints1to5);
CollectionAssert::AreNotEquivalent(gcnew array { 2, 2, 4, 3, 5 }, ints1to5);
CollectionAssert::AreNotEquivalent(gcnew array { 2, 4, 3, 5 }, ints1to5);
CollectionAssert::AreNotEquivalent(gcnew array { 2, 2, 1, 1, 4, 3, 5 }, ints1to5);
// Helper syntax
Assert::That(gcnew array { 2, 1, 4, 3, 5 }, Is::EquivalentTo(ints1to5));
Assert::That(gcnew array { 2, 2, 4, 3, 5 }, Is::Not->EquivalentTo(ints1to5));
Assert::That(gcnew array { 2, 4, 3, 5 }, Is::Not->EquivalentTo(ints1to5));
Assert::That(gcnew array { 2, 2, 1, 1, 4, 3, 5 }, Is::Not->EquivalentTo(ints1to5));
// Inherited syntax
Expect(gcnew array { 2, 1, 4, 3, 5 }, EquivalentTo(ints1to5));
Expect(gcnew array { 2, 2, 4, 3, 5 }, Not->EquivalentTo(ints1to5));
Expect(gcnew array { 2, 4, 3, 5 }, Not->EquivalentTo(ints1to5));
Expect(gcnew array { 2, 2, 1, 1, 4, 3, 5 }, Not->EquivalentTo(ints1to5));
}
[Test]
void SubsetTests()
{
array^ ints1to5 = { 1, 2, 3, 4, 5 };
// Classic syntax
CollectionAssert::IsSubsetOf(gcnew array { 1, 3, 5 }, ints1to5);
CollectionAssert::IsSubsetOf(gcnew array { 1, 2, 3, 4, 5 }, ints1to5);
CollectionAssert::IsNotSubsetOf(gcnew array { 2, 4, 6 }, ints1to5);
CollectionAssert::IsNotSubsetOf(gcnew array { 1, 2, 2, 2, 5 }, ints1to5);
// Helper syntax
Assert::That(gcnew array { 1, 3, 5 }, Is::SubsetOf(ints1to5));
Assert::That(gcnew array { 1, 2, 3, 4, 5 }, Is::SubsetOf(ints1to5));
Assert::That(gcnew array { 2, 4, 6 }, Is::Not->SubsetOf(ints1to5));
Assert::That(gcnew array { 1, 2, 2, 2, 5 }, Is::Not->SubsetOf(ints1to5));
// Inherited syntax
Expect(gcnew array { 1, 3, 5 }, SubsetOf(ints1to5));
Expect(gcnew array { 1, 2, 3, 4, 5 }, SubsetOf(ints1to5));
Expect(gcnew array { 2, 4, 6 }, Not->SubsetOf(ints1to5));
Expect(gcnew array { 1, 2, 2, 2, 5 }, Not->SubsetOf(ints1to5));
}
[Test]
void PropertyTests()
{
array^ strings = { "abc", "bca", "xyz" };
// Helper syntax
Assert::That( "Hello", Has::Property("Length")->EqualTo(5) );
Assert::That( "Hello", Has::Length->EqualTo( 5 ) );
Assert::That( strings , Has::All->Property( "Length")->EqualTo(3) );
Assert::That( strings, Has::All->Length->EqualTo( 3 ) );
// Inherited syntax
Expect( "Hello", Property("Length")->EqualTo(5) );
Expect( "Hello", Length->EqualTo( 5 ) );
Expect( strings, All->Property("Length")->EqualTo(3) );
Expect( strings, All->Length->EqualTo( 3 ) );
}
[Test]
void NotTests()
{
// Not available using the classic syntax
// Helper syntax
Assert::That(42, Is::Not->Null);
Assert::That(42, Is::Not->True);
Assert::That(42, Is::Not->False);
Assert::That(2.5, Is::Not->NaN);
Assert::That(2 + 2, Is::Not->EqualTo(3));
Assert::That(2 + 2, Is::Not->Not->EqualTo(4));
Assert::That(2 + 2, Is::Not->Not->Not->EqualTo(5));
// Inherited syntax
Expect(42, Not->Null);
Expect(42, Not->True);
Expect(42, Not->False);
Expect(2.5, Not->NaN);
Expect(2 + 2, Not->EqualTo(3));
Expect(2 + 2, Not->Not->EqualTo(4));
Expect(2 + 2, Not->Not->Not->EqualTo(5));
}
[Test]
void NotOperator()
{
// The ! operator is only available in the new syntax
Assert::That(42, !Is::Null);
// Inherited syntax
Expect( 42, !Null );
}
[Test]
void AndOperator()
{
// The & operator is only available in the new syntax
Assert::That(7, Is::GreaterThan(5) & Is::LessThan(10));
// Inherited syntax
Expect( 7, GreaterThan(5) & LessThan(10));
}
[Test]
void OrOperator()
{
// The | operator is only available in the new syntax
Assert::That(3, Is::LessThan(5) | Is::GreaterThan(10));
Expect( 3, LessThan(5) | GreaterThan(10));
}
[Test]
void ComplexTests()
{
Assert::That(7, Is::Not->Null & Is::Not->LessThan(5) & Is::Not->GreaterThan(10));
Expect(7, Not->Null & Not->LessThan(5) & Not->GreaterThan(10));
Assert::That(7, !Is::Null & !Is::LessThan(5) & !Is::GreaterThan(10));
Expect(7, !Null & !LessThan(5) & !GreaterThan(10));
}
// This method contains assertions that should not compile
// You can check by uncommenting it.
//void WillNotCompile()
//{
// Assert::That(42, Is::Not);
// Assert::That(42, Is::All);
// Assert::That(42, Is::Null->Not);
// Assert::That(42, Is::Not->Null->GreaterThan(10));
// Assert::That(42, Is::GreaterThan(10)->LessThan(99));
// object[] c = new object[0];
// Assert::That(c, Is::Null->All);
// Assert::That(c, Is::Not->All);
// Assert::That(c, Is::All->Not);
//}
};
} NUnit-2.6.0.12051/samples/cpp/cpp-cli/syntax/cpp-cli-syntax.build 0000664 0001750 0001750 00000000423 11504175260 024156 0 ustar jtaylor jtaylor
NUnit-2.6.0.12051/samples/cpp/cpp-cli/failures/ 0000775 0001750 0001750 00000000000 11742560362 020554 5 ustar jtaylor jtaylor NUnit-2.6.0.12051/samples/cpp/cpp-cli/failures/AssemblyInfo.cpp 0000664 0001750 0001750 00000004405 11504175260 023651 0 ustar jtaylor jtaylor using namespace System::Reflection;
using namespace System::Runtime::CompilerServices;
//
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
//
[assembly:AssemblyTitleAttribute("")];
[assembly:AssemblyDescriptionAttribute("")];
[assembly:AssemblyConfigurationAttribute("")];
[assembly:AssemblyCompanyAttribute("")];
[assembly:AssemblyProductAttribute("")];
[assembly:AssemblyCopyrightAttribute("")];
[assembly:AssemblyTrademarkAttribute("")];
[assembly:AssemblyCultureAttribute("")];
//
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// You can specify all the value or you can default the Revision and Build Numbers
// by using the '*' as shown below:
[assembly:AssemblyVersionAttribute("2.2.0.0")];
//
// In order to sign your assembly you must specify a key to use. Refer to the
// Microsoft .NET Framework documentation for more information on assembly signing.
//
// Use the attributes below to control which key is used for signing.
//
// Notes:
// (*) If no key is specified, the assembly is not signed.
// (*) KeyName refers to a key that has been installed in the Crypto Service
// Provider (CSP) on your machine. KeyFile refers to a file which contains
// a key.
// (*) If the KeyFile and the KeyName values are both specified, the
// following processing occurs:
// (1) If the KeyName can be found in the CSP, that key is used.
// (2) If the KeyName does not exist and the KeyFile does exist, the key
// in the KeyFile is installed into the CSP and used.
// (*) In order to create a KeyFile, you can use the sn.exe (Strong Name) utility.
// When specifying the KeyFile, the location of the KeyFile should be
// relative to the project directory.
// (*) Delay Signing is an advanced option - see the Microsoft .NET Framework
// documentation for more information on this.
//
[assembly:AssemblyDelaySignAttribute(false)];
[assembly:AssemblyKeyFileAttribute("")];
[assembly:AssemblyKeyNameAttribute("")];
NUnit-2.6.0.12051/samples/cpp/cpp-cli/failures/cppsample.h 0000664 0001750 0001750 00000001434 11504175260 022706 0 ustar jtaylor jtaylor // ****************************************************************
// This is free software licensed under the NUnit license. You
// may obtain a copy of the license as well as information regarding
// copyright ownership at http://nunit.org/?p=license&r=2.4.
// ****************************************************************
#pragma once
using namespace System;
using namespace NUnit::Framework;
namespace NUnitSamples
{
[TestFixture]
public ref class SimpleCPPSample
{
int fValue1;
int fValue2;
public:
[SetUp] void Init();
[Test] void Add();
[Test] void DivideByZero();
[Test] void Equals();
[Test] [Ignore("ignored test")] void IgnoredTest();
[Test] [ExpectedException(InvalidOperationException::typeid)] void ExpectAnException();
};
}
NUnit-2.6.0.12051/samples/cpp/cpp-cli/failures/cpp-cli-failures.build 0000664 0001750 0001750 00000001277 11504175260 024736 0 ustar jtaylor jtaylor
NUnit-2.6.0.12051/samples/cpp/cpp-cli/failures/cppsample.cpp 0000664 0001750 0001750 00000002150 11504175260 023235 0 ustar jtaylor jtaylor // ****************************************************************
// This is free software licensed under the NUnit license. You
// may obtain a copy of the license as well as information regarding
// copyright ownership at http://nunit.org/?p=license&r=2.4.
// ****************************************************************
#include "cppsample.h"
namespace NUnitSamples {
void SimpleCPPSample::Init() {
fValue1 = 2;
fValue2 = 3;
}
void SimpleCPPSample::Add() {
int result = fValue1 + fValue2;
Assert::AreEqual(6,result);
}
void SimpleCPPSample::DivideByZero()
{
int zero= 0;
int result= 8/zero;
}
void SimpleCPPSample::Equals() {
Assert::AreEqual(12, 12, "Integer");
Assert::AreEqual(12L, 12L, "Long");
Assert::AreEqual('a', 'a', "Char");
Assert::AreEqual(12, 13, "Expected Failure (Integer)");
Assert::AreEqual(12.0, 11.99, 0.0, "Expected Failure (Double)");
}
void SimpleCPPSample::IgnoredTest()
{
throw gcnew InvalidCastException();
}
void SimpleCPPSample::ExpectAnException()
{
throw gcnew InvalidCastException();
}
}
NUnit-2.6.0.12051/samples/cpp/cpp-cli/failures/cpp-cli-failures.vcproj 0000664 0001750 0001750 00000010260 11504175260 025132 0 ustar jtaylor jtaylor
NUnit-2.6.0.12051/samples/samples.common 0000664 0001750 0001750 00000023430 11535406000 017475 0 ustar jtaylor jtaylor
te
NUnit-2.6.0.12051/samples/ReadMe.txt 0000664 0001750 0001750 00000004243 11504175260 016525 0 ustar jtaylor jtaylor NUnit Samples
This directory contains sample applications demonstrating the use of NUnit and organized as follows...
CSharp: Samples in C#
Failures: Demonstrates 4 failing tests and one that is not run.
Money: This is a C# version of the money example which is found in most xUnit implementations. Thanks to Kent Beck.
Money-Port: This shows how the Money example can be ported from Version 1 of NUnit with minimal changes.
Syntax: Illustrates most Assert methods using both the classic and constraint-based syntax.
JSharp: Samples in J#
Failures: Demonstrates 4 failing tests and one that is not run.
CPP: C++ Samples
MANAGED: Managed C++ Samples (VS 2003 compatible)
Failures: Demonstrates 4 failing tests and one that is not run.
CPP-CLI: C++/CLI Samples (VS 2005 only)
Failures: Demonstrates 4 failing tests and one that is not run.
Syntax: Illustrates most Assert methods using both the classic and constraint-based syntax.
VB: Samples in VB.NET
Failures: Demonstrates 4 failing tests and one that is not run.
Money: This is a VB.NET version of the money example found in most xUnit implementations. Thanks to Kent Beck.
Syntax: Illustrates most Assert methods using both the classic and constraint-based syntax.
Extensibility: Examples of extending NUnit
Framework:
Core:
TestSuiteExtension
TestFixtureExtension
Building the Samples
A Visual Studio 2003 project is included for most samples.
Visual Studio 2005 will convert the format automatically upon
opening it. The C++/CLI samples, as well as other samples that
depend on .NET 2.0 features, include Visual Studio 2005 projects.
In most cases, you will need to remove the reference to the
nunit.framework assembly and replace it with a reference to
your installed copy of NUnit.
To build using the Microsoft compiler, use a command similar
to the following:
csc /target:library /r:/nunit.framework.dll example.cs
To build using the mono compiler, use a command like this:
msc /target:library /r:/nunit.framework.dll example.cs
NUnit-2.6.0.12051/samples/jsharp/ 0000775 0001750 0001750 00000000000 11742560362 016120 5 ustar jtaylor jtaylor NUnit-2.6.0.12051/samples/jsharp/jsharp.sln 0000664 0001750 0001750 00000001635 11504175260 020125 0 ustar jtaylor jtaylor Microsoft Visual Studio Solution File, Format Version 8.00
Project("{E6FDF86B-F3D1-11D4-8576-0002A516ECE8}") = "jsharp-failures", "failures\jsharp-failures.vjsproj", "{B55A6E53-57A9-4205-B396-C9983B3AF46A}"
ProjectSection(ProjectDependencies) = postProject
EndProjectSection
EndProject
Global
GlobalSection(SolutionConfiguration) = preSolution
Debug = Debug
Release = Release
EndGlobalSection
GlobalSection(ProjectConfiguration) = postSolution
{B55A6E53-57A9-4205-B396-C9983B3AF46A}.Debug.ActiveCfg = Debug|.NET
{B55A6E53-57A9-4205-B396-C9983B3AF46A}.Debug.Build.0 = Debug|.NET
{B55A6E53-57A9-4205-B396-C9983B3AF46A}.Release.ActiveCfg = Release|.NET
{B55A6E53-57A9-4205-B396-C9983B3AF46A}.Release.Build.0 = Release|.NET
EndGlobalSection
GlobalSection(ExtensibilityGlobals) = postSolution
EndGlobalSection
GlobalSection(ExtensibilityAddIns) = postSolution
EndGlobalSection
EndGlobal
NUnit-2.6.0.12051/samples/jsharp/failures/ 0000775 0001750 0001750 00000000000 11742560362 017732 5 ustar jtaylor jtaylor NUnit-2.6.0.12051/samples/jsharp/failures/JSharpTest.jsl 0000664 0001750 0001750 00000003433 11504175260 022471 0 ustar jtaylor jtaylor // ****************************************************************
// This is free software licensed under the NUnit license. You
// may obtain a copy of the license as well as information regarding
// copyright ownership at http://nunit.org/?p=license&r=2.4.
// ****************************************************************
package NUnit.Samples;
import System.*;
import NUnit.Framework.Assert;
/** @attribute NUnit.Framework.TestFixture() */
public class SimpleJSharpTest
{
protected int fValue1;
protected int fValue2;
/** @attribute NUnit.Framework.SetUp() */
public void Init()
{
fValue1 = 2;
fValue2 = 3;
}
/** @attribute NUnit.Framework.Test() */
public void Add()
{
int result= fValue1 + fValue2;
Assert.AreEqual(6,result, "Expected Failure");
}
/** @attribute NUnit.Framework.Test() */
public void DivideByZero()
{
int zero= 0;
int result = 8/zero;
KeepCompilerFromWarning(result); // never executed, here to avoid compiler warning that result is unused.
}
/** @attribute NUnit.Framework.Test() */
public void Equals()
{
Assert.AreEqual(12, 12, "Integer");
Assert.AreEqual(new Long(12), new Long(13), "Long");
Assert.AreEqual('a', 'a', "Char");
Assert.AreEqual(new Integer(12), new Integer(12), "Integer Object Cast");
Assert.AreEqual(12, 13, "Expected Failure (Integer)");
Assert.AreEqual(12.0, 11.99, 0.0, "Expected Failure (Double).");
}
/** @attribute NUnit.Framework.Test() */
/** @attribute NUnit.Framework.Ignore("ignored test") */
public void IgnoredTest()
{
throw new InvalidCastException();
}
// A useless function, designed to avoid a compiler warning in the the DivideByZero test.
private int KeepCompilerFromWarning(int dummy)
{
return dummy;
}
} NUnit-2.6.0.12051/samples/jsharp/failures/AssemblyInfo.jsl 0000664 0001750 0001750 00000004567 11504175260 023046 0 ustar jtaylor jtaylor import System.Reflection.*;
import System.Runtime.CompilerServices.*;
//
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
//
/** @assembly AssemblyTitle("") */
/** @assembly AssemblyDescription("") */
/** @assembly AssemblyConfiguration("") */
/** @assembly AssemblyCompany("") */
/** @assembly AssemblyProduct("") */
/** @assembly AssemblyCopyright("") */
/** @assembly AssemblyTrademark("") */
/** @assembly AssemblyCulture("") */
//
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// You can specify all the values or you can default the Revision and Build
// Numbers by using the '*' as shown below:
/** @assembly AssemblyVersion("2.2.0.0") */
//
// In order to sign your assembly you must specify a key to use. Refer to the
// Microsoft .NET Framework documentation for more information on assembly signing.
//
// Use the attributes below to control which key is used for signing.
//
// Notes:
// (*) If no key is specified, the assembly is not signed.
// (*) KeyName refers to a key that has been installed in the Crypto Service
// Provider (CSP) on your machine. KeyFile refers to a file which contains
// a key.
// (*) If the KeyFile and the KeyName values are both specified, the
// following processing occurs:
// (1) If the KeyName can be found in the CSP, that key is used.
// (2) If the KeyName does not exist and the KeyFile does exist, the key
// in the KeyFile is installed into the CSP and used.
// (*) In order to create a KeyFile, you can use the sn.exe (Strong Name) utility.
// When specifying the KeyFile, the location of the KeyFile should be
// relative to the project directory. For example, if your KeyFile is
// located in the project directory itself, you would specify the
// AssemblyKeyFile attribute as @assembly AssemblyKeyFile("mykey.snk")
// (*) Delay Signing is an advanced option - see the Microsoft .NET Framework
// documentation for more information on this.
//
/** @assembly AssemblyDelaySign(false) */
/** @assembly AssemblyKeyFile("") */
/** @assembly AssemblyKeyName("") */
NUnit-2.6.0.12051/samples/jsharp/failures/jsharp-failures.build 0000664 0001750 0001750 00000000416 11504175260 024046 0 ustar jtaylor jtaylor
NUnit-2.6.0.12051/samples/jsharp/failures/jsharp-failures.vjsproj 0000664 0001750 0001750 00000003274 11720516414 024451 0 ustar jtaylor jtaylor NUnit-2.6.0.12051/samples/Extensibility/ 0000775 0001750 0001750 00000000000 11742560362 017465 5 ustar jtaylor jtaylor NUnit-2.6.0.12051/samples/Extensibility/Core/ 0000775 0001750 0001750 00000000000 11742560362 020355 5 ustar jtaylor jtaylor NUnit-2.6.0.12051/samples/Extensibility/Core/SampleSuiteExtension/ 0000775 0001750 0001750 00000000000 11742560362 024505 5 ustar jtaylor jtaylor NUnit-2.6.0.12051/samples/Extensibility/Core/SampleSuiteExtension/SampleSuiteExtensionAttribute.cs 0000664 0001750 0001750 00000001160 11504175260 033041 0 ustar jtaylor jtaylor // ****************************************************************
// Copyright 2007, Charlie Poole
// This is free software licensed under the NUnit license. You may
// obtain a copy of the license at http://nunit.org/?p=license&r=2.4
// ****************************************************************
using System;
namespace NUnit.Core.Extensions
{
///
/// SampleSuiteExtensionAttribute is used to identify a SampleSuiteExtension fixture
///
[AttributeUsage(AttributeTargets.Class, AllowMultiple=false)]
public sealed class SampleSuiteExtensionAttribute : Attribute
{
}
}
NUnit-2.6.0.12051/samples/Extensibility/Core/SampleSuiteExtension/Addin.cs 0000664 0001750 0001750 00000001614 11504175260 026050 0 ustar jtaylor jtaylor // ****************************************************************
// Copyright 2007, Charlie Poole
// This is free software licensed under the NUnit license. You may
// obtain a copy of the license at http://nunit.org/?p=license&r=2.4
// ****************************************************************
using System;
using NUnit.Core.Extensibility;
namespace NUnit.Core.Extensions
{
///
/// Summary description for Addin.
///
[NUnitAddin(Name="SampleSuiteExtension", Description = "Recognizes Tests starting with SampleTest...")]
public class Addin : IAddin
{
#region IAddin Members
public bool Install(IExtensionHost host)
{
IExtensionPoint builders = host.GetExtensionPoint( "SuiteBuilders" );
if ( builders == null )
return false;
builders.Install( new SampleSuiteExtensionBuilder() );
return true;
}
#endregion
}
}
NUnit-2.6.0.12051/samples/Extensibility/Core/SampleSuiteExtension/SampleSuiteExtension.cs 0000664 0001750 0001750 00000003033 11504175260 031156 0 ustar jtaylor jtaylor // ****************************************************************
// Copyright 2007, Charlie Poole
// This is free software licensed under the NUnit license. You may
// obtain a copy of the license at http://nunit.org/?p=license&r=2.4
// ****************************************************************
using System;
using System.Reflection;
namespace NUnit.Core.Extensions
{
///
/// SampleSuiteExtension is a minimal example of a suite extension. It
/// extends test suite and creates a fixture that runs every test starting
/// with "SampleTest..." Because it inherits from TestSuite, rather than
/// TestFixture, it has to construct its own fixture object and find its
/// own tests. Everything is done in the constructor for simplicity.
///
class SampleSuiteExtension : TestSuite
{
public SampleSuiteExtension( Type fixtureType )
: base( fixtureType )
{
// Create the fixture object. We could wait to do this when
// it is needed, but we do it here for simplicity.
this.Fixture = Reflect.Construct( fixtureType );
// Locate our test methods and add them to the suite using
// the Add method of TestSuite. Note that we don't do a simple
// Tests.Add, because that wouldn't set the parent of the tests.
foreach( MethodInfo method in fixtureType.GetMethods(
BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly ) )
{
if ( method.Name.StartsWith( "SampleTest" ) )
this.Add( new NUnitTestMethod( method ) );
}
}
}
}
NUnit-2.6.0.12051/samples/Extensibility/Core/SampleSuiteExtension/SampleSuiteExtension.build 0000664 0001750 0001750 00000001041 11504175260 031645 0 ustar jtaylor jtaylor
NUnit-2.6.0.12051/samples/Extensibility/Core/SampleSuiteExtension/AssemblyInfo.cs 0000664 0001750 0001750 00000004572 11504175260 027432 0 ustar jtaylor jtaylor using System.Reflection;
using System.Runtime.CompilerServices;
//
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
//
[assembly: AssemblyTitle("")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("")]
[assembly: AssemblyCopyright("")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
//
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// You can specify all the values or you can default the Revision and Build Numbers
// by using the '*' as shown below:
[assembly: AssemblyVersion("1.0.*")]
//
// In order to sign your assembly you must specify a key to use. Refer to the
// Microsoft .NET Framework documentation for more information on assembly signing.
//
// Use the attributes below to control which key is used for signing.
//
// Notes:
// (*) If no key is specified, the assembly is not signed.
// (*) KeyName refers to a key that has been installed in the Crypto Service
// Provider (CSP) on your machine. KeyFile refers to a file which contains
// a key.
// (*) If the KeyFile and the KeyName values are both specified, the
// following processing occurs:
// (1) If the KeyName can be found in the CSP, that key is used.
// (2) If the KeyName does not exist and the KeyFile does exist, the key
// in the KeyFile is installed into the CSP and used.
// (*) In order to create a KeyFile, you can use the sn.exe (Strong Name) utility.
// When specifying the KeyFile, the location of the KeyFile should be
// relative to the project output directory which is
// %Project Directory%\obj\. For example, if your KeyFile is
// located in the project directory, you would specify the AssemblyKeyFile
// attribute as [assembly: AssemblyKeyFile("..\\..\\mykey.snk")]
// (*) Delay Signing is an advanced option - see the Microsoft .NET Framework
// documentation for more information on this.
//
[assembly: AssemblyDelaySign(false)]
[assembly: AssemblyKeyFile("")]
[assembly: AssemblyKeyName("")]
NUnit-2.6.0.12051/samples/Extensibility/Core/SampleSuiteExtension/Tests/ 0000775 0001750 0001750 00000000000 11742560362 025607 5 ustar jtaylor jtaylor ././@LongLink 0000000 0000000 0000000 00000000151 00000000000 011562 L ustar root root NUnit-2.6.0.12051/samples/Extensibility/Core/SampleSuiteExtension/Tests/SampleSuiteExtensionTests.csproj NUnit-2.6.0.12051/samples/Extensibility/Core/SampleSuiteExtension/Tests/SampleSuiteExtensionTests.cs0000664 0001750 0001750 00000007051 11504175260 033307 0 ustar jtaylor jtaylor
NUnit-2.6.0.12051/samples/Extensibility/Core/SampleSuiteExtension/Tests/SampleSuiteExtensionTests.cs0000664 0001750 0001750 00000001506 11504175260 033306 0 ustar jtaylor jtaylor // ****************************************************************
// Copyright 2007, Charlie Poole
// This is free software licensed under the NUnit license. You may
// obtain a copy of the license at http://nunit.org/?p=license&r=2.4
// ****************************************************************
using System;
using System.Reflection;
namespace NUnit.Core.Extensions.Tests
{
///
/// Test class that demonstrates SampleSuiteExtension
///
[SampleSuiteExtension]
public class SampleSuiteExtensionTests
{
public void SampleTest1()
{
Console.WriteLine( "Hello from sample test 1" );
}
public void SampleTest2()
{
Console.WriteLine( "Hello from sample test 2" );
}
public void NotATest()
{
Console.WriteLine( "I shouldn't be called!" );
}
}
}
NUnit-2.6.0.12051/samples/Extensibility/Core/SampleSuiteExtension/SampleSuiteExtensionBuilder.cs 0000664 0001750 0001750 00000002656 11504175260 032477 0 ustar jtaylor jtaylor // ****************************************************************
// Copyright 2007, Charlie Poole
// This is free software licensed under the NUnit license. You may
// obtain a copy of the license at http://nunit.org/?p=license&r=2.4
// ****************************************************************
using System;
using NUnit.Core.Extensibility;
namespace NUnit.Core.Extensions
{
///
/// SampleSuiteExtensionBuilder knows how to build a SampleSuiteExtension
///
public class SampleSuiteExtensionBuilder : ISuiteBuilder
{
#region ISuiteBuilder Members
// This builder delegates all the work to the constructor of the
// extension suite. Many builders will need to do more work,
// looking for other attributes, setting properties on the
// suite and locating methods for tests, setup and teardown.
public Test BuildFrom(Type type)
{
if ( CanBuildFrom( type ) )
return new SampleSuiteExtension( type );
return null;
}
// The builder recognizes the types that it can use by the presense
// of SampleSuiteExtensionAttribute. Note that an attribute does not
// have to be used. You can use any arbitrary set of rules that can be
// implemented using reflection on the type.
public bool CanBuildFrom(Type type)
{
return Reflect.HasAttribute( type, "NUnit.Core.Extensions.SampleSuiteExtensionAttribute", false );
}
#endregion
}
}
NUnit-2.6.0.12051/samples/Extensibility/Core/SampleSuiteExtension/SampleSuiteExtension.csproj 0000664 0001750 0001750 00000010347 11504175260 032057 0 ustar jtaylor jtaylor
NUnit-2.6.0.12051/samples/Extensibility/Core/SampleSuiteExtension/ReadMe.txt 0000664 0001750 0001750 00000003404 11504175260 026377 0 ustar jtaylor jtaylor SampleSuiteExtension Example
This is a minimal example of a SuiteBuilder extension. It extends
NUnit.Core.TestSuite test suite and creates a fixture that runs every
test starting with "SampleTest..." It packages both the core extension
and the attribute used in the tests in the same assembly.
SampleSuiteExtension Class
This class derives from NUnit.Framework.TestSuite and represents the
extended suite within NUnit. Because it inherits from TestSuite,
rather than TestFixture, it has to construct its own fixture object and
find its own tests. Everything is done in the constructor for simplicity.
SampleSuiteExtensionBuilder
This class is the actual SuiteBuilder loaded by NUnit as an add-in.
It recognizes the SampleSuiteExtensionAttribute and invokes the
SampleSuiteExtension constructor to build the suite.
SampleSuiteExtensionAttribute
This is the special attribute used to mark tests to be constructed
using this add-in. It is the only class referenced from the user tests.
Note on Building this Extension
If you use the Visual Studio solution, the NUnit references in both
included projects must be changed so that they refer to the copy of
NUnit in which you want to install the extension. The post-build step
for the SampleSuiteExtension project must be changed to copy the
extension into the addins directory for your NUnit install.
NOTE:
The references to nunit.core and nunit.common in the
SampleSuiteExtension project have their Copy Local property set to
false, rather than the Visual Studio default of true. In developing
extensions, it is essential there be no extra copies of these assemblies
be created. Once the extension is complete, those who install it in
binary form will not need to deal with this issue.
NUnit-2.6.0.12051/samples/Extensibility/Core/SampleFixtureExtension/ 0000775 0001750 0001750 00000000000 11742560362 025042 5 ustar jtaylor jtaylor ././@LongLink 0000000 0000000 0000000 00000000147 00000000000 011567 L ustar root root NUnit-2.6.0.12051/samples/Extensibility/Core/SampleFixtureExtension/SampleFixtureExtensionAttribute.cs NUnit-2.6.0.12051/samples/Extensibility/Core/SampleFixtureExtension/SampleFixtureExtensionAttribute.0000664 0001750 0001750 00000001164 11504175260 033411 0 ustar jtaylor jtaylor // ****************************************************************
// Copyright 2007, Charlie Poole
// This is free software licensed under the NUnit license. You may
// obtain a copy of the license at http://nunit.org/?p=license&r=2.4
// ****************************************************************
using System;
namespace NUnit.Core.Extensions
{
///
/// SampleFixtureExtensionAttribute is used to identify a SampleFixtureExtension class
///
[AttributeUsage(AttributeTargets.Class, AllowMultiple=false)]
public sealed class SampleFixtureExtensionAttribute : Attribute
{
}
}
NUnit-2.6.0.12051/samples/Extensibility/Core/SampleFixtureExtension/AssemblyInfo.cs 0000664 0001750 0001750 00000004572 11504175260 027767 0 ustar jtaylor jtaylor using System.Reflection;
using System.Runtime.CompilerServices;
//
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
//
[assembly: AssemblyTitle("")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("")]
[assembly: AssemblyCopyright("")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
//
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// You can specify all the values or you can default the Revision and Build Numbers
// by using the '*' as shown below:
[assembly: AssemblyVersion("1.0.*")]
//
// In order to sign your assembly you must specify a key to use. Refer to the
// Microsoft .NET Framework documentation for more information on assembly signing.
//
// Use the attributes below to control which key is used for signing.
//
// Notes:
// (*) If no key is specified, the assembly is not signed.
// (*) KeyName refers to a key that has been installed in the Crypto Service
// Provider (CSP) on your machine. KeyFile refers to a file which contains
// a key.
// (*) If the KeyFile and the KeyName values are both specified, the
// following processing occurs:
// (1) If the KeyName can be found in the CSP, that key is used.
// (2) If the KeyName does not exist and the KeyFile does exist, the key
// in the KeyFile is installed into the CSP and used.
// (*) In order to create a KeyFile, you can use the sn.exe (Strong Name) utility.
// When specifying the KeyFile, the location of the KeyFile should be
// relative to the project output directory which is
// %Project Directory%\obj\. For example, if your KeyFile is
// located in the project directory, you would specify the AssemblyKeyFile
// attribute as [assembly: AssemblyKeyFile("..\\..\\mykey.snk")]
// (*) Delay Signing is an advanced option - see the Microsoft .NET Framework
// documentation for more information on this.
//
[assembly: AssemblyDelaySign(false)]
[assembly: AssemblyKeyFile("")]
[assembly: AssemblyKeyName("")]
NUnit-2.6.0.12051/samples/Extensibility/Core/SampleFixtureExtension/SampleFixtureExtension.csproj 0000664 0001750 0001750 00000010241 11504175260 032742 0 ustar jtaylor jtaylor
NUnit-2.6.0.12051/samples/Extensibility/Core/SampleFixtureExtension/Tests/ 0000775 0001750 0001750 00000000000 11742560362 026144 5 ustar jtaylor jtaylor NUnit-2.6.0.12051/samples/Extensibility/Core/SampleFixtureExtension/Tests/AssemblyInfo.cs 0000664 0001750 0001750 00000004572 11504175260 031071 0 ustar jtaylor jtaylor using System.Reflection;
using System.Runtime.CompilerServices;
//
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
//
[assembly: AssemblyTitle("")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("")]
[assembly: AssemblyCopyright("")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
//
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// You can specify all the values or you can default the Revision and Build Numbers
// by using the '*' as shown below:
[assembly: AssemblyVersion("1.0.*")]
//
// In order to sign your assembly you must specify a key to use. Refer to the
// Microsoft .NET Framework documentation for more information on assembly signing.
//
// Use the attributes below to control which key is used for signing.
//
// Notes:
// (*) If no key is specified, the assembly is not signed.
// (*) KeyName refers to a key that has been installed in the Crypto Service
// Provider (CSP) on your machine. KeyFile refers to a file which contains
// a key.
// (*) If the KeyFile and the KeyName values are both specified, the
// following processing occurs:
// (1) If the KeyName can be found in the CSP, that key is used.
// (2) If the KeyName does not exist and the KeyFile does exist, the key
// in the KeyFile is installed into the CSP and used.
// (*) In order to create a KeyFile, you can use the sn.exe (Strong Name) utility.
// When specifying the KeyFile, the location of the KeyFile should be
// relative to the project output directory which is
// %Project Directory%\obj\. For example, if your KeyFile is
// located in the project directory, you would specify the AssemblyKeyFile
// attribute as [assembly: AssemblyKeyFile("..\\..\\mykey.snk")]
// (*) Delay Signing is an advanced option - see the Microsoft .NET Framework
// documentation for more information on this.
//
[assembly: AssemblyDelaySign(false)]
[assembly: AssemblyKeyFile("")]
[assembly: AssemblyKeyName("")]
././@LongLink 0000000 0000000 0000000 00000000155 00000000000 011566 L ustar root root NUnit-2.6.0.12051/samples/Extensibility/Core/SampleFixtureExtension/Tests/SampleFixtureExtensionTests.csproj NUnit-2.6.0.12051/samples/Extensibility/Core/SampleFixtureExtension/Tests/SampleFixtureExtensionTest0000664 0001750 0001750 00000007054 11504175260 033415 0 ustar jtaylor jtaylor
././@LongLink 0000000 0000000 0000000 00000000151 00000000000 011562 L ustar root root NUnit-2.6.0.12051/samples/Extensibility/Core/SampleFixtureExtension/Tests/SampleFixtureExtensionTests.cs NUnit-2.6.0.12051/samples/Extensibility/Core/SampleFixtureExtension/Tests/SampleFixtureExtensionTest0000664 0001750 0001750 00000002136 11504175260 033411 0 ustar jtaylor jtaylor // ****************************************************************
// Copyright 2007, Charlie Poole
// This is free software licensed under the NUnit license. You may
// obtain a copy of the license at http://nunit.org/?p=license&r=2.4
// ****************************************************************
using System;
using NUnit.Framework;
using NUnit.Core.Extensions;
namespace NUnit.Extensions.Tests
{
///
/// Test class that demonstrates SampleFixtureExtension
///
[SampleFixtureExtension]
public class SampleFixtureExtensionTests
{
[TestFixtureSetUp]
public void SetUpTests()
{
Console.WriteLine( "TestFixtureSetUp called" );
}
[TestFixtureTearDown]
public void FixtureTearDown()
{
Console.WriteLine( "TestFixtureTearDown called" );
}
[Test]
public void SomeTest()
{
Console.WriteLine( "Hello from some test" );
}
[Test]
public void AnotherTest()
{
Console.WriteLine( "Hello from another test" );
}
public void NotATest()
{
Console.WriteLine( "I shouldn't be called!" );
}
}
}
NUnit-2.6.0.12051/samples/Extensibility/Core/SampleFixtureExtension/SampleFixtureExtensionBuilder.cs0000664 0001750 0001750 00000003523 11504175260 033363 0 ustar jtaylor jtaylor // ****************************************************************
// Copyright 2007, Charlie Poole
// This is free software licensed under the NUnit license. You may
// obtain a copy of the license at http://nunit.org/?p=license&r=2.4
// ****************************************************************
using System;
using NUnit.Core.Builders;
using NUnit.Core.Extensibility;
namespace NUnit.Core.Extensions
{
///
/// MockFixtureExtensionBuilder knows how to build
/// a MockFixtureExtension.
///
[NUnitAddin(Description="Wraps an NUnitTestFixture with an additional level of SetUp and TearDown")]
public class SampleFixtureExtensionBuilder : ISuiteBuilder, IAddin
{
#region NUnitTestFixtureBuilder Overrides
///
/// Makes a SampleFixtureExtension instance
///
/// The type to be used
/// A SampleFixtureExtension as a TestSuite
// protected override TestSuite MakeSuite(Type type)
// {
// return new SampleFixtureExtension( type );
// }
// The builder recognizes the types that it can use by the presense
// of SampleFixtureExtensionAttribute. Note that an attribute does not
// have to be used. You can use any arbitrary set of rules that can be
// implemented using reflection on the type.
public bool CanBuildFrom(Type type)
{
return Reflect.HasAttribute( type, "NUnit.Core.Extensions.SampleFixtureExtensionAttribute", false );
}
public Test BuildFrom(Type type)
{
return null;
}
#endregion
#region IAddin Members
public bool Install(IExtensionHost host)
{
IExtensionPoint suiteBuilders = host.GetExtensionPoint( "SuiteBuilders" );
if ( suiteBuilders == null )
return false;
suiteBuilders.Install( this );
return true;
}
#endregion
}
}
NUnit-2.6.0.12051/samples/Extensibility/Core/SampleFixtureExtension/ReadMe.txt 0000664 0001750 0001750 00000003404 11504175260 026734 0 ustar jtaylor jtaylor SampleSuiteExtension Example
This is a minimal example of a SuiteBuilder extension. It extends
NUnit.Core.TestSuite test suite and creates a fixture that runs every
test starting with "SampleTest..." It packages both the core extension
and the attribute used in the tests in the same assembly.
SampleSuiteExtension Class
This class derives from NUnit.Framework.TestSuite and represents the
extended suite within NUnit. Because it inherits from TestSuite,
rather than TestFixture, it has to construct its own fixture object and
find its own tests. Everything is done in the constructor for simplicity.
SampleSuiteExtensionBuilder
This class is the actual SuiteBuilder loaded by NUnit as an add-in.
It recognizes the SampleSuiteExtensionAttribute and invokes the
SampleSuiteExtension constructor to build the suite.
SampleSuiteExtensionAttribute
This is the special attribute used to mark tests to be constructed
using this add-in. It is the only class referenced from the user tests.
Note on Building this Extension
If you use the Visual Studio solution, the NUnit references in both
included projects must be changed so that they refer to the copy of
NUnit in which you want to install the extension. The post-build step
for the SampleSuiteExtension project must be changed to copy the
extension into the addins directory for your NUnit install.
NOTE:
The references to nunit.core and nunit.common in the
SampleSuiteExtension project have their Copy Local property set to
false, rather than the Visual Studio default of true. In developing
extensions, it is essential there be no extra copies of these assemblies
be created. Once the extension is complete, those who install it in
binary form will not need to deal with this issue.
NUnit-2.6.0.12051/samples/Extensibility/Core/SampleFixtureExtension/SampleFixtureExtension.build 0000664 0001750 0001750 00000001064 11504175260 032544 0 ustar jtaylor jtaylor
NUnit-2.6.0.12051/samples/Extensibility/Core/SampleFixtureExtension/SampleFixtureExtension.cs 0000664 0001750 0001750 00000003134 11504175260 032052 0 ustar jtaylor jtaylor // ****************************************************************
// Copyright 2007, Charlie Poole
// This is free software licensed under the NUnit license. You may
// obtain a copy of the license at http://nunit.org/?p=license&r=2.4
// ****************************************************************
using System;
namespace NUnit.Core.Extensions
{
///
/// SampleFixtureExtension extends NUnitTestFixture and adds a custom setup
/// before running TestFixtureSetUp and after running TestFixtureTearDown.
/// Because it inherits from NUnitTestFixture, a lot of work is done for it.
///
class SampleFixtureExtension : NUnitTestFixture
{
public SampleFixtureExtension( Type fixtureType )
: base( fixtureType )
{
// NOTE: Since we are inheriting from NUnitTestFixture we don't
// have to do anything if we don't want to. All the attributes
// that are normally used with an NUnitTestFixture will be
// recognized.
//
// Just to have something to do, we override DoOneTimeSetUp and
// DoOneTimeTearDown below to do some special processing before
// and after the normal TestFixtureSetUp and TestFixtureTearDown.
// In this example, we simply display a message.
}
protected override void DoOneTimeSetUp(TestResult suiteResult)
{
Console.WriteLine( "Extended Fixture SetUp called" );
base.DoOneTimeSetUp (suiteResult);
}
protected override void DoOneTimeTearDown(TestResult suiteResult)
{
base.DoOneTimeTearDown (suiteResult);
Console.WriteLine( "Extended Fixture TearDown called" );
}
}
}
NUnit-2.6.0.12051/samples/Extensibility/Core/CoreExtensibility.sln 0000664 0001750 0001750 00000006057 11504175260 024543 0 ustar jtaylor jtaylor Microsoft Visual Studio Solution File, Format Version 8.00
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Minimal", "Minimal\Minimal.csproj", "{EF428E5B-B3E7-4C2F-B005-98DE7D6E7CDB}"
ProjectSection(ProjectDependencies) = postProject
EndProjectSection
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SampleFixtureExtension", "SampleFixtureExtension\SampleFixtureExtension.csproj", "{ED281A23-9579-4A70-B608-1B86DCDEB78C}"
ProjectSection(ProjectDependencies) = postProject
EndProjectSection
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SampleFixtureExtensionTests", "SampleFixtureExtension\Tests\SampleFixtureExtensionTests.csproj", "{0DE6C90F-BB74-4BC8-887A-2222DB56D2EB}"
ProjectSection(ProjectDependencies) = postProject
EndProjectSection
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SampleSuiteExtension", "SampleSuiteExtension\SampleSuiteExtension.csproj", "{0C4269EE-3266-45DD-9062-E356C067FBEF}"
ProjectSection(ProjectDependencies) = postProject
EndProjectSection
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SampleSuiteExtensionTests", "SampleSuiteExtension\Tests\SampleSuiteExtensionTests.csproj", "{9F609A0D-FF7E-4F0C-B2DF-417EBC557CFF}"
ProjectSection(ProjectDependencies) = postProject
EndProjectSection
EndProject
Global
GlobalSection(SolutionConfiguration) = preSolution
Debug = Debug
Release = Release
EndGlobalSection
GlobalSection(ProjectConfiguration) = postSolution
{EF428E5B-B3E7-4C2F-B005-98DE7D6E7CDB}.Debug.ActiveCfg = Debug|.NET
{EF428E5B-B3E7-4C2F-B005-98DE7D6E7CDB}.Debug.Build.0 = Debug|.NET
{EF428E5B-B3E7-4C2F-B005-98DE7D6E7CDB}.Release.ActiveCfg = Release|.NET
{EF428E5B-B3E7-4C2F-B005-98DE7D6E7CDB}.Release.Build.0 = Release|.NET
{ED281A23-9579-4A70-B608-1B86DCDEB78C}.Debug.ActiveCfg = Debug|.NET
{ED281A23-9579-4A70-B608-1B86DCDEB78C}.Debug.Build.0 = Debug|.NET
{ED281A23-9579-4A70-B608-1B86DCDEB78C}.Release.ActiveCfg = Release|.NET
{ED281A23-9579-4A70-B608-1B86DCDEB78C}.Release.Build.0 = Release|.NET
{0DE6C90F-BB74-4BC8-887A-2222DB56D2EB}.Debug.ActiveCfg = Debug|.NET
{0DE6C90F-BB74-4BC8-887A-2222DB56D2EB}.Debug.Build.0 = Debug|.NET
{0DE6C90F-BB74-4BC8-887A-2222DB56D2EB}.Release.ActiveCfg = Release|.NET
{0DE6C90F-BB74-4BC8-887A-2222DB56D2EB}.Release.Build.0 = Release|.NET
{0C4269EE-3266-45DD-9062-E356C067FBEF}.Debug.ActiveCfg = Debug|.NET
{0C4269EE-3266-45DD-9062-E356C067FBEF}.Debug.Build.0 = Debug|.NET
{0C4269EE-3266-45DD-9062-E356C067FBEF}.Release.ActiveCfg = Release|.NET
{0C4269EE-3266-45DD-9062-E356C067FBEF}.Release.Build.0 = Release|.NET
{9F609A0D-FF7E-4F0C-B2DF-417EBC557CFF}.Debug.ActiveCfg = Debug|.NET
{9F609A0D-FF7E-4F0C-B2DF-417EBC557CFF}.Debug.Build.0 = Debug|.NET
{9F609A0D-FF7E-4F0C-B2DF-417EBC557CFF}.Release.ActiveCfg = Release|.NET
{9F609A0D-FF7E-4F0C-B2DF-417EBC557CFF}.Release.Build.0 = Release|.NET
EndGlobalSection
GlobalSection(ExtensibilityGlobals) = postSolution
EndGlobalSection
GlobalSection(ExtensibilityAddIns) = postSolution
EndGlobalSection
EndGlobal
NUnit-2.6.0.12051/samples/Extensibility/Core/Minimal/ 0000775 0001750 0001750 00000000000 11742560362 021743 5 ustar jtaylor jtaylor NUnit-2.6.0.12051/samples/Extensibility/Core/Minimal/Minimal.csproj 0000664 0001750 0001750 00000006546 11504175260 024561 0 ustar jtaylor jtaylor
NUnit-2.6.0.12051/samples/Extensibility/Core/Minimal/ReadMe.txt 0000664 0001750 0001750 00000001767 11504175260 023647 0 ustar jtaylor jtaylor Minimal Addin Example
MinimalAddin Class
This class represents the addin. It is marked by the NUnitAddinAttribute
and implements the required IAddin interface. When called by NUnit to
install itself, it simply returns false.
Note on Building this Extension
If you use the Visual Studio solution, the NUnit references in both
included projects must be changed so that they refer to the copy of
NUnit in which you want to install the extension. The post-build step
for the SampleSuiteExtension project must be changed to copy the
extension into the addins directory for your NUnit install.
NOTE:
The references to nunit.core and nunit.common in the
SampleSuiteExtension project have their Copy Local property set to
false, rather than the Visual Studio default of true. In developing
extensions, it is essential there be no extra copies of these assemblies
be created. Once the extension is complete, those who install it in
binary form will not need to deal with this issue.
NUnit-2.6.0.12051/samples/Extensibility/Core/Minimal/Minimal.cs 0000664 0001750 0001750 00000002342 11504175260 023654 0 ustar jtaylor jtaylor // ****************************************************************
// Copyright 2007, Charlie Poole
// This is free software licensed under the NUnit license. You may
// obtain a copy of the license at http://nunit.org/?p=license&r=2.4
// ****************************************************************
using System;
using NUnit.Core.Extensibility;
namespace NUnit.Samples.Extensibility
{
///
/// This is the smallest possible Addin, which does nothing
/// but is recognized by NUnit and listed in the Addins dialog.
///
/// The Addin class is marked by the NUnitAddin attribute and
/// implements IAddin, as required. Optional property syntax
/// is used here to override the default name of the addin and
/// to provide a description. Both are displayed by NUnit in the
/// Addin Dialog.
///
/// The addin doesn't actually install anything, but simply
/// returns false in its Install method.
///
[NUnitAddin(Name="Minimal Addin", Description="This Addin doesn't do anything")]
public class Minimal : IAddin
{
#region IAddin Members
public bool Install(IExtensionHost host)
{
// TODO: Add Minimal.Install implementation
return true;
}
#endregion
}
}
NUnit-2.6.0.12051/samples/Extensibility/Core/Minimal/Minimal.build 0000664 0001750 0001750 00000001074 11504175260 024347 0 ustar jtaylor jtaylor
NUnit-2.6.0.12051/samples/csharp/ 0000775 0001750 0001750 00000000000 11742560362 016111 5 ustar jtaylor jtaylor NUnit-2.6.0.12051/samples/csharp/money/ 0000775 0001750 0001750 00000000000 11742560362 017240 5 ustar jtaylor jtaylor NUnit-2.6.0.12051/samples/csharp/money/AssemblyInfo.cs 0000664 0001750 0001750 00000004574 11504175260 022167 0 ustar jtaylor jtaylor using System.Reflection;
using System.Runtime.CompilerServices;
//
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
//
[assembly: AssemblyTitle("")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("")]
[assembly: AssemblyCopyright("")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
//
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// You can specify all the values or you can default the Revision and Build Numbers
// by using the '*' as shown below:
[assembly: AssemblyVersion("2.2.0.0")]
//
// In order to sign your assembly you must specify a key to use. Refer to the
// Microsoft .NET Framework documentation for more information on assembly signing.
//
// Use the attributes below to control which key is used for signing.
//
// Notes:
// (*) If no key is specified, the assembly is not signed.
// (*) KeyName refers to a key that has been installed in the Crypto Service
// Provider (CSP) on your machine. KeyFile refers to a file which contains
// a key.
// (*) If the KeyFile and the KeyName values are both specified, the
// following processing occurs:
// (1) If the KeyName can be found in the CSP, that key is used.
// (2) If the KeyName does not exist and the KeyFile does exist, the key
// in the KeyFile is installed into the CSP and used.
// (*) In order to create a KeyFile, you can use the sn.exe (Strong Name) utility.
// When specifying the KeyFile, the location of the KeyFile should be
// relative to the project output directory which is
// %Project Directory%\obj\. For example, if your KeyFile is
// located in the project directory, you would specify the AssemblyKeyFile
// attribute as [assembly: AssemblyKeyFile("..\\..\\mykey.snk")]
// (*) Delay Signing is an advanced option - see the Microsoft .NET Framework
// documentation for more information on this.
//
[assembly: AssemblyDelaySign(false)]
[assembly: AssemblyKeyFile("")]
[assembly: AssemblyKeyName("")]
NUnit-2.6.0.12051/samples/csharp/money/IMoney.cs 0000664 0001750 0001750 00000002301 11504175260 020756 0 ustar jtaylor jtaylor // ****************************************************************
// This is free software licensed under the NUnit license. You
// may obtain a copy of the license as well as information regarding
// copyright ownership at http://nunit.org/?p=license&r=2.4.
// ****************************************************************
namespace NUnit.Samples.Money
{
/// The common interface for simple Monies and MoneyBags.
interface IMoney
{
/// Adds a money to this money.
IMoney Add(IMoney m);
/// Adds a simple Money to this money. This is a helper method for
/// implementing double dispatch.
IMoney AddMoney(Money m);
/// Adds a MoneyBag to this money. This is a helper method for
/// implementing double dispatch.
IMoney AddMoneyBag(MoneyBag s);
/// True if this money is zero.
bool IsZero { get; }
/// Multiplies a money by the given factor.
IMoney Multiply(int factor);
/// Negates this money.
IMoney Negate();
/// Subtracts a money from this money.
IMoney Subtract(IMoney m);
}
}
NUnit-2.6.0.12051/samples/csharp/money/MoneyTest.cs 0000664 0001750 0001750 00000016665 11504175260 021527 0 ustar jtaylor jtaylor // ****************************************************************
// This is free software licensed under the NUnit license. You
// may obtain a copy of the license as well as information regarding
// copyright ownership at http://nunit.org/?p=license&r=2.4.
// ****************************************************************
namespace NUnit.Samples.Money
{
using System;
using NUnit.Framework;
///
///
///
///
[TestFixture]
public class MoneyTest
{
private Money f12CHF;
private Money f14CHF;
private Money f7USD;
private Money f21USD;
private MoneyBag fMB1;
private MoneyBag fMB2;
///
///
///
///
[SetUp]
protected void SetUp()
{
f12CHF= new Money(12, "CHF");
f14CHF= new Money(14, "CHF");
f7USD= new Money( 7, "USD");
f21USD= new Money(21, "USD");
fMB1= new MoneyBag(f12CHF, f7USD);
fMB2= new MoneyBag(f14CHF, f21USD);
}
///
///
///
///
[Test]
public void BagMultiply()
{
// {[12 CHF][7 USD]} *2 == {[24 CHF][14 USD]}
Money[] bag = { new Money(24, "CHF"), new Money(14, "USD") };
MoneyBag expected= new MoneyBag(bag);
Assert.AreEqual(expected, fMB1.Multiply(2));
Assert.AreEqual(fMB1, fMB1.Multiply(1));
Assert.IsTrue(fMB1.Multiply(0).IsZero);
}
///
///
///
///
[Test]
public void BagNegate()
{
// {[12 CHF][7 USD]} negate == {[-12 CHF][-7 USD]}
Money[] bag= { new Money(-12, "CHF"), new Money(-7, "USD") };
MoneyBag expected= new MoneyBag(bag);
Assert.AreEqual(expected, fMB1.Negate());
}
///
///
///
///
[Test]
public void BagSimpleAdd()
{
// {[12 CHF][7 USD]} + [14 CHF] == {[26 CHF][7 USD]}
Money[] bag= { new Money(26, "CHF"), new Money(7, "USD") };
MoneyBag expected= new MoneyBag(bag);
Assert.AreEqual(expected, fMB1.Add(f14CHF));
}
///
///
///
///
[Test]
public void BagSubtract()
{
// {[12 CHF][7 USD]} - {[14 CHF][21 USD] == {[-2 CHF][-14 USD]}
Money[] bag= { new Money(-2, "CHF"), new Money(-14, "USD") };
MoneyBag expected= new MoneyBag(bag);
Assert.AreEqual(expected, fMB1.Subtract(fMB2));
}
///
///
///
///
[Test]
public void BagSumAdd()
{
// {[12 CHF][7 USD]} + {[14 CHF][21 USD]} == {[26 CHF][28 USD]}
Money[] bag= { new Money(26, "CHF"), new Money(28, "USD") };
MoneyBag expected= new MoneyBag(bag);
Assert.AreEqual(expected, fMB1.Add(fMB2));
}
///
///
///
///
[Test]
public void IsZero()
{
Assert.IsTrue(fMB1.Subtract(fMB1).IsZero);
Money[] bag = { new Money(0, "CHF"), new Money(0, "USD") };
Assert.IsTrue(new MoneyBag(bag).IsZero);
}
///
///
///
///
[Test]
public void MixedSimpleAdd()
{
// [12 CHF] + [7 USD] == {[12 CHF][7 USD]}
Money[] bag= { f12CHF, f7USD };
MoneyBag expected= new MoneyBag(bag);
Assert.AreEqual(expected, f12CHF.Add(f7USD));
}
///
///
///
///
[Test]
public void MoneyBagEquals()
{
//NOTE: Normally we use Assert.AreEqual to test whether two
// objects are equal. But here we are testing the MoneyBag.Equals()
// method itself, so using AreEqual would not serve the purpose.
Assert.IsFalse(fMB1.Equals(null));
Assert.IsTrue(fMB1.Equals( fMB1 ));
MoneyBag equal= new MoneyBag(new Money(12, "CHF"), new Money(7, "USD"));
Assert.IsTrue(fMB1.Equals(equal));
Assert.IsTrue(!fMB1.Equals(f12CHF));
Assert.IsTrue(!f12CHF.Equals(fMB1));
Assert.IsTrue(!fMB1.Equals(fMB2));
}
///
///
///
///
[Test]
public void MoneyBagHash()
{
MoneyBag equal= new MoneyBag(new Money(12, "CHF"), new Money(7, "USD"));
Assert.AreEqual(fMB1.GetHashCode(), equal.GetHashCode());
}
///
///
///
///
[Test]
public void MoneyEquals()
{
//NOTE: Normally we use Assert.AreEqual to test whether two
// objects are equal. But here we are testing the MoneyBag.Equals()
// method itself, so using AreEqual would not serve the purpose.
Assert.IsFalse(f12CHF.Equals(null));
Money equalMoney= new Money(12, "CHF");
Assert.IsTrue(f12CHF.Equals( f12CHF ));
Assert.IsTrue(f12CHF.Equals( equalMoney ));
Assert.IsFalse(f12CHF.Equals(f14CHF));
}
///
///
///
///
[Test]
public void MoneyHash()
{
Assert.IsFalse(f12CHF.Equals(null));
Money equal= new Money(12, "CHF");
Assert.AreEqual(f12CHF.GetHashCode(), equal.GetHashCode());
}
///
///
///
///
[Test]
public void Normalize()
{
Money[] bag= { new Money(26, "CHF"), new Money(28, "CHF"), new Money(6, "CHF") };
MoneyBag moneyBag= new MoneyBag(bag);
Money[] expected = { new Money(60, "CHF") };
// note: expected is still a MoneyBag
MoneyBag expectedBag= new MoneyBag(expected);
Assert.AreEqual(expectedBag, moneyBag);
}
///
///
///
///
[Test]
public void Normalize2()
{
// {[12 CHF][7 USD]} - [12 CHF] == [7 USD]
Money expected= new Money(7, "USD");
Assert.AreEqual(expected, fMB1.Subtract(f12CHF));
}
///
///
///
///
[Test]
public void Normalize3()
{
// {[12 CHF][7 USD]} - {[12 CHF][3 USD]} == [4 USD]
Money[] s1 = { new Money(12, "CHF"), new Money(3, "USD") };
MoneyBag ms1= new MoneyBag(s1);
Money expected= new Money(4, "USD");
Assert.AreEqual(expected, fMB1.Subtract(ms1));
}
///
///
///
///
[Test]
public void Normalize4()
{
// [12 CHF] - {[12 CHF][3 USD]} == [-3 USD]
Money[] s1 = { new Money(12, "CHF"), new Money(3, "USD") };
MoneyBag ms1= new MoneyBag(s1);
Money expected= new Money(-3, "USD");
Assert.AreEqual(expected, f12CHF.Subtract(ms1));
}
///
///
///
///
[Test]
public void Print()
{
Assert.AreEqual("[12 CHF]", f12CHF.ToString());
}
///
///
///
///
[Test]
public void SimpleAdd()
{
// [12 CHF] + [14 CHF] == [26 CHF]
Money expected= new Money(26, "CHF");
Assert.AreEqual(expected, f12CHF.Add(f14CHF));
}
///
///
///
///
[Test]
public void SimpleBagAdd()
{
// [14 CHF] + {[12 CHF][7 USD]} == {[26 CHF][7 USD]}
Money[] bag= { new Money(26, "CHF"), new Money(7, "USD") };
MoneyBag expected= new MoneyBag(bag);
Assert.AreEqual(expected, f14CHF.Add(fMB1));
}
///
///
///
///
[Test]
public void SimpleMultiply()
{
// [14 CHF] *2 == [28 CHF]
Money expected= new Money(28, "CHF");
Assert.AreEqual(expected, f14CHF.Multiply(2));
}
///
///
///
///
[Test]
public void SimpleNegate()
{
// [14 CHF] negate == [-14 CHF]
Money expected= new Money(-14, "CHF");
Assert.AreEqual(expected, f14CHF.Negate());
}
///
///
///
///
[Test]
public void SimpleSubtract()
{
// [14 CHF] - [12 CHF] == [2 CHF]
Money expected= new Money(2, "CHF");
Assert.AreEqual(expected, f14CHF.Subtract(f12CHF));
}
}
} NUnit-2.6.0.12051/samples/csharp/money/cs-money.build 0000664 0001750 0001750 00000000553 11504175260 022011 0 ustar jtaylor jtaylor
NUnit-2.6.0.12051/samples/csharp/money/MoneyBag.cs 0000664 0001750 0001750 00000007715 11504175260 021275 0 ustar jtaylor jtaylor // ****************************************************************
// This is free software licensed under the NUnit license. You
// may obtain a copy of the license as well as information regarding
// copyright ownership at http://nunit.org/?p=license&r=2.4.
// ****************************************************************
namespace NUnit.Samples.Money
{
using System;
using System.Collections;
using System.Text;
/// A MoneyBag defers exchange rate conversions.
/// For example adding
/// 12 Swiss Francs to 14 US Dollars is represented as a bag
/// containing the two Monies 12 CHF and 14 USD. Adding another
/// 10 Swiss francs gives a bag with 22 CHF and 14 USD. Due to
/// the deferred exchange rate conversion we can later value a
/// MoneyBag with different exchange rates.
///
/// A MoneyBag is represented as a list of Monies and provides
/// different constructors to create a MoneyBag.
class MoneyBag: IMoney
{
private ArrayList fMonies= new ArrayList(5);
private MoneyBag()
{
}
public MoneyBag(Money[] bag)
{
for (int i= 0; i < bag.Length; i++)
{
if (!bag[i].IsZero)
AppendMoney(bag[i]);
}
}
public MoneyBag(Money m1, Money m2)
{
AppendMoney(m1);
AppendMoney(m2);
}
public MoneyBag(Money m, MoneyBag bag)
{
AppendMoney(m);
AppendBag(bag);
}
public MoneyBag(MoneyBag m1, MoneyBag m2)
{
AppendBag(m1);
AppendBag(m2);
}
public IMoney Add(IMoney m)
{
return m.AddMoneyBag(this);
}
public IMoney AddMoney(Money m)
{
return (new MoneyBag(m, this)).Simplify();
}
public IMoney AddMoneyBag(MoneyBag s)
{
return (new MoneyBag(s, this)).Simplify();
}
private void AppendBag(MoneyBag aBag)
{
foreach (Money m in aBag.fMonies)
AppendMoney(m);
}
private void AppendMoney(Money aMoney)
{
IMoney old= FindMoney(aMoney.Currency);
if (old == null)
{
fMonies.Add(aMoney);
return;
}
fMonies.Remove(old);
IMoney sum= old.Add(aMoney);
if (sum.IsZero)
return;
fMonies.Add(sum);
}
private bool Contains(Money aMoney)
{
Money m= FindMoney(aMoney.Currency);
return m.Amount == aMoney.Amount;
}
public override bool Equals(Object anObject)
{
if (IsZero)
if (anObject is IMoney)
return ((IMoney)anObject).IsZero;
if (anObject is MoneyBag)
{
MoneyBag aMoneyBag= (MoneyBag)anObject;
if (aMoneyBag.fMonies.Count != fMonies.Count)
return false;
foreach (Money m in fMonies)
{
if (!aMoneyBag.Contains(m))
return false;
}
return true;
}
return false;
}
private Money FindMoney(String currency)
{
foreach (Money m in fMonies)
{
if (m.Currency.Equals(currency))
return m;
}
return null;
}
public override int GetHashCode()
{
int hash= 0;
foreach (Money m in fMonies)
{
hash^= m.GetHashCode();
}
return hash;
}
public bool IsZero
{
get { return fMonies.Count == 0; }
}
public IMoney Multiply(int factor)
{
MoneyBag result= new MoneyBag();
if (factor != 0)
{
foreach (Money m in fMonies)
{
result.AppendMoney((Money)m.Multiply(factor));
}
}
return result;
}
public IMoney Negate()
{
MoneyBag result= new MoneyBag();
foreach (Money m in fMonies)
{
result.AppendMoney((Money)m.Negate());
}
return result;
}
private IMoney Simplify()
{
if (fMonies.Count == 1)
return (IMoney)fMonies[0];
return this;
}
public IMoney Subtract(IMoney m)
{
return Add(m.Negate());
}
public override String ToString()
{
StringBuilder buffer = new StringBuilder();
buffer.Append("{");
foreach (Money m in fMonies)
buffer.Append(m);
buffer.Append("}");
return buffer.ToString();
}
}
}
NUnit-2.6.0.12051/samples/csharp/money/Money.cs 0000664 0001750 0001750 00000004250 11504175260 020652 0 ustar jtaylor jtaylor // ****************************************************************
// This is free software licensed under the NUnit license. You
// may obtain a copy of the license as well as information regarding
// copyright ownership at http://nunit.org/?p=license&r=2.4.
// ****************************************************************
namespace NUnit.Samples.Money
{
using System;
using System.Text;
/// A simple Money.
class Money: IMoney
{
private int fAmount;
private String fCurrency;
/// Constructs a money from the given amount and
/// currency.
public Money(int amount, String currency)
{
fAmount= amount;
fCurrency= currency;
}
/// Adds a money to this money. Forwards the request to
/// the AddMoney helper.
public IMoney Add(IMoney m)
{
return m.AddMoney(this);
}
public IMoney AddMoney(Money m)
{
if (m.Currency.Equals(Currency) )
return new Money(Amount+m.Amount, Currency);
return new MoneyBag(this, m);
}
public IMoney AddMoneyBag(MoneyBag s)
{
return s.AddMoney(this);
}
public int Amount
{
get { return fAmount; }
}
public String Currency
{
get { return fCurrency; }
}
public override bool Equals(Object anObject)
{
if (IsZero)
if (anObject is IMoney)
return ((IMoney)anObject).IsZero;
if (anObject is Money)
{
Money aMoney= (Money)anObject;
return aMoney.Currency.Equals(Currency)
&& Amount == aMoney.Amount;
}
return false;
}
public override int GetHashCode()
{
return fCurrency.GetHashCode()+fAmount;
}
public bool IsZero
{
get { return Amount == 0; }
}
public IMoney Multiply(int factor)
{
return new Money(Amount*factor, Currency);
}
public IMoney Negate()
{
return new Money(-Amount, Currency);
}
public IMoney Subtract(IMoney m)
{
return Add(m.Negate());
}
public override String ToString()
{
StringBuilder buffer = new StringBuilder();
buffer.Append("["+Amount+" "+Currency+"]");
return buffer.ToString();
}
}
}
NUnit-2.6.0.12051/samples/csharp/money/cs-money.csproj 0000664 0001750 0001750 00000004236 11720516414 022214 0 ustar jtaylor jtaylor NUnit-2.6.0.12051/samples/csharp/CSharp.sln 0000664 0001750 0001750 00000003605 11504175260 020006 0 ustar jtaylor jtaylor Microsoft Visual Studio Solution File, Format Version 8.00
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "cs-failures", "failures\cs-failures.csproj", "{15D66EEE-A852-4A52-89C2-83E74ECF3770}"
ProjectSection(ProjectDependencies) = postProject
EndProjectSection
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "cs-money", "money\cs-money.csproj", "{11EDF872-A04D-4F75-A1BF-71168DC86AF3}"
ProjectSection(ProjectDependencies) = postProject
EndProjectSection
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "cs-syntax", "syntax\cs-syntax.csproj", "{06F46FA2-687B-4B46-A912-C1B0B4CC1B20}"
ProjectSection(ProjectDependencies) = postProject
EndProjectSection
EndProject
Global
GlobalSection(SolutionConfiguration) = preSolution
Debug = Debug
Release = Release
EndGlobalSection
GlobalSection(ProjectConfiguration) = postSolution
{15D66EEE-A852-4A52-89C2-83E74ECF3770}.Debug.ActiveCfg = Debug|.NET
{15D66EEE-A852-4A52-89C2-83E74ECF3770}.Debug.Build.0 = Debug|.NET
{15D66EEE-A852-4A52-89C2-83E74ECF3770}.Release.ActiveCfg = Release|.NET
{15D66EEE-A852-4A52-89C2-83E74ECF3770}.Release.Build.0 = Release|.NET
{11EDF872-A04D-4F75-A1BF-71168DC86AF3}.Debug.ActiveCfg = Debug|.NET
{11EDF872-A04D-4F75-A1BF-71168DC86AF3}.Debug.Build.0 = Debug|.NET
{11EDF872-A04D-4F75-A1BF-71168DC86AF3}.Release.ActiveCfg = Release|.NET
{11EDF872-A04D-4F75-A1BF-71168DC86AF3}.Release.Build.0 = Release|.NET
{06F46FA2-687B-4B46-A912-C1B0B4CC1B20}.Debug.ActiveCfg = Debug|.NET
{06F46FA2-687B-4B46-A912-C1B0B4CC1B20}.Debug.Build.0 = Debug|.NET
{06F46FA2-687B-4B46-A912-C1B0B4CC1B20}.Release.ActiveCfg = Release|.NET
{06F46FA2-687B-4B46-A912-C1B0B4CC1B20}.Release.Build.0 = Release|.NET
EndGlobalSection
GlobalSection(ExtensibilityGlobals) = postSolution
EndGlobalSection
GlobalSection(ExtensibilityAddIns) = postSolution
EndGlobalSection
EndGlobal
NUnit-2.6.0.12051/samples/csharp/syntax/ 0000775 0001750 0001750 00000000000 11742560362 017437 5 ustar jtaylor jtaylor NUnit-2.6.0.12051/samples/csharp/syntax/cs-syntax.build 0000664 0001750 0001750 00000000413 11504175260 022402 0 ustar jtaylor jtaylor
NUnit-2.6.0.12051/samples/csharp/syntax/AssertSyntaxTests.cs 0000664 0001750 0001750 00000064762 11504175260 023473 0 ustar jtaylor jtaylor // ****************************************************************
// Copyright 2007, Charlie Poole
// This is free software licensed under the NUnit license. You may
// obtain a copy of the license at http://nunit.org/?p=license&r=2.4
// ****************************************************************
using System;
using System.Collections;
using NUnit.Framework.Constraints;
namespace NUnit.Framework.Tests
{
///
/// This test fixture attempts to exercise all the syntactic
/// variations of Assert without getting into failures, errors
/// or corner cases. Thus, some of the tests may be duplicated
/// in other fixtures.
///
/// Each test performs the same operations using the classic
/// syntax (if available) and the new syntax in both the
/// helper-based and inherited forms.
///
/// This Fixture will eventually be duplicated in other
/// supported languages.
///
[TestFixture]
public class AssertSyntaxTests : AssertionHelper
{
#region Simple Constraint Tests
[Test]
public void IsNull()
{
object nada = null;
// Classic syntax
Assert.IsNull(nada);
// Helper syntax
Assert.That(nada, Is.Null);
// Inherited syntax
Expect(nada, Null);
}
[Test]
public void IsNotNull()
{
// Classic syntax
Assert.IsNotNull(42);
// Helper syntax
Assert.That(42, Is.Not.Null);
// Inherited syntax
Expect( 42, Not.Null );
}
[Test]
public void IsTrue()
{
// Classic syntax
Assert.IsTrue(2+2==4);
// Helper syntax
Assert.That(2+2==4, Is.True);
Assert.That(2+2==4);
// Inherited syntax
Expect(2+2==4, True);
Expect(2+2==4);
}
[Test]
public void IsFalse()
{
// Classic syntax
Assert.IsFalse(2+2==5);
// Helper syntax
Assert.That(2+2== 5, Is.False);
// Inherited syntax
Expect(2+2==5, False);
}
[Test]
public void IsNaN()
{
double d = double.NaN;
float f = float.NaN;
// Classic syntax
Assert.IsNaN(d);
Assert.IsNaN(f);
// Helper syntax
Assert.That(d, Is.NaN);
Assert.That(f, Is.NaN);
// Inherited syntax
Expect(d, NaN);
Expect(f, NaN);
}
[Test]
public void EmptyStringTests()
{
// Classic syntax
Assert.IsEmpty("");
Assert.IsNotEmpty("Hello!");
// Helper syntax
Assert.That("", Is.Empty);
Assert.That("Hello!", Is.Not.Empty);
// Inherited syntax
Expect("", Empty);
Expect("Hello!", Not.Empty);
}
[Test]
public void EmptyCollectionTests()
{
// Classic syntax
Assert.IsEmpty(new bool[0]);
Assert.IsNotEmpty(new int[] { 1, 2, 3 });
// Helper syntax
Assert.That(new bool[0], Is.Empty);
Assert.That(new int[] { 1, 2, 3 }, Is.Not.Empty);
// Inherited syntax
Expect(new bool[0], Empty);
Expect(new int[] { 1, 2, 3 }, Not.Empty);
}
#endregion
#region TypeConstraint Tests
[Test]
public void ExactTypeTests()
{
// Classic syntax workarounds
Assert.AreEqual(typeof(string), "Hello".GetType());
Assert.AreEqual("System.String", "Hello".GetType().FullName);
Assert.AreNotEqual(typeof(int), "Hello".GetType());
Assert.AreNotEqual("System.Int32", "Hello".GetType().FullName);
// Helper syntax
Assert.That("Hello", Is.TypeOf(typeof(string)));
Assert.That("Hello", Is.Not.TypeOf(typeof(int)));
// Inherited syntax
Expect( "Hello", TypeOf(typeof(string)));
Expect( "Hello", Not.TypeOf(typeof(int)));
}
[Test]
public void InstanceOfTypeTests()
{
// Classic syntax
Assert.IsInstanceOf(typeof(string), "Hello");
Assert.IsNotInstanceOf(typeof(string), 5);
// Helper syntax
Assert.That("Hello", Is.InstanceOf(typeof(string)));
Assert.That(5, Is.Not.InstanceOf(typeof(string)));
// Inherited syntax
Expect("Hello", InstanceOf(typeof(string)));
Expect(5, Not.InstanceOf(typeof(string)));
}
[Test]
public void AssignableFromTypeTests()
{
// Classic syntax
Assert.IsAssignableFrom(typeof(string), "Hello");
Assert.IsNotAssignableFrom(typeof(string), 5);
// Helper syntax
Assert.That( "Hello", Is.AssignableFrom(typeof(string)));
Assert.That( 5, Is.Not.AssignableFrom(typeof(string)));
// Inherited syntax
Expect( "Hello", AssignableFrom(typeof(string)));
Expect( 5, Not.AssignableFrom(typeof(string)));
}
#endregion
#region StringConstraint Tests
[Test]
public void SubstringTests()
{
string phrase = "Hello World!";
string[] array = new string[] { "abc", "bad", "dba" };
// Classic Syntax
StringAssert.Contains("World", phrase);
// Helper syntax
Assert.That(phrase, Text.Contains("World"));
// Only available using new syntax
Assert.That(phrase, Text.DoesNotContain("goodbye"));
Assert.That(phrase, Text.Contains("WORLD").IgnoreCase);
Assert.That(phrase, Text.DoesNotContain("BYE").IgnoreCase);
Assert.That(array, Text.All.Contains( "b" ) );
// Inherited syntax
Expect(phrase, Contains("World"));
// Only available using new syntax
Expect(phrase, Not.Contains("goodbye"));
Expect(phrase, Contains("WORLD").IgnoreCase);
Expect(phrase, Not.Contains("BYE").IgnoreCase);
Expect(array, All.Contains("b"));
}
[Test]
public void StartsWithTests()
{
string phrase = "Hello World!";
string[] greetings = new string[] { "Hello!", "Hi!", "Hola!" };
// Classic syntax
StringAssert.StartsWith("Hello", phrase);
// Helper syntax
Assert.That(phrase, Text.StartsWith("Hello"));
// Only available using new syntax
Assert.That(phrase, Text.DoesNotStartWith("Hi!"));
Assert.That(phrase, Text.StartsWith("HeLLo").IgnoreCase);
Assert.That(phrase, Text.DoesNotStartWith("HI").IgnoreCase);
Assert.That(greetings, Text.All.StartsWith("h").IgnoreCase);
// Inherited syntax
Expect(phrase, StartsWith("Hello"));
// Only available using new syntax
Expect(phrase, Not.StartsWith("Hi!"));
Expect(phrase, StartsWith("HeLLo").IgnoreCase);
Expect(phrase, Not.StartsWith("HI").IgnoreCase);
Expect(greetings, All.StartsWith("h").IgnoreCase);
}
[Test]
public void EndsWithTests()
{
string phrase = "Hello World!";
string[] greetings = new string[] { "Hello!", "Hi!", "Hola!" };
// Classic Syntax
StringAssert.EndsWith("!", phrase);
// Helper syntax
Assert.That(phrase, Text.EndsWith("!"));
// Only available using new syntax
Assert.That(phrase, Text.DoesNotEndWith("?"));
Assert.That(phrase, Text.EndsWith("WORLD!").IgnoreCase);
Assert.That(greetings, Text.All.EndsWith("!"));
// Inherited syntax
Expect(phrase, EndsWith("!"));
// Only available using new syntax
Expect(phrase, Not.EndsWith("?"));
Expect(phrase, EndsWith("WORLD!").IgnoreCase);
Expect(greetings, All.EndsWith("!") );
}
[Test]
public void EqualIgnoringCaseTests()
{
string phrase = "Hello World!";
// Classic syntax
StringAssert.AreEqualIgnoringCase("hello world!",phrase);
// Helper syntax
Assert.That(phrase, Is.EqualTo("hello world!").IgnoreCase);
//Only available using new syntax
Assert.That(phrase, Is.Not.EqualTo("goodbye world!").IgnoreCase);
Assert.That(new string[] { "Hello", "World" },
Is.EqualTo(new object[] { "HELLO", "WORLD" }).IgnoreCase);
Assert.That(new string[] {"HELLO", "Hello", "hello" },
Is.All.EqualTo( "hello" ).IgnoreCase);
// Inherited syntax
Expect(phrase, EqualTo("hello world!").IgnoreCase);
//Only available using new syntax
Expect(phrase, Not.EqualTo("goodbye world!").IgnoreCase);
Expect(new string[] { "Hello", "World" },
EqualTo(new object[] { "HELLO", "WORLD" }).IgnoreCase);
Expect(new string[] {"HELLO", "Hello", "hello" },
All.EqualTo( "hello" ).IgnoreCase);
}
[Test]
public void RegularExpressionTests()
{
string phrase = "Now is the time for all good men to come to the aid of their country.";
string[] quotes = new string[] { "Never say never", "It's never too late", "Nevermore!" };
// Classic syntax
StringAssert.IsMatch( "all good men", phrase );
StringAssert.IsMatch( "Now.*come", phrase );
// Helper syntax
Assert.That( phrase, Text.Matches( "all good men" ) );
Assert.That( phrase, Text.Matches( "Now.*come" ) );
// Only available using new syntax
Assert.That(phrase, Text.DoesNotMatch("all.*men.*good"));
Assert.That(phrase, Text.Matches("ALL").IgnoreCase);
Assert.That(quotes, Text.All.Matches("never").IgnoreCase);
// Inherited syntax
Expect( phrase, Matches( "all good men" ) );
Expect( phrase, Matches( "Now.*come" ) );
// Only available using new syntax
Expect(phrase, Not.Matches("all.*men.*good"));
Expect(phrase, Matches("ALL").IgnoreCase);
Expect(quotes, All.Matches("never").IgnoreCase);
}
#endregion
#region Equality Tests
[Test]
public void EqualityTests()
{
int[] i3 = new int[] { 1, 2, 3 };
double[] d3 = new double[] { 1.0, 2.0, 3.0 };
int[] iunequal = new int[] { 1, 3, 2 };
// Classic Syntax
Assert.AreEqual(4, 2 + 2);
Assert.AreEqual(i3, d3);
Assert.AreNotEqual(5, 2 + 2);
Assert.AreNotEqual(i3, iunequal);
// Helper syntax
Assert.That(2 + 2, Is.EqualTo(4));
Assert.That(2 + 2 == 4);
Assert.That(i3, Is.EqualTo(d3));
Assert.That(2 + 2, Is.Not.EqualTo(5));
Assert.That(i3, Is.Not.EqualTo(iunequal));
// Inherited syntax
Expect(2 + 2, EqualTo(4));
Expect(2 + 2 == 4);
Expect(i3, EqualTo(d3));
Expect(2 + 2, Not.EqualTo(5));
Expect(i3, Not.EqualTo(iunequal));
}
[Test]
public void EqualityTestsWithTolerance()
{
// CLassic syntax
Assert.AreEqual(5.0d, 4.99d, 0.05d);
Assert.AreEqual(5.0f, 4.99f, 0.05f);
// Helper syntax
Assert.That(4.99d, Is.EqualTo(5.0d).Within(0.05d));
Assert.That(4.0d, Is.Not.EqualTo(5.0d).Within(0.5d));
Assert.That(4.99f, Is.EqualTo(5.0f).Within(0.05f));
Assert.That(4.99m, Is.EqualTo(5.0m).Within(0.05m));
Assert.That(3999999999u, Is.EqualTo(4000000000u).Within(5u));
Assert.That(499, Is.EqualTo(500).Within(5));
Assert.That(4999999999L, Is.EqualTo(5000000000L).Within(5L));
Assert.That(5999999999ul, Is.EqualTo(6000000000ul).Within(5ul));
// Inherited syntax
Expect(4.99d, EqualTo(5.0d).Within(0.05d));
Expect(4.0d, Not.EqualTo(5.0d).Within(0.5d));
Expect(4.99f, EqualTo(5.0f).Within(0.05f));
Expect(4.99m, EqualTo(5.0m).Within(0.05m));
Expect(499u, EqualTo(500u).Within(5u));
Expect(499, EqualTo(500).Within(5));
Expect(4999999999L, EqualTo(5000000000L).Within(5L));
Expect(5999999999ul, EqualTo(6000000000ul).Within(5ul));
}
[Test]
public void EqualityTestsWithTolerance_MixedFloatAndDouble()
{
// Bug Fix 1743844
Assert.That(2.20492d, Is.EqualTo(2.2d).Within(0.01f),
"Double actual, Double expected, Single tolerance");
Assert.That(2.20492d, Is.EqualTo(2.2f).Within(0.01d),
"Double actual, Single expected, Double tolerance" );
Assert.That(2.20492d, Is.EqualTo(2.2f).Within(0.01f),
"Double actual, Single expected, Single tolerance" );
Assert.That(2.20492f, Is.EqualTo(2.2f).Within(0.01d),
"Single actual, Single expected, Double tolerance");
Assert.That(2.20492f, Is.EqualTo(2.2d).Within(0.01d),
"Single actual, Double expected, Double tolerance");
Assert.That(2.20492f, Is.EqualTo(2.2d).Within(0.01f),
"Single actual, Double expected, Single tolerance");
}
[Test]
public void EqualityTestsWithTolerance_MixingTypesGenerally()
{
// Extending tolerance to all numeric types
Assert.That(202d, Is.EqualTo(200d).Within(2),
"Double actual, Double expected, int tolerance");
Assert.That( 4.87m, Is.EqualTo(5).Within(.25),
"Decimal actual, int expected, Double tolerance" );
Assert.That( 4.87m, Is.EqualTo(5ul).Within(1),
"Decimal actual, ulong expected, int tolerance" );
Assert.That( 487, Is.EqualTo(500).Within(25),
"int actual, int expected, int tolerance" );
Assert.That( 487u, Is.EqualTo(500).Within(25),
"uint actual, int expected, int tolerance" );
Assert.That( 487L, Is.EqualTo(500).Within(25),
"long actual, int expected, int tolerance" );
Assert.That( 487ul, Is.EqualTo(500).Within(25),
"ulong actual, int expected, int tolerance" );
}
#endregion
#region Comparison Tests
[Test]
public void ComparisonTests()
{
// Classic Syntax
Assert.Greater(7, 3);
Assert.GreaterOrEqual(7, 3);
Assert.GreaterOrEqual(7, 7);
// Helper syntax
Assert.That(7, Is.GreaterThan(3));
Assert.That(7, Is.GreaterThanOrEqualTo(3));
Assert.That(7, Is.AtLeast(3));
Assert.That(7, Is.GreaterThanOrEqualTo(7));
Assert.That(7, Is.AtLeast(7));
// Inherited syntax
Expect(7, GreaterThan(3));
Expect(7, GreaterThanOrEqualTo(3));
Expect(7, AtLeast(3));
Expect(7, GreaterThanOrEqualTo(7));
Expect(7, AtLeast(7));
// Classic syntax
Assert.Less(3, 7);
Assert.LessOrEqual(3, 7);
Assert.LessOrEqual(3, 3);
// Helper syntax
Assert.That(3, Is.LessThan(7));
Assert.That(3, Is.LessThanOrEqualTo(7));
Assert.That(3, Is.AtMost(7));
Assert.That(3, Is.LessThanOrEqualTo(3));
Assert.That(3, Is.AtMost(3));
// Inherited syntax
Expect(3, LessThan(7));
Expect(3, LessThanOrEqualTo(7));
Expect(3, AtMost(7));
Expect(3, LessThanOrEqualTo(3));
Expect(3, AtMost(3));
}
#endregion
#region Collection Tests
[Test]
public void AllItemsTests()
{
object[] ints = new object[] { 1, 2, 3, 4 };
object[] doubles = new object[] { 0.99, 2.1, 3.0, 4.05 };
object[] strings = new object[] { "abc", "bad", "cab", "bad", "dad" };
// Classic syntax
CollectionAssert.AllItemsAreNotNull(ints);
CollectionAssert.AllItemsAreInstancesOfType(ints, typeof(int));
CollectionAssert.AllItemsAreInstancesOfType(strings, typeof(string));
CollectionAssert.AllItemsAreUnique(ints);
// Helper syntax
Assert.That(ints, Is.All.Not.Null);
Assert.That(ints, Has.None.Null);
Assert.That(ints, Is.All.InstanceOfType(typeof(int)));
Assert.That(ints, Has.All.InstanceOfType(typeof(int)));
Assert.That(strings, Is.All.InstanceOfType(typeof(string)));
Assert.That(strings, Has.All.InstanceOfType(typeof(string)));
Assert.That(ints, Is.Unique);
// Only available using new syntax
Assert.That(strings, Is.Not.Unique);
Assert.That(ints, Is.All.GreaterThan(0));
Assert.That(ints, Has.All.GreaterThan(0));
Assert.That(ints, Has.None.LessThanOrEqualTo(0));
Assert.That(strings, Text.All.Contains( "a" ) );
Assert.That(strings, Has.All.Contains( "a" ) );
Assert.That(strings, Has.Some.StartsWith( "ba" ) );
Assert.That( strings, Has.Some.Property( "Length" ).EqualTo( 3 ) );
Assert.That( strings, Has.Some.StartsWith( "BA" ).IgnoreCase );
Assert.That( doubles, Has.Some.EqualTo( 1.0 ).Within( .05 ) );
// Inherited syntax
Expect(ints, All.Not.Null);
Expect(ints, None.Null);
Expect(ints, All.InstanceOfType(typeof(int)));
Expect(strings, All.InstanceOfType(typeof(string)));
Expect(ints, Unique);
// Only available using new syntax
Expect(strings, Not.Unique);
Expect(ints, All.GreaterThan(0));
Expect(ints, None.LessThanOrEqualTo(0));
Expect(strings, All.Contains( "a" ) );
Expect(strings, Some.StartsWith( "ba" ) );
Expect(strings, Some.StartsWith( "BA" ).IgnoreCase );
Expect(doubles, Some.EqualTo( 1.0 ).Within( .05 ) );
}
[Test]
public void SomeItemTests()
{
object[] mixed = new object[] { 1, 2, "3", null, "four", 100 };
object[] strings = new object[] { "abc", "bad", "cab", "bad", "dad" };
// Not available using the classic syntax
// Helper syntax
Assert.That(mixed, Has.Some.Null);
Assert.That(mixed, Has.Some.InstanceOfType(typeof(int)));
Assert.That(mixed, Has.Some.InstanceOfType(typeof(string)));
Assert.That(strings, Has.Some.StartsWith( "ba" ) );
Assert.That(strings, Has.Some.Not.StartsWith( "ba" ) );
// Inherited syntax
Expect(mixed, Some.Null);
Expect(mixed, Some.InstanceOfType(typeof(int)));
Expect(mixed, Some.InstanceOfType(typeof(string)));
Expect(strings, Some.StartsWith( "ba" ) );
Expect(strings, Some.Not.StartsWith( "ba" ) );
}
[Test]
public void NoItemTests()
{
object[] ints = new object[] { 1, 2, 3, 4, 5 };
object[] strings = new object[] { "abc", "bad", "cab", "bad", "dad" };
// Not available using the classic syntax
// Helper syntax
Assert.That(ints, Has.None.Null);
Assert.That(ints, Has.None.InstanceOfType(typeof(string)));
Assert.That(ints, Has.None.GreaterThan(99));
Assert.That(strings, Has.None.StartsWith( "qu" ) );
// Inherited syntax
Expect(ints, None.Null);
Expect(ints, None.InstanceOfType(typeof(string)));
Expect(ints, None.GreaterThan(99));
Expect(strings, None.StartsWith( "qu" ) );
}
[Test]
public void CollectionContainsTests()
{
int[] iarray = new int[] { 1, 2, 3 };
string[] sarray = new string[] { "a", "b", "c" };
// Classic syntax
Assert.Contains(3, iarray);
Assert.Contains("b", sarray);
CollectionAssert.Contains(iarray, 3);
CollectionAssert.Contains(sarray, "b");
CollectionAssert.DoesNotContain(sarray, "x");
// Showing that Contains uses NUnit equality
CollectionAssert.Contains( iarray, 1.0d );
// Helper syntax
Assert.That(iarray, Has.Member(3));
Assert.That(sarray, Has.Member("b"));
Assert.That(sarray, Has.No.Member("x"));
// Showing that Contains uses NUnit equality
Assert.That(iarray, Has.Member( 1.0d ));
// Only available using the new syntax
// Note that EqualTo and SameAs do NOT give
// identical results to Contains because
// Contains uses Object.Equals()
Assert.That(iarray, Has.Some.EqualTo(3));
Assert.That(iarray, Has.Member(3));
Assert.That(sarray, Has.Some.EqualTo("b"));
Assert.That(sarray, Has.None.EqualTo("x"));
Assert.That(iarray, Has.None.SameAs( 1.0d ));
Assert.That(iarray, Has.All.LessThan(10));
Assert.That(sarray, Has.All.Length.EqualTo(1));
Assert.That(sarray, Has.None.Property("Length").GreaterThan(3));
// Inherited syntax
Expect(iarray, Contains(3));
Expect(sarray, Contains("b"));
Expect(sarray, Not.Contains("x"));
// Only available using new syntax
// Note that EqualTo and SameAs do NOT give
// identical results to Contains because
// Contains uses Object.Equals()
Expect(iarray, Some.EqualTo(3));
Expect(sarray, Some.EqualTo("b"));
Expect(sarray, None.EqualTo("x"));
Expect(iarray, All.LessThan(10));
Expect(sarray, All.Length.EqualTo(1));
Expect(sarray, None.Property("Length").GreaterThan(3));
}
[Test]
public void CollectionEquivalenceTests()
{
int[] ints1to5 = new int[] { 1, 2, 3, 4, 5 };
int[] twothrees = new int[] { 1, 2, 3, 3, 4, 5 };
int[] twofours = new int[] { 1, 2, 3, 4, 4, 5 };
// Classic syntax
CollectionAssert.AreEquivalent(new int[] { 2, 1, 4, 3, 5 }, ints1to5);
CollectionAssert.AreNotEquivalent(new int[] { 2, 2, 4, 3, 5 }, ints1to5);
CollectionAssert.AreNotEquivalent(new int[] { 2, 4, 3, 5 }, ints1to5);
CollectionAssert.AreNotEquivalent(new int[] { 2, 2, 1, 1, 4, 3, 5 }, ints1to5);
CollectionAssert.AreNotEquivalent(twothrees, twofours);
// Helper syntax
Assert.That(new int[] { 2, 1, 4, 3, 5 }, Is.EquivalentTo(ints1to5));
Assert.That(new int[] { 2, 2, 4, 3, 5 }, Is.Not.EquivalentTo(ints1to5));
Assert.That(new int[] { 2, 4, 3, 5 }, Is.Not.EquivalentTo(ints1to5));
Assert.That(new int[] { 2, 2, 1, 1, 4, 3, 5 }, Is.Not.EquivalentTo(ints1to5));
// Inherited syntax
Expect(new int[] { 2, 1, 4, 3, 5 }, EquivalentTo(ints1to5));
Expect(new int[] { 2, 2, 4, 3, 5 }, Not.EquivalentTo(ints1to5));
Expect(new int[] { 2, 4, 3, 5 }, Not.EquivalentTo(ints1to5));
Expect(new int[] { 2, 2, 1, 1, 4, 3, 5 }, Not.EquivalentTo(ints1to5));
}
[Test]
public void SubsetTests()
{
int[] ints1to5 = new int[] { 1, 2, 3, 4, 5 };
// Classic syntax
CollectionAssert.IsSubsetOf(new int[] { 1, 3, 5 }, ints1to5);
CollectionAssert.IsSubsetOf(new int[] { 1, 2, 3, 4, 5 }, ints1to5);
CollectionAssert.IsNotSubsetOf(new int[] { 2, 4, 6 }, ints1to5);
CollectionAssert.IsNotSubsetOf(new int[] { 1, 2, 2, 2, 5 }, ints1to5);
// Helper syntax
Assert.That(new int[] { 1, 3, 5 }, Is.SubsetOf(ints1to5));
Assert.That(new int[] { 1, 2, 3, 4, 5 }, Is.SubsetOf(ints1to5));
Assert.That(new int[] { 2, 4, 6 }, Is.Not.SubsetOf(ints1to5));
// Inherited syntax
Expect(new int[] { 1, 3, 5 }, SubsetOf(ints1to5));
Expect(new int[] { 1, 2, 3, 4, 5 }, SubsetOf(ints1to5));
Expect(new int[] { 2, 4, 6 }, Not.SubsetOf(ints1to5));
}
#endregion
#region Property Tests
[Test]
public void PropertyTests()
{
string[] array = { "abc", "bca", "xyz", "qrs" };
string[] array2 = { "a", "ab", "abc" };
ArrayList list = new ArrayList( array );
// Not available using the classic syntax
// Helper syntax
Assert.That( list, Has.Property( "Count" ) );
Assert.That( list, Has.No.Property( "Length" ) );
Assert.That( "Hello", Has.Length.EqualTo( 5 ) );
Assert.That( "Hello", Has.Length.LessThan( 10 ) );
Assert.That( "Hello", Has.Property("Length").EqualTo(5) );
Assert.That( "Hello", Has.Property("Length").GreaterThan(3) );
Assert.That( array, Has.Property( "Length" ).EqualTo( 4 ) );
Assert.That( array, Has.Length.EqualTo( 4 ) );
Assert.That( array, Has.Property( "Length" ).LessThan( 10 ) );
Assert.That( array, Has.All.Property("Length").EqualTo(3) );
Assert.That( array, Has.All.Length.EqualTo( 3 ) );
Assert.That( array, Is.All.Length.EqualTo( 3 ) );
Assert.That( array, Has.All.Property("Length").EqualTo(3) );
Assert.That( array, Is.All.Property("Length").EqualTo(3) );
Assert.That( array2, Has.Some.Property("Length").EqualTo(2) );
Assert.That( array2, Has.Some.Length.EqualTo(2) );
Assert.That( array2, Has.Some.Property("Length").GreaterThan(2) );
Assert.That( array2, Is.Not.Property("Length").EqualTo(4) );
Assert.That( array2, Is.Not.Length.EqualTo( 4 ) );
Assert.That( array2, Has.No.Property("Length").GreaterThan(3) );
Assert.That( List.Map( array2 ).Property("Length"), Is.EqualTo( new int[] { 1, 2, 3 } ) );
Assert.That( List.Map( array2 ).Property("Length"), Is.EquivalentTo( new int[] { 3, 2, 1 } ) );
Assert.That( List.Map( array2 ).Property("Length"), Is.SubsetOf( new int[] { 1, 2, 3, 4, 5 } ) );
Assert.That( List.Map( array2 ).Property("Length"), Is.Unique );
Assert.That( list, Has.Count.EqualTo( 4 ) );
// Inherited syntax
Expect( list, Property( "Count" ) );
Expect( list, Not.Property( "Nada" ) );
Expect( "Hello", Length.EqualTo( 5 ) );
Expect( "Hello", Property("Length").EqualTo(5) );
Expect( "Hello", Property("Length").GreaterThan(0) );
Expect( array, Property("Length").EqualTo(4) );
Expect( array, Length.EqualTo(4) );
Expect( array, Property("Length").LessThan(10));
Expect( array, All.Length.EqualTo( 3 ) );
Expect( array, All.Property("Length").EqualTo(3));
Expect( array2, Some.Property("Length").EqualTo(2) );
Expect( array2, Some.Length.EqualTo( 2 ) );
Expect( array2, Some.Property("Length").GreaterThan(2));
Expect( array2, None.Property("Length").EqualTo(4) );
Expect( array2, None.Length.EqualTo( 4 ) );
Expect( array2, None.Property("Length").GreaterThan(3));
Expect( Map( array2 ).Property("Length"), EqualTo( new int[] { 1, 2, 3 } ) );
Expect( Map( array2 ).Property("Length"), EquivalentTo( new int[] { 3, 2, 1 } ) );
Expect( Map( array2 ).Property("Length"), SubsetOf( new int[] { 1, 2, 3, 4, 5 } ) );
Expect( Map( array2 ).Property("Length"), Unique );
Expect( list, Count.EqualTo( 4 ) );
}
#endregion
#region Not Tests
[Test]
public void NotTests()
{
// Not available using the classic syntax
// Helper syntax
Assert.That(42, Is.Not.Null);
Assert.That(42, Is.Not.True);
Assert.That(42, Is.Not.False);
Assert.That(2.5, Is.Not.NaN);
Assert.That(2 + 2, Is.Not.EqualTo(3));
Assert.That(2 + 2, Is.Not.Not.EqualTo(4));
Assert.That(2 + 2, Is.Not.Not.Not.EqualTo(5));
// Inherited syntax
Expect(42, Not.Null);
Expect(42, Not.True);
Expect(42, Not.False);
Expect(2.5, Not.NaN);
Expect(2 + 2, Not.EqualTo(3));
Expect(2 + 2, Not.Not.EqualTo(4));
Expect(2 + 2, Not.Not.Not.EqualTo(5));
}
#endregion
#region Operator Tests
[Test]
public void NotOperator()
{
// The ! operator is only available in the new syntax
Assert.That(42, !Is.Null);
// Inherited syntax
Expect( 42, !Null );
}
[Test]
public void AndOperator()
{
// The & operator is only available in the new syntax
Assert.That(7, Is.GreaterThan(5) & Is.LessThan(10));
// Inherited syntax
Expect( 7, GreaterThan(5) & LessThan(10));
}
[Test]
public void OrOperator()
{
// The | operator is only available in the new syntax
Assert.That(3, Is.LessThan(5) | Is.GreaterThan(10));
Expect( 3, LessThan(5) | GreaterThan(10));
}
[Test]
public void ComplexTests()
{
Assert.That(7, Is.Not.Null & Is.Not.LessThan(5) & Is.Not.GreaterThan(10));
Expect(7, Not.Null & Not.LessThan(5) & Not.GreaterThan(10));
Assert.That(7, !Is.Null & !Is.LessThan(5) & !Is.GreaterThan(10));
Expect(7, !Null & !LessThan(5) & !GreaterThan(10));
// TODO: Remove #if when mono compiler can handle null
#if MONO
Constraint x = null;
Assert.That(7, !x & !Is.LessThan(5) & !Is.GreaterThan(10));
Expect(7, !x & !LessThan(5) & !GreaterThan(10));
#else
Assert.That(7, !(Constraint)null & !Is.LessThan(5) & !Is.GreaterThan(10));
Expect(7, !(Constraint)null & !LessThan(5) & !GreaterThan(10));
#endif
}
#endregion
#region Invalid Code Tests
// This method contains assertions that should not compile
// You can check by uncommenting it.
//public void WillNotCompile()
//{
// Assert.That(42, Is.Not);
// Assert.That(42, Is.All);
// Assert.That(42, Is.Null.Not);
// Assert.That(42, Is.Not.Null.GreaterThan(10));
// Assert.That(42, Is.GreaterThan(10).LessThan(99));
// object[] c = new object[0];
// Assert.That(c, Is.Null.All);
// Assert.That(c, Is.Not.All);
// Assert.That(c, Is.All.Not);
//}
#endregion
}
}
NUnit-2.6.0.12051/samples/csharp/syntax/AssemblyInfo.cs 0000664 0001750 0001750 00000004572 11504175260 022364 0 ustar jtaylor jtaylor using System.Reflection;
using System.Runtime.CompilerServices;
//
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
//
[assembly: AssemblyTitle("")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("")]
[assembly: AssemblyCopyright("")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
//
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// You can specify all the values or you can default the Revision and Build Numbers
// by using the '*' as shown below:
[assembly: AssemblyVersion("1.0.*")]
//
// In order to sign your assembly you must specify a key to use. Refer to the
// Microsoft .NET Framework documentation for more information on assembly signing.
//
// Use the attributes below to control which key is used for signing.
//
// Notes:
// (*) If no key is specified, the assembly is not signed.
// (*) KeyName refers to a key that has been installed in the Crypto Service
// Provider (CSP) on your machine. KeyFile refers to a file which contains
// a key.
// (*) If the KeyFile and the KeyName values are both specified, the
// following processing occurs:
// (1) If the KeyName can be found in the CSP, that key is used.
// (2) If the KeyName does not exist and the KeyFile does exist, the key
// in the KeyFile is installed into the CSP and used.
// (*) In order to create a KeyFile, you can use the sn.exe (Strong Name) utility.
// When specifying the KeyFile, the location of the KeyFile should be
// relative to the project output directory which is
// %Project Directory%\obj\. For example, if your KeyFile is
// located in the project directory, you would specify the AssemblyKeyFile
// attribute as [assembly: AssemblyKeyFile("..\\..\\mykey.snk")]
// (*) Delay Signing is an advanced option - see the Microsoft .NET Framework
// documentation for more information on this.
//
[assembly: AssemblyDelaySign(false)]
[assembly: AssemblyKeyFile("")]
[assembly: AssemblyKeyName("")]
NUnit-2.6.0.12051/samples/csharp/syntax/cs-syntax.csproj 0000664 0001750 0001750 00000003712 11720516414 022610 0 ustar jtaylor jtaylor NUnit-2.6.0.12051/samples/csharp/failures/ 0000775 0001750 0001750 00000000000 11742560362 017723 5 ustar jtaylor jtaylor NUnit-2.6.0.12051/samples/csharp/failures/AssemblyInfo.cs 0000664 0001750 0001750 00000005067 11504175260 022650 0 ustar jtaylor jtaylor using System.Reflection;
using System.Runtime.CompilerServices;
//
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
//
[assembly: AssemblyTitle("csharp.sample.dll")]
[assembly: AssemblyDescription("C# Sample Unit Tests")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("NUnit")]
[assembly: AssemblyProduct("NUnit")]
[assembly: AssemblyCopyright("Copyright (C) 2002-2003 James W. Newkirk, Michael C. Two, Alexei A. Vorontsov. \nCopyright (C) 2000-2003 Philip Craig.\nAll Rights Reserved.")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
//
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// You can specify all the values or you can default the Revision and Build Numbers
// by using the '*' as shown below:
[assembly: AssemblyVersion("2.2.0.0")]
//
// In order to sign your assembly you must specify a key to use. Refer to the
// Microsoft .NET Framework documentation for more information on assembly signing.
//
// Use the attributes below to control which key is used for signing.
//
// Notes:
// (*) If no key is specified, the assembly is not signed.
// (*) KeyName refers to a key that has been installed in the Crypto Service
// Provider (CSP) on your machine. KeyFile refers to a file which contains
// a key.
// (*) If the KeyFile and the KeyName values are both specified, the
// following processing occurs:
// (1) If the KeyName can be found in the CSP, that key is used.
// (2) If the KeyName does not exist and the KeyFile does exist, the key
// in the KeyFile is installed into the CSP and used.
// (*) In order to create a KeyFile, you can use the sn.exe (Strong Name) utility.
// When specifying the KeyFile, the location of the KeyFile should be
// relative to the project output directory which is
// %Project Directory%\obj\. For example, if your KeyFile is
// located in the project directory, you would specify the AssemblyKeyFile
// attribute as [assembly: AssemblyKeyFile("..\\..\\mykey.snk")]
// (*) Delay Signing is an advanced option - see the Microsoft .NET Framework
// documentation for more information on this.
//
[assembly: AssemblyDelaySign(false)]
[assembly: AssemblyKeyFile("")]
[assembly: AssemblyKeyName("")]
NUnit-2.6.0.12051/samples/csharp/failures/cs-failures.csproj 0000664 0001750 0001750 00000003710 11720516414 023356 0 ustar jtaylor jtaylor NUnit-2.6.0.12051/samples/csharp/failures/cs-failures.build 0000664 0001750 0001750 00000000405 11504175260 023153 0 ustar jtaylor jtaylor
NUnit-2.6.0.12051/samples/csharp/failures/CSharpTest.cs 0000664 0001750 0001750 00000003427 11504175260 022273 0 ustar jtaylor jtaylor // ****************************************************************
// This is free software licensed under the NUnit license. You
// may obtain a copy of the license as well as information regarding
// copyright ownership at http://nunit.org/?p=license&r=2.4.
// ****************************************************************
namespace NUnit.Samples
{
using System;
using NUnit.Framework;
/// Some simple Tests.
///
[TestFixture]
public class SimpleCSharpTest
{
///
///
///
protected int fValue1;
///
///
///
protected int fValue2;
///
///
///
[SetUp] public void Init()
{
fValue1= 2;
fValue2= 3;
}
///
///
///
///
[Test] public void Add()
{
double result= fValue1 + fValue2;
// forced failure result == 5
Assert.AreEqual(6, result, "Expected Failure.");
}
///
///
///
///
[Test] public void DivideByZero()
{
int zero= 0;
int result= 8/zero;
}
///
///
///
///
[Test] public void Equals()
{
Assert.AreEqual(12, 12, "Integer");
Assert.AreEqual(12L, 12L, "Long");
Assert.AreEqual('a', 'a', "Char");
Assert.AreEqual((object)12, (object)12, "Integer Object Cast");
Assert.AreEqual(12, 13, "Expected Failure (Integer)");
Assert.AreEqual(12.0, 11.99, 0.0, "Expected Failure (Double).");
}
[Test]
[ExpectedException(typeof(InvalidOperationException))]
public void ExpectAnException()
{
throw new InvalidCastException();
}
[Test]
[Ignore("ignored test")]
public void IgnoredTest()
{
throw new Exception();
}
}
} NUnit-2.6.0.12051/doc/ 0000775 0001750 0001750 00000000000 11742560362 013732 5 ustar jtaylor jtaylor NUnit-2.6.0.12051/doc/conditionAsserts.html 0000664 0001750 0001750 00000013114 11720512704 020144 0 ustar jtaylor jtaylor
NUnit - ConditionAsserts
Methods that test a specific condition are named for the condition they test and
take the value tested as their first argument and, optionally a message as the
second. The following methods are provided:
Two forms are provided for the True, False, Null and NotNull
conditions. The "Is" forms are compatible with earlier versions
of the NUnit framework, while those without "Is" are provided
for compatibility with NUnitLite.
Assert.IsEmpty and Assert.IsNotEmpty may be used to test either a string
or a collection.
Since version 2.1, NUnit has allowed loading suites of tests from multiple assemblies in both
the console and GUI runners. This may be done on an adhoc basis or by creating NUnit test projects
saved as files of type '.nunit'. In either case, a top-level suite is constructed, which contains
the root suite for each assembly. Tests are run and reported just as for a single assembly.
Adhoc Usage
Using the console runner, multiple assemblies may be run simply by specifying their names on the
command line. See NUnit-Console Command Line Options for
an example of this usage.
The gui runner does not support specifying multiple assemblies on the command-line.
However, you can load a single assembly and then use the Project menu to add additional
assemblies. Additionally, you can drag multiple assemblies to the tree view pane, in which
case they will replace any assemblies already loaded.
NUnit Test Projects
Running tests from multiple assemblies is facilitated by the use of NUnit test projects. These are
files with the extension .nunit containing information about the assemblies to be loaded. The
following is an example of a hypothetical test project file:
This project contains two configurations, each of which contains two assemblies. The Debug
configuration is currently active. By default, the assemblies will be loaded using the directory
containing this file as the ApplicationBase. The PrivateBinPath will be set automatically to
LibraryCore\bin\Debug;LibraryUI\bin\Debug or to the corresonding release path.
XML attributes are used to specify non-default values for the ApplicationBase, Configuration
File and PrivateBinPath. The Project Editor may
be used to create or modify NUnit projects.
Even when you are running a single test assembly, NUnit creates an internal project
to contain that assembly. If you are using the gui, you can save this project, edit it,
add additional assemblies, etc. Note that the gui does not display the internal project
unless you add assemblies or modify it in some other way.
If you use Visual Studio Support to load Visual
Studio .Net project or solution files, NUnit converts them to Test projects internally.
As with other internal projects, these test projects are not saved automatically but may
be saved by use of the File menu.
Loading and Running
In the past, test writers have been able to rely on the current directory being set to the
directory containing the single loaded assembly. For the purpose of compatibility, NUnit continues
to set the current directory to the directory containing each assembly whenever any test from that
assembly is run.
Additionally, because some assemblies may rely on unmanaged dlls in the same directory, the
current directory is also set to that of the assembly at the time the assembly is loaded. However,
in cases where multiple assemblies reference the same unmanaged assembly, this may not be sufficient
and the user may need to place the directory containing the unmanaged dll on the path.
NUnit originally identified tests in the time-honored way used in many xUnit
test frameworks. Test classes inherited from the framework's
TestCase class. Individual test case methods were identified by having names
starting with "test..."
With NUnit 2.0, we introduced the use of attributes to identify both fixtures
and test cases. Use of attributes in this way was a natural outcome of their
presence in .NET and gave us a way of identifying tests that was completely
independent of both inheritance and naming conventions.
However, by moving away from an inheritance-based mechanism we no longer
had an easy way for others to extend NUnit's internal behavior. NUnit Addins are
intended to fill that gap, providing an mechanism to introduce new or changed
behavior without modifying NUnit itself.
Extension Points, Extensions and Addins
NUnit provides a number of Extension Points, places where it is
possible to extend its behavior. Because NUnit works with various hosts
and uses separate AppDomains to run tests, Extension Points are
categorized into three types: Core, Client and Gui. Each of these types is
supported by a different Extension Host.
An NUnit Addin provides enhanced functionality through one or more
extensions, which it installs at identified Extension Points. Each
Addin is characterized by the types of extensions it supplies, so that
an Extension Host knows whether to invoke it.
Note: In the current release, only Core extensions are actually
supported. An Addin may characterize itself as a Client or Gui extension and
will be listed as such in the Addins Dialog,
but no other action is taken.
Addin Identification, Loading and Installation
NUnit examines all assemblies in the bin/addins directory, looking
for public classes with the NUnitAddinAttribute and implementing the
IAddin interface. It loads all those it finds as Addins.
NUnitAddinAttribute supports three optional named parameters: Type,
Name and Description. Name and Description are strings representing the name
of the extension and a description of what it does. If no name is provided,
the name of the class is used. Type may be any one or a combination of the
ExtensionType enum members:
[Flags]
public enum ExtensionType
{
Core=1,
Client=2,
Gui=4
}
The values may be or'ed together, allowing for future Addins that require
extensions at multiple levels of the application. If not provided, Type
defaults to ExtensionType.Core.
The IAddin interface, which must be implemented by each Addin,
is defined as follows:
public interface IAddin
{
bool Install( IExtensionHost host );
}
The Install method is called by each host for which the addin has
specified an ExtensionType. The addin should check that the necessary extension
points are available and install itself, returning true for success or false
for failure to install. The method will be called once for each extension
host and - for Core extensions - each time a new test domain is loaded.
The Install method uses the IExtensionHost interface to locate
extension points. It is defined as follows:
public interface IExtensionHost
{
IExtensionPoint[] ExtensionPoints { get; }
IExtensionPoint GetExtensionPoint( string name );
ExtensionType ExtensionTypes { get; }
}
The ExtensionPoints property returns an array of all extension points
for those extensions that need the information. The ExtensionTypes
property returns the flags for the type of extension supported by this host,
allowing, for example, Gui extensions to only load in a Gui host.
Most addins will only need to use the GetExtensionPoint method to
get the interface to a particular extension point. The IExtensionPoint
interface is defined as follows:
Once again, most addins will only need to use one method - the
Install method in this case. This method passes an extension object
to the Extension Point where it is installed. Generally, extensions
do not need to remove themselves once installed, but the method is
provided in any case.
With NUnit 2.5, an additional interface, IExtensionPoint2 is
available. It derives from IExtensionPoint and also allows setting
the priority order in which the extension will be called in comparison to
other extensions on the same extension point. The interface is defined
as follows:
public interface IExtensionPoint2 : IExtensionPoint
{
void Install( object extension, int priority );
}
Only extension points that use a priority scheme implement this interface.
In general, extension points with a priority scheme will use a default value
for priority if the Install method without a priority is called.
In the NUnit 2.5 release, only the TestDecorators extension point implements
IExtensionPoint2.
Extension Point Details
Depending on the particular extension point, the object passed will
need to implement one or more interfaces. The following ExtensionPoints
are implemented in this release of NUnit:
For examples of implementing each type of extension, see the Extensibility
samples provided with NUnit. More complete examples are available in the
code of NUnit itself, since NUnit uses the same mechanism internally.
NUnit supports the Visual Studio project and solution format, which are also
used by a number of other IDEs. Visual Studio support is enabled/disabled
by use of the Settings Dialog
Running From Within Visual Studio
The most convenient way to do this is to set up a custom tool entry specifying the path to
NUnit as the command. For a VS2003 C# project, you can use $(TargetPath) for the arguments and
$(TargetDir) for the initial directory.
With Visual Studio VS2005 this becomes a bit harder, because that release changed the
meaning of the 'Target' macros so they now point to the intermediate 'obj' directories rather
than the final output in one of the 'bin' directories. Here are some alternatives that
work in both versions:
$(ProjectDir)$(ProjectFileName) to open the VS Project rather than the assembly.
If you use this approach, be sure to rename your config file accordingly and put it
in the same directory as the VS project file.
$(ProjectDir)bin/Debug/$(TargetName)$(TargetExt) to run the assembly directly.
Note that this requires hard-coding part of the path, including the configuration.
If you would like to debug your tests, use the Visual Studio
Debug | Processes menu item to attach to NUnit after starting it and set breakpoints in
your test code as desired before running the tests.
Using Console Interface to Debug Applications
When the nunit-console program is run in debug mode under Visual Studio, it detects that it is
running in this mode and sends output to the Visual Studio output window. Output is formatted so
that double clicking any error or failure entries opens the appropriate test file at the location
where the failure was detected.
Opening Visual Studio Projects
When Visual Studio support is enabled, the File Open dialog displays the following supported
Visual Studio project types: C#, VB.Net, J# and C++. The project file is read and the
configurations and output assembly locations are identified. Since the project files do not contain
information about the most recently opened configuration, the output assembly for the first
configuration found (usually Debug) is loaded in the GUI. The tree shows the project as the toplevel
node with the assembly shown as its descendant.
Beginning with NUnit 2.2.2, you may also open a Visual Studio project by dragging it to the gui tree control.
When tests are run for a Visual studio project, they run just as if the output assembly had been
loaded with one exception. The default location for the config file is the directory containing the
project file and it's default name is the same as the project file with an extension of .config.
For example, the following command would load the tests in the nunit.tests assembly using the
configuration file nunit.tests.dll.config located in the same directory as the dll.
nunit.exe nunit.tests.dll
On the other hand, the following command would load the tests using the configuration file
nunit.tests.config located in the same directory as the csproj file.
nunit.exe nunit.tests.csproj
The same consideration applies to running tests using the console runner.
Opening Visual Studio Solutions
When Visual Studio support is enabled, solution files may be opened as well. All the output
assemblies from contained projects of the types supported will be loaded in the tree. In the case
where all contained projects are located in the subdirectories beneath the solution, it will be
possible to load and run tests using this method directly.
Beginning with NUnit 2.2.2, you may also open a Visual Studio solution by dragging it to the gui tree control.
When a solution contains projects located elsewhere in the file system, it may not be possible to
run the tests - although the solution will generally load without problem. In this case, the Project
Editor should be use to modify and save the NUnit test project so that there is all referenced
assemblies are located in or beneath the application base directory.
Adding Visual Studio Projects to the Open Test Project
When Visual Studio support is enabled, the Project menu contains an active entry to add a VS
project to the loaded project. The output assembly will be added for each of the configurations
specified in the VS project.
ValueSourceAttribute is used on individual parameters of a test method to
identify a named source for the argument values to be supplied. The attribute has
two public constructors.
If sourceType is specified, it represents the class that provides
the data. It must have a default constructor.
If sourceType is not specified, the class containing the test
method is used. NUnit will construct it using either the default constructor
or - if arguments are provided - the appropriate constructor for those
arguments.
The sourceName, represents the name of the source that will
provide the arguments. It should have the following characteristics:
It may be a field, a non-indexed property or a method taking no arguments.
It may be either an instance or a static member.
It must return an IEnumerable or a type that implements IEnumerable.
The individual items returned from the enumerator must be compatible
with the type of the parameter on which the attribute appears.
Order of Execution
In NUnit 2.5, individual test cases are sorted alphabetically and executed in
that order. With NUnit 2.5.1, the individual cases are not sorted, but are
executed in the order in which NUnit discovers them. This order does not
follow the lexical order of the attributes and will often vary between different
compilers or different versions of the CLR.
As a result, when ValueSourceAttribute appears multiple times on a
parameter or when other data-providing attributes are used in combination with
ValueSourceAttribute, the order of the arguments is undefined.
However, when a single ValueSourceAttribute is used by itself,
the order of the arguments follows exactly the order in which the data
is returned from the source.
Note on Object Construction
NUnit locates the test cases at the time the tests are loaded, creates
instances of each class with non-static sources and builds a list of
tests to be executed. Each source object is only created once at this
time and is destroyed after all tests are loaded.
If the data source is in the test fixture itself, the object is created
using the appropriate constructor for the fixture parameters provided on
the TestFixtureAttribute, or
the default constructor if no parameters were specified. Since this object
is destroyed before the tests are run, no communication is possible between
these two phases - or between different runs - except through the parameters
themselves.
The console interface has a few additional options compared to the forms
interface. The command line must always specify one or more file names. The
console interface normally creates an XML representation of the test results.
This file by default is called TestResult.xml and is placed in the working
directory.
Note: By default the nunit-console program is not added to your path. You
must do this manually if this is the desired behavior.
Note: Under the Windows operating system, options may be prefixed by either
a forward slash or a hyphen. Under Linux, a hyphen must be used. Options that
take values may use an equal sign, a colon or a space to separate the option
from its value.
Specifying Which Tests to Run
Specifying an Assembly
The console program must always have an assembly or project specified. To run
the tests contained in the nunit.tests.dll use the following command:
nunit-console nunit.tests.dll
To run the tests in nunit.tests.dll through the Visual Studio project, use:
nunit-console nunit.tests.csproj
To run the same tests through an NUnit test project you have defined, use:
nunit-console nunit.tests.nunit
Specifying an Assembly and a Test to be Run
You may specify a test to be run by providing the full name of the test along
with the containing assembly. For example to run NUnit.Tests.AssertionTests
in the nunit.tests assembly use the following command:
Unlike the deprecated /fixture option, this option affects the running
rather than the loading of the tests. Consequently it supports much broader use,
including situations involving SetUpFixtures, which are not run if the class
in question is not loaded. You should use /run in lieu of /fixture
in most cases.
Specifying Tests to be Run Using a Separate File
You may specify a list of tests to be run by creating a separate file listing
those tests and using the /runlist option:
The file 'testlist.txt' should contain the full name of each test, listed one per line.
Each test named may be a test case, test fixture or a namesspace containing tests. Lines
with the character '#' in the first column are treated as comments.
Specifying an Assembly and a Fixture to be Loaded (Deprecated)
When specifying a fixture, you must give the full name of the test fixture
along with the containing assembly. For example, to load the
NUnit.Tests.AssertionTests in the nunit.tests.dll assembly use the following
command:
The name specified after the /fixture option may be that of a TestFixture
class, a legacy suite (using the Suite property ) or a namespace. If a
namespace is given, then all fixtures under that namespace are loaded.
This option is provided for backward compatibility. In most cases, you will
be better served by using the /test option.
Specifying Multiple Assemblies
You may run tests from multiple assemblies in one run using the console
interface even if you have not defined an NUnit test project file. The
following command would run a suite of tests contained in assembly1.dll,
assembly2.dll and assembly3.dll.
Notes: You may specify multiple assemblies, but not multiple NUnit or
Visual Studio projects on the command line. Further, you may not specify an
NUnit or Visual Studio project together with a list of assemblies.
Beginning with NUnit 2.4, the console loads multiple assemblies specified
in this way into separate AppDomains by default. You may provide a separate
config file for each assembly. You may override the default by use of the
/domain option.
Beginning with NUnit 2.4, the /fixture
option, when used with multiple assemblies, will run tests matching the
fixture name in all the assemblies. In earlier versions, only the first
test found was executed.
Specifying which Configuration to run
When running tests from a Visual Studio or NUnit project, the first
configuration found will be loaded by default. Usually this is Debug. The
configuration loaded may be controlled by using the /config switch. The
following will load and run tests for the Release configuration of
nunit.tests.dll.
nunit-console nunit.tests.csproj /config:Release
Note: This option has no effect when loading an assembly directly.
Specifying Test Categories to Include or Exclude
NUnit provides CategoryAttribute for use in marking tests as belonging to
one or more categories. Categories may be included or excluded in a test run
using the /include and /exclude options. The following command
runs only the tests in the BaseLine category:
nunit-console myassembly.dll /include:BaseLine
The following command runs all tests except those in the Database
category:
nunit-console myassembly.dll /exclude:Database
Multiple categories may be specified on either option, by using commas to
separate them.
Notes: Beginning with NUnit 2.4, the /include and /exclude options may
be combined on the command line. When both are used, all tests with the included
categories are run except for those with the excluded categories.
Beginning with NUnit 2.4.6, you may use a Category Expression with
/include or /exclude. The table shows some examples:
Expression
Action
A|B|C
Selects tests having any of the categories A, B or C.
A,B,C
Selects tests having any of the categories A, B or C.
A+B+C
Selects only tests having all three of the categories assigned
A+B|C
Selects tests with both A and B OR with category C.
A+B-C
Selects tests with both A and B but not C.
-A
Selects tests not having category A assigned
A+(B|C)
Selects tests having both category A and either of B or C
A+B,C
Selects tests having both category A and either of B or C
Note: As shown by the last two examples, the comma operator is
equivalent to | but has a higher precendence. Order of evaluation is as follows:
Unary exclusion operator (-)
High-precendence union operator (,)
Intersection and set subtraction operators (+ and binary -)
Low-precedence union operator (|)
Note: Because the operator characters have special meaning,
you should avoid creating a category that uses any of them in it's name.
For example, the category "db-tests" could not be used on the command
line, since it appears to means "run category db, except for category tests."
The same limitation applies to characters that have special meaning for
the shell you are using.
Most applications are written to run under a specific version of the CLR.
A few are designed to operate correctly under multiple versions. In either case,
it is important to be able to specify the CLR version to be used for testing.
Prior to NUnit 2.5, it was necessary to run the console program itself using
the CLR version under which you wanted to run tests. This was done either by
editing the nunit-console.exe.config file or by setting the COMPLUS_Version
environment variable before running the program.
Under NUnit 2.5 and later versions, you may still use either of these approaches,
but a simpler method is available.
The /framework option allows you to specify the version of the runtime
to be used in executing tests. If that version specified is different from the
one being used by NUnit, the tests are run in a separate process. For example,
you may enter
nunit-console myassembly.dll /framework:net-1.1
This command will run tests under .NET 1.1 even if you are running the .NET 2.0
build of the nunit-console. Beginning with version 2.5.3, all versions of .NET
through 4.0 as well as Mono profiles 1.0, 2.0 and 3.5 are supported.
Note: This option is not available using the .NET 1.1 build of nunit-console.
Controlling the Use of Processes
The /process option controls how NUnit loads tests in processes. The
following values are recognized.
Single
All the tests are run in the nunit-console process. This is the default.
Separate
A separate process is created to run the tests.
Multiple
A separate process is created for each test assembly, whether specified
on the command line or listed in an NUnit project file.
Note: This option is not available using the .NET 1.1 build of nunit-console.
Controlling the Use of AppDomains
The /domain option controls of the creation of AppDomains for running tests.
The following values are recognized:
None
No domain is created - the tests are run in the primary domain. This normally
requires copying the NUnit assemblies into the same directory as your tests.
Single
A test domain is created - this is how NUnit worked prior to version 2.4
Multiple
A separate test domain is created for each assembly
The default is to use multiple domains if multiple assemblies are listed on
the command line. Otherwise a single domain is used.
Controlling the Apartment in Which Tests Run
The /apartment option may be used to specify the ApartmentState (STA or MTA)
of the test runner thread. Since the default is MTA, the option is
only needed to force execution in the Single Threaded Apartment.
Note: If a given test must always run in a particular apartment,
as is the case with many Gui tests, you should use an attribute on the test rather
than specifying this option at the command line.
Specifying a Default Timeout Value
The /timeout option takes an int value representing the default timeout
to be used for test cases in this run. If any test exceeds the timeout value,
it is cancelled and reported as an error. The default value may be overridden
for selected tests by use of TimeoutAttribute.
Note: If you do not use this option, no timeout is set and tests
may run for any amount of time.
Controlling the Output of a Test Run
Redirecting Text Output
Output created by the test, which is normally shown on the console, may be
redirected to a file. The following command redirects standard output to the
file TestResult.txt:
nunit-console nunit.tests.dll /out:TestResult.txt
The following command redirects standard error output to the StdErr.txt file.
nunit-console nunit.tests.dll /err:StdErr.txt
Note:This option only redirects output produced by the tests,
together with selected NUnit output that is interspersed with the test output.
It does not redirect all console output. If you want to redirect all
output to a file, you should use command line redirection as supported by the
shell you are using. This option exists for the purpose of separating test
output from other output, such as the NUnit summary report.
Labeling Text Output
The output from each test normally follows right after that of the preceding
test. You may use the /labels option to cause an identifying label to be
displayed at the start of each test case.
Specifying the XML result file name
As stated above, the console program normally creates an XML representation of the
test results. To change the name of the output file to
"console-test.xml" use the following command line option:
The XML output may be entirely eliminated by use of the /noresult option.
Note: For compatibility with earlier releases, NUnit 2.6 also recognizes /xml
and /noxml as synonyms for the /result and /noresult options.
Note: For additional information see the XML schema for the test results.
This file is in the same directory as the executable and is called
Results.xsd.
Specifying a Directory for Output
By default, all output files are created in the current directory. You may
change the location for such files by specifying the /work option. For
example, the following command would cause the TestResult.xml and Output.txt
files to be created in the results directory.
The /trace option allows you to control the amount of information that NUnit
writes to its internal trace log. Valid values are Off, Error, Warning,Info
and Debug. The default is Off.
The /noshadow option disables shadow copying of the assembly in order to
provide improved performance.
The /nothread option suppresses use of a separate thread for running the
tests and uses the main thread instead.
The /stoponerror option causes execution of the test run to terminate
immediately on the first test failure or error.
The /wait option causes the program to wait for user input before
exiting. This is useful when running nunit-console from a shortcut.
The /xmlconsole option displays raw XML output on the console rather than
transforming it. This is useful when debugging problems with the XML format.
The /nologo option disables display of the copyright information at the
start of the program.
The /cleanup option clears the shadow copy cache and exits.
The /help or /? option displays a brief help message
namespace NUnit.Tests
{
using System;
using NUnit.Framework;
[TestFixture, Property("Location",723)]
public class MathTests
{
[Test, Property("Severity", "Critical")]
public void AdditionTest()
{ /* ... */ }
}
}
Imports System
Imports Nunit.Framework
Namespace Nunit.Tests
<TestFixture(), Property("Location",723)>
Public Class MathTests
<Test(), Property("Severity","Critical")>
Public Sub AdditionTest()
' ...
End Sub
End Class
End Namespace
#using <Nunit.Framework.dll>
using namespace System;
using namespace NUnit::Framework;
namespace NUnitTests
{
[TestFixture, Property("Location",723)]
public __gc class MathTests
{
[Test, Property("Severity","Critical")] void AdditionTest();
};
}
#include "cppsample.h"
namespace NUnitTests {
// ...
}
The PropertyAttribute is not used for any purpose by NUnit itself, but
it does display them in the XML output file and in the Test Properties
dialog of the gui.
It is
possible to write extensions that access the value of specific properties.
It is also possible to access the value of properties from within a test
using reflection.
Custom Property Attributes
Users can define custom
attributes that derive from PropertyAttribute and have them
recognized by NUnit. PropertyAttribute provides a protected constructor
that takes the value of the property and sets the property name to the
name of the derived class. NUnit itself uses this facility: some of
it's specialized attributes are actually specializations of PropertyAttribute.
Here's an example that creates a Severity property. It works
just like any other property, but has a simpler syntax and is type-safe.
A test reporting system might make use of the property to provide special reports.
public enum SeverityLevel
{
Critical,
Major,
Normal,
Minor
}
[AttributeUsage(AttributeTargets.Method, AllowMultiple=false)]
public class SeverityAttribute : PropertyAttribute
{
public SeverityAttribute( SeverityLevel level )
: base( level );
}
...
[Test, Severity( SeverityLevel.Critical)]
public void MyTest()
{ /*...*/ }
Beginning with NUnit 2.5, a property attribute is able to contain
multiple name/value pairs. This capability is not exposed publicly
but may be used by derived property classes. NUnit uses this
feature itself for certain attributes. See, for example,
RequiresThreadAttribute.
Comparison constraints are able to test whether one value
is greater or less than another. Comparison constraints work
on numeric values, as well as other objects that implement the
IComparable interface or - beginning with NUnit 2.5 -
IComparable<T>.
Beginning with NUnit 2.5, you may supply your own comparison
algorithm through the Using modifier.
GreaterThanConstraint
Action
Tests that one value is greater than another.
Constructor
GreaterThanConstraint(object expected)
Syntax
Is.GreaterThan(object expected)
Is.Positive // Equivalent to Is.GreaterThan(0)
The Test attribute is one way of marking a method inside a TestFixture class
as a test. For backwards compatibility with previous versions of Nunit a
test method may also be found if the first 4 letters are "test"
regardless of case. This option is available by setting a value in
the config file for the test.
Prior to NUnit 2.5, the signature for a test method was:
public void MethodName()
Beginning with NUnit 2.5, static methods may be used as tests:
public static void MethodName()
In addition, with 2.5, test methods may have arguments and return
values, provided that NUnit is told what values to use for the
arguments and how to handle the return value. For more information
on these capabilities, see
Parameterized Tests as well as some of the related attributes
listed at the end of this page.
Parameterized test methods may also be generic, provided that
NUnit is able to deduce the proper argument types from the
types of the data arguments supplied.
If the programmer marks a test method that does not have the correct signature
it will be considered as not runnable and be indicated as such by the console
or gui runner. In the Gui, such tests are marked in red.
In the examples on this page, NUnit would have no way of knowing what values
to supply as arguments, so methods without parameters are used.
namespace NUnit.Tests
{
using System;
using NUnit.Framework;
[TestFixture]
public class SuccessTests
{
[Test] public void Add()
{ /* ... */ }
public void TestSubtract()
{ /* backwards compatibility */ }
}
}
Imports System
Imports Nunit.Framework
Namespace Nunit.Tests
<TestFixture()> Public Class SuccessTests
<Test()> Public Sub Add()
' ...
End Sub
End Class
End Namespace
#using <Nunit.Framework.dll>
using namespace System;
using namespace NUnit::Framework;
namespace NUnitTests
{
[TestFixture]
public __gc class SuccessTests
{
[Test] void Add();
};
}
#include "cppsample.h"
namespace NUnitTests {
// ...
}
package NUnit.Tests;
import System.*;
import NUnit.Framework.TestFixture;
/** @attribute NUnit.Framework.TestFixture() */
public class SuccessTests
{
/** @attribute NUnit.Framework.Test() */
public void Add()
{ /* ... */ }
}
Version 1 of NUnit used the classic approach to identifying tests based on
inheritance and naming conventions. From version 2.0 on, NUnit has used custom
attributes for this purpose.
Because NUnit test fixtures do not inherit from a framework class, the developer
is free to use inheritance in other ways. And because there is no arbitrary
convention for naming tests, the choice of names can be entirely oriented
toward communicating the purpose of the test.
All NUnit attributes are contained in the NUnit.Framework namespace. Each source
file that contains tests must include a using statement for that namespace and
the project must reference the framework assembly, nunit.framework.dll.
Beginning with NUnit 2.4.6, NUnit's attributes are no longer sealed and any
attributes that derive from them will be recognized by NUnit.
The samples installed with NUnit continue to be organized by language, with an additional
folder for Extensibility examples. The 'money-port' example has been
removed as of NUnit 2.5.
C# Samples
Failures
This sample written in C# demonstrates 4 failing unit tests and one test
that is not run.
Money
This is a C# version of the money example which is found in most xUnit
implementations. Thanks to Kent Beck.
J# Samples
Failures
This has three failing tests and one ignored test written in J#.
VB.NET Samples
Failures
This sample written in VB.NET demonstrates 4 failing unit tests and
one test that is not run.
Money
This is a VB.NET version of the money example which is found in most xUnit
implementations. Thanks to Kent Beck.
Managed C++ Samples
Failures
This is the same example as the others with four failing unit
tests and one ignored test. NOTE: The results are as expected when
compiled in Debug mode. In Release mode the divide by zero test succeeds.
C++/CLI Samples
Failures
This is the same example as the others with four failing unit
tests and one ignored test.
Extensibility Examples
Minimal
The smallest possible Addin: it does nothing but is
recognized by NUnit and listed in the Addins dialog.
SampleSuiteExtension
A "toy" SuiteBuilder. It recognizes a special attribute
and identifies tests right in the suite extension. This example
uses separate objects for the addin and the suite builder.
SampleFixtureExtension
A slightly more involved SuiteBuilder. It recognizes
a special attribute and registers a test case builder to
identify its tests. It inherits from NUnitTestFixture and
so gets all the features of that class as well for free.
This example uses the same object to implement both the
addin and the suite builder.
An Extenders Guide will be published in the future. At the moment, writing an
extension is a bit of an adventure. Extension authors are advised to join the
nunit-developer list and post questions and comments there.
For the moment, the following tips may be of assistance.
The nunit.core.interfaces assembly is intended to be stable in the future
while the nunit.core assembly will change from release to release. Right now,
both assemblies are still in flux, but extensions that depend solely on the interfaces
assembly will have a much better chance of surviving NUnit version changes. Unfortunately,
this is rather difficult to do without duplicating a great deal of NUnit code. Most
of the add-in samples provided with NUnit are currently version dependent.
If you place the definition of a custom attribute in the same assembly as your
add-in, then user tests are dependent on the add-in assembly. If the add-in is
version-dependent, then the user tests will also be version-dependent. We suggest
placing any types referenced by user tests in a separate assembly, particularly if
your extension relies on nunit.core.
If using Visual Studio, set Copy Local to false for any references to nunit.core
or nunit.core.interfaces. This is especially important if you are also building
NUnit itself.
There is currently no mechanism to allow decorators to apply in a particular order.
NUnit applies decorators in the order in which they are returned through reflection,
which may vary among different runtimes.
Avoid trying to "stretch" the existing extension points to do more than they were
intended to do. Rather, let us know what further extension points you would like to see!
Note: This page is based on the original QuickStart.doc, found in
earlier releases of NUnit. It has been pointed out that it isn't a good
example of Test-Driven Development. However, we're keeping it in the docs
because it does illustrate the basics of using NUnit. We'll revise or replace
it in a future release.
Lets start with a simple example. Suppose we are writing a bank application and we have a basic domain class Account. Account supports operations to deposit, withdraw, and transfer funds. The Account class may look like this:
namespace bank
{
public class Account
{
private float balance;
public void Deposit(float amount)
{
balance+=amount;
}
public void Withdraw(float amount)
{
balance-=amount;
}
public void TransferFunds(Account destination, float amount)
{
}
public float Balance
{
get{ return balance;}
}
}
}
Now lets write a test for this class AccountTest. The first method we will test is TransferFunds.
namespace bank
{
using NUnit.Framework;
[TestFixture]
public class AccountTest
{
[Test]
public void TransferFunds()
{
Account source = new Account();
source.Deposit(200.00F);
Account destination = new Account();
destination.Deposit(150.00F);
source.TransferFunds(destination, 100.00F);
Assert.AreEqual(250.00F, destination.Balance);
Assert.AreEqual(100.00F, source.Balance);
}
}
}
The first thing to notice about this class is that it has a [TestFixture] attribute associated with it this is the way to indicate that the class contains test code (this attribute can be inherited). The class has to be public and there are no restrictions on its superclass. The class also has to have a default constructor.
The only method in the class TransferFunds, has a [Test] attribute associated with it this is an indication that it is a test method. Test methods have to return void and take no parameters. In our test method we do the usual initialization of the required test objects, execute the tested business method and check the state of the business objects. The Assert class defines a collection of methods used to check the post-conditions and in our example we use the AreEqual method to make sure that after the transfer both accounts have the correct balances (there are several overloadings of this method, the version that was used in this example has the following parameters : the first parameter is an expected value and the second parameter is the actual value).
Compile and run this example. Assume that you have compiled your test code into a bank.dll. Start the NUnit Gui (the installer will have created a shortcut on your desktop and in the Program Files folder), after the GUI starts, select the File->Open menu item, navigate to the location of your bank.dll and select it in the Open dialog box. When the bank.dll is loaded you will see a test tree structure in the left panel and a collection of status panels on the right. Click the Run button, the status bar and the TransferFunds node in the test tree turn red our test has failed. The Errors and Failures panel displayed the following message:
TransferFunds : expected <250> but was <150>
and the stack trace panel right below it reported where in the test code the failure has occurred
at bank.AccountTest.TransferFunds() in C:\nunit\BankSampleTests\AccountTest.cs:line 17
That is expected behavior; the test has failed because we have not implemented the TransferFunds method yet. Now lets get it to work. Dont close the GUI and go back to your IDE and fix the code, make your TransferFunds method look like this:
public void TransferFunds(Account destination, float amount)
{
destination.Deposit(amount);
Withdraw(amount);
}
Now recompile your code and click the run button in GUI again the status bar and the test tree turn green. (Note how the GUI has reloaded the assembly automatically for you; we will keep the GUI open all the time and continue working with our code in IDE and write more tests).
Lets add some error checking to our Account code. We are adding the minimum balance requirement for the account to make sure that banks continue to make their money by charging your minimal overdraft protection fee. Lets add the minimum balance property to our Account class:
We will use an exception to indicate an overdraft:
namespace bank
{
using System;
public class InsufficientFundsException : ApplicationException
{
}
}
Add a new test method to our AccountTest class:
[Test]
[ExpectedException(typeof(InsufficientFundsException))]
public void TransferWithInsufficientFunds()
{
Account source = new Account();
source.Deposit(200.00F);
Account destination = new Account();
destination.Deposit(150.00F);
source.TransferFunds(destination, 300.00F);
}
This test method in addition to [Test] attribute has an [ExpectedException] attribute associated with it this is the way to indicate that the test code is expecting an exception of a certain type; if such an exception is not thrown during the execution the test will fail. Compile your code and go back to the GUI. As you compiled your test code, the GUI has grayed out and collapsed the test tree as if the tests were not run yet (GUI watches for the changes made to the test assemblies and updates itself when the structure of the test tree has changed e.g. new test is added). Click the Run button we have a red status bar again. We got the following Failure :
TransferWithInsufficentFunds : InsufficientFundsException was expected
Lets fix our Account code again, modify the TransferFunds method this way:
public void TransferFunds(Account destination, float amount)
{
destination.Deposit(amount);
if(balance-amount<minimumBalance)
throw new InsufficientFundsException();
Withdraw(amount);
}
Compile and run the tests green bar. Success! But wait, looking at the code weve just written we can see that the bank may be loosing money on every unsuccessful funds Transfer operation. Lets write a test to confirm our suspicions. Add this test method:
[Test]
public void TransferWithInsufficientFundsAtomicity()
{
Account source = new Account();
source.Deposit(200.00F);
Account destination = new Account();
destination.Deposit(150.00F);
try
{
source.TransferFunds(destination, 300.00F);
}
catch(InsufficientFundsException expected)
{
}
Assert.AreEqual(200.00F,source.Balance);
Assert.AreEqual(150.00F,destination.Balance);
}
We are testing the transactional property of our business method all operations are successful or none. Compile and run red bar. OK, weve made $300.00 out of a thin air (1999.com dj vu?) the source account has the correct balance of 200.00 but the destination account shows : $450.00. How do we fix this? Can we just move the minimum balance check call in front of the updates:
public void TransferFunds(Account destination, float amount)
{
if(balance-amount<minimumBalance)
throw new InsufficientFundsException();
destination.Deposit(amount);
Withdraw(amount);
}
What if the Withdraw() method throws another exception? Should we execute a compensating transaction in the catch block or rely on our transaction manager to restore the state of the objects? We need to answer those questions at some point, but not now; but what do we do with the failing test in the meantime remove it? A better way is to temporarily ignore it, add the following attribute to your test method
[Test]
[Ignore("Decide how to implement transaction management")]
public void TransferWithInsufficientFundsAtomicity()
{
// code is the same
}
Compile and run yellow bar. Click on Tests Not Run tab and you will see bank.AccountTest.TransferWithInsufficientFundsAtomicity() in the list along with the Reason this test is ignored.
Looking at our test code we can see that some refactoring is in order. All test methods share a common set of test objects. Lets extract this initialization code into a setup method and reuse it in all of our tests. The refactored version of our test class looks like this:
namespace bank
{
using System;
using NUnit.Framework;
[TestFixture]
public class AccountTest
{
Account source;
Account destination;
[SetUp]
public void Init()
{
source = new Account();
source.Deposit(200.00F);
destination = new Account();
destination.Deposit(150.00F);
}
[Test]
public void TransferFunds()
{
source.TransferFunds(destination, 100.00f);
Assert.AreEqual(250.00F, destination.Balance);
Assert.AreEqual(100.00F, source.Balance);
}
[Test]
[ExpectedException(typeof(InsufficientFundsException))]
public void TransferWithInsufficientFunds()
{
source.TransferFunds(destination, 300.00F);
}
[Test]
[Ignore("Decide how to implement transaction management")]
public void TransferWithInsufficientFundsAtomicity()
{
try
{
source.TransferFunds(destination, 300.00F);
}
catch(InsufficientFundsException expected)
{
}
Assert.AreEqual(200.00F,source.Balance);
Assert.AreEqual(150.00F,destination.Balance);
}
}
}
Note that Init method has the common initialization code, it has void return type, no parameters, and it is marked with [SetUp] attribute. Compile and run same yellow bar!
The NUnit Test Adapter allows you to run NUnit tests inside
Visual Studio. The current release, version 0.90, only works
with the Visual Studio 11 Developer Preview, which is available
for download from Microsoft. Earlier releases of Visual Studio
did not have the ability to recognize tests built with Open
Source testing frameworks like NUnit.
Installation
The easiest way to install the NUnit Test Adapter is using the
Extension Manager within Visual Studio. Follow these steps:
From within Visual Studio 11, select Tools | Extension Manager.
In the left panel of the Extension Manager, select Online Extensions.
Locate the NUnit Test Adapter in the center panel and highlight it.
Click 'Download' and follow the instructions.
Use the Extension Manager to ensure that the NUnit Test Adapter is enabled.
Usage
In preparation for using the test adapter, make sure that the Unit
Test Explorer is shown in your window. If you don't see it, use
View | Other Windows | Unit Test Explorer to show it and position
the window where you would like it within Visual Studio.
When you initially open a solution, no tests will be displayed.
After compiling the assemblies in the solution, Visual Studio will
interact with the NUnit Test Adapter to discover tests and a list
of them will be shown in the Unit Test Explorer.
Click on Run All Tests in the Unit Test Explorer to run
all the tests. You may also select one or more tests in the list and
run them by right-clicking and using the context menu.
The context menu also contains entries for debugging tests and for
navigating to the source code of a test.
Known Problems
There is no test status corresponding to NUnit's Inconclusive
result, so tests with this result are reported as Not Run.
Test cases appear in a flat list, without any grouping by fixture or
namespace. This can make it hard to select a group of related tests
to be run. It is, however, relatively easy to rerun all failing tests.
Theories are reported as individual cases, rather as a single unit.
Startup performance is rather poor in this release.
Reporting Problems
Until a separate project is created, bugs should be reported using
the NUnit bug list.
Path constraints perform tests on paths, without reference to any
actual files or directories. This allows testing paths that are
created by an application for reference or later use, without
any effect on the environment.
Path constraints are intended to work across multiple file systems,
and convert paths to a canonical form before comparing them.
It is usually not necessary to know the file system of the paths
in order to compare them. Where necessary, the programmer may
use the IgnoreCase and RespectCase modifiers to provide
behavior other than the system default.
This documentation covers the NUnit 2.6 release,
introducing a large set of new features to NUnit, particularly in
the area of parameterized or data-driven testing.
Where applicable, we have marked sections with the version in which a feature
first appeared.
If you are new to NUnit, we suggest you begin by reading the
Getting Started section of this site.
Those who have used earlier releases may want to begin with the
Upgrading section.
See the
Release Notes for more information on this release.
All documentation is included in the release packages of NUnit. Beginning with NUnit
2.4.2, you may choose to download the documentation
separately.
NUnit isolates test assemblies from its own code and from one another
by use of separate AppDomains and/or Processes.
By default, NUnit loads a test assembly into a separate AppDomain,
while its own code runs in the primary AppDomain.
When multiple assemblies are run at the same time, NUnit loads them differently
depending on how they were specified. For assemblies that are part of an
NUnit project, then a single AppDomain is used. If the assemblies
were specified on the console runner command line, then a separate
AppDomain is used for each of them.
If greater separation is desired, test assemblies may be loaded into
a separate Process or into multiple processes. This is done
automatically by NUnit in the case where the tests are to be run under
a different runtime from the one that NUnit is currently using. Tests
running in a separate process are executed under the control of the
nunit-agent program.
Controlling Isolation
Beyond the NUnit default behavior, the user may control the level of isolation
through the command line or through NUnit's general settings. Process and AppDomain
isolation may also be specified as part of the settings of an NUnit project.
Command Line
Assembly Isolation may be specified on the console runner commandline using
the /process and /domain options. See
NUnit-Console Command Line Options for more information.
General Settings
The built-in NUnit defaults may be overridden using the Assembly Isolation
panel of the NUnit Settings Dialog. Settings made here are saved and become
the new default values for all executions of NUnit until changed. For more info,
see the Settings Dialog page.
Project Settings
Isolation settings may be specified for an individual NUnit project using the
Project Editor.
The Explicit attribute causes a test or test fixture to be ignored unless it is
explicitly selected for running. The test or fixture will be run if it is
selected in the gui, if its name is specified on the console runner command
line as the fixture to run or if it is included by use of a Category filter.
An optional string argument may be used to give the reason for marking
the test Explicit.
If a test or fixture with the Explicit attribute is encountered in the course of
running tests, it is skipped unless it has been specifically selected by one
of the above means. The test does not affect the outcome of the run at all:
it is not considered as ignored and is not even counted in the total number
of tests. In the gui, the tree node for the test remains gray and the
status bar color is not affected.
Note: In versions of NUnit prior to 2.4, these tests were
shown as ignored.
namespace NUnit.Tests
{
using System;
using NUnit.Framework;
[TestFixture]
public class SuccessTests
{
[Test, Explicit]
public void ExplicitTest()
{ /* ... */ }
}
Imports System
Imports Nunit.Framework
Namespace Nunit.Tests
<TestFixture()>
Public Class SuccessTests
<Test(), Explicit()> Public Sub ExplicitTest()
' ...
End Sub
End Class
End Namespace
#using <Nunit.Framework.dll>
using namespace System;
using namespace NUnit::Framework;
namespace NUnitTests
{
[TestFixture]
public __gc class SuccessTests
{
[Test][Explicit] void ExplicitTest();
};
}
#include "cppsample.h"
namespace NUnitTests {
// ...
}
An EqualConstraint is used to test whether an actual value
is equal to the expected value supplied in its constructor,
optionally within a specified tolerance.
Values of type float and double are normally compared using a tolerance
specified by the Within modifier. The special values PositiveInfinity,
NegativeInfinity and NaN compare
as equal to themselves.
With version 2.5, floating-point values may be compared using a tolerance
in "Units in the Last Place" or ULPs. For certain types of numerical work,
this is safer than a fixed tolerance because it automatically compensates
for the added inaccuracy of larger numbers.
String comparisons normally respect case. The IgnoreCase modifier
causes the comparison to be case-insensitive. It may also be used when
comparing arrays or collections of strings.
DateTimes and TimeSpans may be compared either with or without
a tolerance. A tolerance is specified using Within with either a
TimeSpan as an argument or with a numeric value followed by a one of
the time conversion modifiers: Days, Hours, Minutes,
Seconds, Milliseconds or Ticks.
DateTime now = DateTime.Now;
DateTime later = now + TimeSpan.FromHours(1.0);
Assert.That( now, Is.EqualTo(now) );
Assert.That( later. Is.EqualTo(now).Within(TimeSpan.FromHours(3.0);
Assert.That( later, Is.EqualTo(now).Within(3).Hours;
Comparing Arrays and Collections
Since version 2.2, NUnit has been able to compare two single-dimensioned arrays.
Beginning with version 2.4, multi-dimensioned arrays, nested arrays (arrays of arrays)
and collections may be compared. With version 2.5, any IEnumerable is supported.
Two arrays, collections or IEnumerables are considered equal if they have the
the same dimensions and if each of the corresponding elements is equal.
If you want to treat two arrays of different shapes as simple collections
for purposes of comparison, use the AsCollection modifier, which causes
the comparison to be made element by element, without regard for the rank or
dimensions of the array. Note that jagged arrays (arrays of arrays) do not
have a single underlying collection. The modifier would be applied
to each array separately, which has no effect in most cases.
Dictionaries implement ICollection, and NUnit has treated
them as collections since version 2.4. However, this did not
give useful results, since the dictionary entries had to be
in the same order for the comparison to succeed and the
underlying implementation had to be the same.
Beginning with NUnit 2.5.6, NUnit has specific code for
comparing dictionaries. Two dictionaries are considered equal if
The list of keys is the same - without regard to ordering.
The values associated with each key are equal.
You can use this capability to compare any two objects implementing
IDictionary. Generic and non-generic dictionaries (Hashtables)
may be successfully compared.
User-Specified Comparers
If the default NUnit or .NET behavior for testing equality doesn't
meet your needs, you can supply a comparer of your own through the
Using modifier. When used with EqualConstraint, you
may supply an IEqualityComparer, IEqualityComparer<T>,
IComparer, IComparer<T>; or Comparison<T>
as the argument to Using.
Prior to NUnit 2.6, only one comparer could be used. If multiple
comparers were specified, all but one was ignored. Beginning with NUnit 2.6,
multiple generic comparers for different types may be specified. NUnit
will use the appropriate comparer for any two types being compared. As a result,
it is now possible to provide a comparer for an array, a collection type or
a dictionary. The user-provided comparer will be used directly, bypassing the
default NUnit logic for array, collection or dictionary equality.
class ListOfIntComparer : IEqualityComparer<List<int>>
{
...
}
var list1 = new List<int>();
var list2 = new List<int>();
var myComparer = new ListOfIntComparer();
...
Assert.That( list1, Is.EqualTo(list2).Using( myComparer ) );
Notes
When checking the equality of user-defined classes, NUnit first examines each class to determine whether it implements IEquatable<T>. If either object implements the interface for the type of the other object, then that implementation is used in making the comparison. If neither class implements the appropriate interface, NUnit makes use
of the Equals override on the expected object. If you neglect to either implement IEquatable<T> or to
override Equals, you can expect failures comparing non-identical objects.
In particular, overriding operator== without overriding Equals
or implementing the interface has no effect.
The Within modifier was originally designed for use with floating point
values only. Beginning with NUnit 2.4, comparisons of DateTime values
may use a TimeSpan as a tolerance. Beginning with NUnit 2.4.2,
non-float numeric comparisons may also specify a tolerance.
Beginning with NUnit 2.4.4, float and double comparisons for which no
tolerance is specified use a default, use the value of
GlobalSettings.DefaultFloatingPointTolerance. If this is not
set, a tolerance of 0.0d is used.
Prior to NUnit 2.2.3, comparison of two NaN values would always fail,
as specified by IEEE floating point standards. The new behavior, was
introduced after some discussion becuase it seems more useful in tests.
To avoid confusion, consider using Is.NaN where appropriate.
When an equality test between two strings fails, the relevant portion of
of both strings is displayed in the error message, clipping the strings to
fit the length of the line as needed. Beginning with 2.4.4, this behavior
may be modified by use of the NoClip modifier on the constraint. In
addition, the maximum line length may be modified for all tests by setting
the value of TextMessageWriter.MaximumLineLength in the appropriate
level of setup.
When used with arrays, collections or dictionaries, EqualConstraint
operates recursively. Any modifiers are saved and used as they apply to
individual items.
A user-specified comparer will not be called by EqualConstraint
if either or both arguments are null. If both are null, the Constraint
succeeds. If only one is null, it fails.
NUnit has special semantics for comparing Streams and
DirectoryInfos. For a Stream, the contents are compared.
For a DirectoryInfo, the first-level directory contents are compared.
PNUnit stands for "Parallel NUnit." It is an extension of NUNit
developed by Pablo Santos Luaces and his team at Codice Software for
their internal use in testing the Plastic (TM) Software Configuration
Management System. Codice released PNUnit to the community in 2007.
As part of the NUnit 2.5 release, we worked with the NUnit and PNUnit
teams worked together to make PNUnit work with NUnit without any modifications.
PNUnit is now included in the NUnit distribution.
How it Works
PNUnit is not intended for "casual" parallelism merely to
make the tests run faster. Rather, it's intended as a way to test
applications composed of distributed, communicating components. Tests
of each component run in parallel and use memory barriers to synchronize
their operation.
PNUnit uses a special executable to launch its tests.
The launcher reads an xml file that specifies the tests to be
executed and where they should run, whether on the same machine or
on another machine on the network.
NUnit uses configuration files for the test runner executable either nunit-console.exe or
nunitgui.exe as well as for the tests being run. Only settings that pertain to NUnit itself should be in
the nunit-console.exe.config and nunit-gui.exe.config, while those that pertain to your own
application and tests should be in a separate configuration file.
NUnit Configuration Files
One main purpose of the nunit-console and nunit-gui config files is to allow
NUnit to run with various versions of the .NET framework. NUnit is built using
versions 1.1 and 2.0 of the framework. The two builds are provided as separate
downloads and either build can be made to run against other versions of the CLR.
As delivered, the section of each config file is commented out,
causing NUnit to run with the version of .NET used to build it. If you uncomment
the section, the entries there control the order in which alternate
framework versions are selected.
Test Configuration File
When a configuration file is used to provide settings or to control the environment in which a test
is run, specific naming conventions must be followed.
If a single assembly is being loaded, then the configuration file is given the name of the assembly
file with the config extension. For example, the configuration file used to run nunit.tests.dll must
be named nunit.tests.dll.config and located in the same directory as the dll.
If an NUnit project is being loaded into a single AppDomain, the configuration file uses the
name of the project file with the extension changed to config. For example, the project
AllTests.nunit would require a configuration file named AllTests.config, located in the same
directory as AllTests.nunit. The same rule is followed when loading Visual Studio projects or solutions.
Note: The above only applies if a single AppDomain is being used. If an NUnit
project is loaded using a separate AppDomain for each assembly, then the individual
configuration files for each of the assemblies are used.
Generally, you should be able to simply copy your application config file and rename it as
described above.
In versions of NUnit prior to 2.6, it was possible to change the behavior of
NUnit by adding special sections to the test config file. This feature is no
longer supported.
The following recommendations are provided in the case of each of the settings
that are no longer available:
OldStyleTestCases
NUnit no longer recognizes test methods without attributes.Use TestAttribute.
ApartmentState
We recommend the use of RequiresSTAAttribute or RequiresMTAAttribute
on those test cases, test fixtures or setup fixtures that require a particular apartment.
As a temporary measure, the nunit-console -apartment option may be used.
ThreadPriority
This is no longer supported.
DefaultLogThreshold
This is now controlled by a setting in the NUnit Gui runner.
Unlike Constraint classes, ListMapper is used to modify the actual
value argument to Assert.That(). It transforms the actual value, which
must be a collection, creating a new collection to be tested against the
supplied constraint. Currently, ListMapper supports one transformation: creating
a collection of property values.
Normally, ListMapper will be used through the List.Map() syntax helper
or the inherited syntax equivalent, Map(). The following example
shows three forms of the same assert:
By default the NUnit installation program places all of the files into the
C:\Program Files\NUnit 2.6 directory.
In the installation directory there are up to three sub-directories, depending
on what the user has chosen to install: bin, doc and samples.
Source code is no longer provided with the binary installation package but may
be downloaded separately.
Running NUnit
The installation program places a number of shortcuts in the start menu, which
run NUnit under .NET or Mono, depending on what is installed on your system.
For NUnit 2.5, the gui only runs under version 2.0 of the CLR, although tests
may be executed under other versions using a separate process.
Installation Verification
NUnit's own tests are available as an installation option. If you installed
the tests, you may verify that the installation has worked successfully by
running the NUnit gui and loading and running NUnitTests.nunit. All tests should pass.
Additional Tests
Additional tests are included with the samples and in separate assemblies used
as data by the verification tests themselves. Failures or not run conditions in
these tests are intentional.
Manual Installation
You may build NUnit from source using one of the Visual Studio solutions or
the NAnt script. In either case, an output directory is created, which
contains all files needed in the proper relative location. Just copy this
directory to a permanent location and create shortcuts if desired.
.NET 1.1 Support
NUnit's .NET 1.1 support is packaged as a separate download. It may be installed
independently, in which case it provides only a restricted version of the console
runner, or as part of the overall NUnit installation. When used together with
the primary NUnit installation, it allows you to run .NET 1.1 tests under the
Gui. For complete functionality, install in the same disk location used to
install NUnit itself.
TestCaseAttribute serves the dual purpose of marking a method with
parameters as a test method and providing inline data to be used when
invoking that method. Here is an example of a test being run three
times, with three different sets of data:
[TestCase(12,3,4)]
[TestCase(12,2,6)]
[TestCase(12,4,3)]
public void DivideTest(int n, int d, int q)
{
Assert.AreEqual( q, n / d );
}
Note: Because arguments to .NET attributes are limited in terms of the
Types that may be used, NUnit will make some attempt to convert the supplied
values using Convert.ChangeType() before supplying it to the test.
TestCaseAttribute may appear one or more times on a test method,
which may also carry other attributes providing test data, such as the
FactoriesAttribute.
The method may optionally be marked with the
TestAttribute as well.
By using the named parameter Result this test set may be simplified
further:
[TestCase(12,3, Result=4)]
[TestCase(12,2, Result=6)]
[TestCase(12,4, Result=3)]
public int DivideTest(int n, int d)
{
return( n / d );
}
In the above example, NUnit checks that the return
value of the method is equal to the expected result provided on the attribut
TestCaseAttribute supports a number of additional
named parameters, which may be used as follows:
Description
Sets the description property of the test
ExpectedException
Specifies a the Type of an exception that should be thrown by this invocation
ExpectedExceptionName
Specifies a the FullName of an exception that should be thrown by this invocation
ExpectedMessage
Specifies the message text of the expected exception
Explicit
Set to true in order to make the individual test case Explicit. Use Reason to explain why.
Ignore
Set to true in order to ignore the individual test case. Use Reason to explain why.
IgnoreReason
Causes this test case to be ignored and specifies the reason. Equivalent to Ignore combined with Reason. This attribute will be removed in a later release.
Specifies the reason for not running this test case. Use in conjunction with Ignore or Explicit.
Result
The expected result to be returned from the method, which must have
a compatible return type.
TestName
Provides a name for the test. If not specified, a name is generated based on
the method name and the arguments provided.
Order of Execution
In NUnit 2.5, individual test cases are sorted alphabetically and executed in
that order. Beginning with NUnit 2.5.1, the individual cases are not sorted, but are
executed in the order in which NUnit discovers them. This order does not
follow the lexical order of the attributes and will often vary between different
compilers or different versions of the CLR.
As a result, when TestCaseAttribute appears multiple times on a method
or when other data-providing attributes are used in combination with
TestCaseAttribute, the order of the test cases is undefined.
This is the attribute that marks a class that contains the one-time
setup or teardown methods for all the test fixtures under a given
namespace. The class may contain at most one method marked with the
SetUpAttribute and one method marked with the TearDownAttribute.
There are a few restrictions on a class that is used as a setup fixture.
It must be a publicly exported type or NUnit will not see it.
It must have a default constructor or NUnit will not be able to construct it.
The SetUp method in a SetUpFixture is executed once before any of the fixtures
contained in its namespace. The TearDown method is executed once after all the
fixtures have completed execution. In the examples below, the method RunBeforeAnyTests()
is called before any tests or setup methods in the NUnit.Tests namespace. The method
RunAfterAnyTests() is called after all the tests in the namespace as well as their
individual or fixture teardowns have completed exection.
Only one SetUpFixture should be created in a given namespace. A SetUpFixture
outside of any namespace provides SetUp and TearDown for the entire assembly.
namespace NUnit.Tests
{
using System;
using NUnit.Framework;
[SetUpFixture]
public class MySetUpClass
{
[SetUp]
RunBeforeAnyTests()
{
// ...
}
[TearDown]
RunAfterAnyTests()
{
// ...
}
}
}
Imports System
Imports Nunit.Framework
Namespace Nunit.Tests
<TestFixture()> Public Class MySetUpClass
<SetUp()> Public Sub RunBeforeAnyTests()
' ...
End Sub
<TearDown()> Public Sub RunAfterAnyTests()
' ...
End Sub
End Class
End Namespace
#using <Nunit.Framework.dll>
using namespace System;
using namespace NUnit::Framework;
namespace NUnitTests
{
[TestFixture]
public __gc class MySetUpClass
{
[SetUp] public void RunBeforeAnyTests();
[TearDown] public void RunAfterAnyTests();
};
}
#include "cppsample.h"
namespace NUnitTests {
// ...
}
package NUnit.Tests;
import System.*;
import NUnit.Framework.TestFixture;
/** @attribute NUnit.Framework.TestFixture() */
public class MySetUpClass
{
/** @attribute NUnit.Framework.SetUp() */
public void RunBeforeAnyTests()
{ /* ... */ }
/** @attribute NUnit.Framework.TearDown() */
public void RunAfterAnyTests()
{ /* ... */ }
}
The extension object passed to Install must implement the ITestDecorator interface:
public interface ITestDecorator
{
Test Decorate( Test test, MemberInfo member );
}
The Decorate method may do several things, depending on what it needs
to accomplish:
Return test unmodified
Modify properties of the test object and return it
Replace test with another object, either discarding the
original or aggregating it in the new test.
Depending on what the decorator does, it may need to run
ahead of other decorators or after them. Decorators should
be installed using the Install method overload that takes
a priority. The priorities range from 1 to 9 and decorators
with lower priority values are installed first. The following
standard values are defined for use if desired:
This attribute is used inside a TestFixture to provide a single set of
functions that are performed once prior to executing any of the tests
in the fixture.
Before NUnit 2.5, a TestFixture could have only one TestFixtureSetUp method
and it was required to be an instance method.
Beginning with NUnit 2.5, TestFixtureSetUp methods may be either static or
instance methods and you may define more than one of them in a fixture.
Normally, multiple TestFixtureSetUp methods are only defined at different levels
of an inheritance hierarchy, as explained below.
If a TestFixtueSetUp method fails or throws an exception, none of the tests
in the fixure are executed and a failure or error is reported.
namespace NUnit.Tests
{
using System;
using NUnit.Framework;
[TestFixture]
public class SuccessTests
{
[TestFixtureSetUp] public void Init()
{ /* ... */ }
[TestFixtureTearDown] public void Cleanup()
{ /* ... */ }
[Test] public void Add()
{ /* ... */ }
}
}
Imports System
Imports Nunit.Framework
Namespace Nunit.Tests
<TestFixture()> Public Class SuccessTests
<TestFixtureSetUp()> Public Sub Init()
' ...
End Sub
<TestFixtureTearDown()> Public Sub Cleanup()
' ...
End Sub
<Test()> Public Sub Add()
' ...
End Sub
End Class
End Namespace
#using <Nunit.Framework.dll>
using namespace System;
using namespace NUnit::Framework;
namespace NUnitTests
{
[TestFixture]
public __gc class SuccessTests
{
[TestFixtureSetUp] void Init();
[TestFixtureTearDown] void Cleanup();
[Test] void Add();
};
}
#include "cppsample.h"
namespace NUnitTests {
// ...
}
The TestFixtureSetUp attribute is inherited from any base class. Therefore, if a base
class has defined a SetFixtureSetUp method, that method will be called
after each test method in the derived class.
Before NUnit 2.5, you were permitted only one TestFixtureSetUp method. If you wanted to
have some TestFixtureSetUp functionality in the base class and add more in the derived
class you needed to call the base class method yourself.
With NUnit 2.5, you can achieve the same result by defining a TestFixtureSetUp method
in the base class and another in the derived class. NUnit will call base
class TestFixtureSetUp methods before those in the derived classes.
Note: Although it is possible to define multiple TestFixtureSetUp methods
in the same class, you should rarely do so. Unlike methods defined in
separate classes in the inheritance hierarchy, the order in which they
are executed is not guaranteed.
The Description attribute is used to apply descriptive text to a Test,
TestFixture or Assembly. The text appears in the XML output file and is
shown in the Test Properties dialog.
[assembly: Description("Assembly description here")]
namespace NUnit.Tests
{
using System;
using NUnit.Framework;
[TestFixture, Description("Fixture description here")]
public class SomeTests
{
[Test, Description("Test description here")]
public void OneTest()
{ /* ... */ }
}
}
<assembly: Description("Assembly description here")>
Imports System
Imports Nunit.Framework
Namespace Nunit.Tests
<TestFixture(), Description("Fixture description here")>_
Public Class SomeTests
<Test(), Description("Test description here")>_
Public Sub OneTest()
' ...
End Sub
End Class
End Namespace
[assembly:Description("Assembly description here")]
#using <Nunit.Framework.dll>
using namespace System;
using namespace NUnit::Framework;
namespace NUnitTests
{
[TestFixture, Description("Fixture description here")]
public __gc class SomeTests
{
[Test, Description("Test description here")]
void OneTest();
};
}
#include "cppsample.h"
namespace NUnitTests {
// ...
}
Note: The Test and TestFixture attributes continue to support an
optional Description property. The Description attribute should be used for
new applciations. If both are used, the Description attribute takes precedence.
ExpectedExceptionAttribute (NUnit 2.0 plus Updates)
This is the way to specify that the execution of a test will throw an
exception. This attribute has a number of positional and
named parameters, which we will discuss in separate sections
according to the purpose they serve.
Specifying the Expected Exception Type
The original attribute, introduced with NUnit 2.0 took a single
argument giving the exact type of the expected exception. For example...
[ExpectedException( typeof( ArgumentException ) )]
public void TestMethod()
{
...
Beginning with NUnit 2.2.4, it became possible to specify the type
of exception as a string, avoiding the need for a reference to the
defining assembly...
[ExpectedException( "System.ArgumentException" ) )]
public void TestMethod()
{
...
The above two examples function identically: the test only succeeds if a
System.Argument exception is thrown.
Specifying the Expected Message
NUnit 2.1 introduced a constructor with a second argument, specifying the
exact text of the message property of the exception. After NUnit 2.2.4, the
same extension was made to the constructor taking a string argument. With
NUnit 2.4, these arguments are marked obsolete, and a named parameter
is provided instead...
With NUnit 2.4, it is possible to specify additional tests on the
exception message, beyond a simple exact match. This is done using the
MatchType named parameter, whose argument is an enumeration, defined as
follows:
public enum MessageMatch
{
/// Expect an exact match
Exact,
/// Expect a message containing the parameter string
Contains,
/// Match the regular expression provided as a parameter
Regex,
/// Expect a message starting with the parameter string
StartsWith
}
The following example is for a test that passes only if an ArgumentException
with a message containing "unspecified" is received.
If MatchType is not specified, an exact match is used as before.
Specifying a Custom Error Message
With NUnit 2.4, it is possible to specify a custom message to be
displayed if the ExpectedException attribute is not satisfied. This
is done through the UserMessage named parameter...
If the processing required for an exception is too complex to express
in the attribute declaration, the normal practice is to process it in the
test code using a try/catch block. As an alternative, NUnit 2.4 allows
designating a method that will be called to process the exception. This
is particularly useful when multiple exceptions need to be processed
in the same way.
An common exception handler may be designated by implementing the
IExpectExceptionInterface, which is defined as follows...
public interface IExpectException
{
void HandleException( System.Exception ex );
}
The exception handler is only called for methods marked with
the ExpectedException attribute. If all checks - including
the type of the exception - are to be performed in code, the
attribute may be specified without any arguments in order to
indicate that an exception is expected.
An handler may be designated for a particular method
using the Handler named parameter.
[ExpectedException( Handler="HandlerMethod" )]
public void TestMethod()
{
...
}
public void HandlerMethod( System.Exception ex )
{
...
}
This technique may be
used without implementing IExpectException or in
combination with it. In the latter case, the designated handler
applies to any method that specifies it, while the normal
exception handler applies to any other methods that specify
an ExpectedException.
However it is specified, the handler method should examine the exception and
Assert on whatever properties are relevant. Any resulting failure message
will then be consistent in format with other assertions performed in the tests.
namespace NUnit.Tests
{
using System;
using NUnit.Framework;
[TestFixture]
public class SuccessTests
{
[Test]
[ExpectedException(typeof(InvalidOperationException))]
public void ExpectAnExceptionByType()
{ /* ... */ }
[Test]
[ExpectedException("System.InvalidOperationException")]
public void ExpectAnExceptionByName()
{ /* ... */ }
}
}
Imports System
Imports Nunit.Framework
Namespace Nunit.Tests
<TestFixture()> Public Class SuccessTests
<Test(), ExpectedException(GetType(Exception))>
Public Sub ExpectAnExceptionByType()
' ...
End Sub
<TestFixture()> Public Class SuccessTests
<Test(), ExpectedException("System.Exception")>
Public Sub ExpectAnExceptionByName()
' ...
End Sub
End Class
End Namespace
#using <Nunit.Framework.dll>
using namespace System;
using namespace NUnit::Framework;
namespace NUnitTests
{
[TestFixture]
public __gc class SuccessTests
{
[Test]
[ExpectedException(__typeof(InvalidOperationException))]
void ExpectAnExceptionByType();
[Test]
[ExpectedException(S"SystemInvalidOperationException")]
void ExpectAnExceptionByName();
};
}
#include "cppsample.h"
namespace NUnitTests {
// ...
}
The extension object passed to Install must implement either the ITestCaseBuilder
or the ITestCaseBuilder2 interface:
public interface ITestCaseBuilder
{
bool CanBuildFrom( MethodInfo method );
Test BuildFrom( MethodInfo method );
}
public interface ITestCaseBuilder2 : ITestCaseBuilder
{
bool CanBuildFrom( MethodInfo method, Test suite );
Test BuildFrom( MethodInfo method, Test suite );
}
NUnit will call ITestCaseBuilder2 if it is available. Otherwise
ITestCaseBuilder will be used.
The CanBuildFrom method should return true if the addin can build
a test from the MethodInfo provided. Some TestCaseBuilder addins are only
intended to apply to methods within a specific type of fixture. The
suite argument of the ITestCaseBuilder2 interface may be used to make
this determination.
The BuildFrom method should return a test constructed over the MethodInfo
provided as an argument or null if the method cannot be used.
The nunit.exe program is a graphical runner. It shows the tests in an
explorer-like browser window and provides a visual indication of the success or
failure of the tests. It allows you to selectively run single tests or suites
and reloads automatically as you modify and re-compile your code. The following
is a screenshot of NUnit running the same mock-assembly.dll shown in the
nunit-console example.
Tree Display
This version of NUnit uses symbols in the test tree, which allow those who
are unable to easily distinguish colors to determine the test status.
Successful tests are colored green, with a check mark. Tests that are ignored
are marked with a yellow circle, containing a question mark. If any
tests had failed, they would be marked red, with an X symbol.
In this example, there were a total of 11 test cases, but one of them was not
counted because it was marked Explicit. Note that it is shown as a gray
circle in the tree. Of the remaining 10 tests, 5 were run successfully and
5 were ignored.
The symbols shown in the tree are actually files in the NUnit bin directory.
These files are named Success.jpg, Failure.jpg and Ignored.jpg and may be
modified or replaced by the user.
Note: Beginning with NUnit 2.6, tests marked with the IgnoreAttribtute are shown in yellow immediately upon loading. Similarly,
non-runnable tests (e.g.: wrong argument type) are shown in red at load time.
Progress Bar
The progress bar shows the progress of the test. It is colored according
to the "worst" result obtained: red if there were any failures, yellow if
some tests were ignored and green for success.
Result Summary
At the end of the test run, a summary of the results is displayed immediately
below the progress bar. If the result information does not fit in the space
available, hovering over it shows the full information.
Result Tabs
The tabs along the bottom of the display show the results of running
a test. The Errors and Failures tab displays the error message
and stack trace for both unexpected exceptions and assertion failures.
Beginning with NUnit 2.5, source code for each stack location can be displayed
in this tab - as is seen above - provided that the program was compiled with
debug information.
The Tests Not Run tab provides a list of all tests that were
selected for running but were not run, together with the reason.
The Text Output tab displays text output from the tests, potentially
including console output, trace output and log output. The default display
provides a single tab, but additional tabs may be created by the user to
hold specific kinds of output. For more information on creating new tabs,
see the documentation for the
Settings Dialog.
Mini-Gui
Since the release of NUnit 2.4, an alternate "mini-gui" is also available. It
may be selected from the View menu. In the following screenshot, the mini
gui window has been positioned next to the Visual Studio IDE so
that both windows can be seen.
ThrowsConstraint is used to test that some code, represented as a delegate,
throws a particular exception. It may be used alone, to merely test the type
of constraint, or with an additional constraint to be applied to the exception
specified as an argument.
p>The related ThrowsNothingConstraint simply asserts that the delegate
does not throw an exception.
// .NET 1.1
Assert.That( new TestDelegate(SomeMethod),
Throws.TypeOf(typeof(ArgumentException)));
Assert.That( new TestDelegate(SomeMethod),
Throws.Exception.TypeOf(typeof(ArgumentException)));
Assert.That( new TestDelegate(SomeMethod),
Throws.TypeOf(typeof(ArgumentException))
.With.Property("Parameter").EqualTo("myParam"));
Assert.That( new TestDelegate(SomeMethod),
Throws.ArgumentException );
Assert.That( new TestDelegate(SomeMethod),
Throws.TargetInvocationException
.With.InnerException.TypeOf(ArgumentException));
// .NET 2.0
Assert.That( SomeMethod,
Throws.TypeOf<ArgumentException>());
Assert.That( SomeMethod,
Throws.Exception.TypeOf<ArgumentException>());
Assert.That( SomeMethod,
Throws.TypeOf<ArgumentException>()
.With.Property("Parameter").EqualTo("myParam"));
Assert.That( SomeMethod, Throws.ArgumentException );
Assert.That( SomeMethod,
Throws.TargetInvocationException
.With.InnerException.TypeOf<ArgumentException>());
Notes
Throws.Exception may be followed by further constraints,
which are applied to the exception itself as shown in the last two
examples above. It may also be used alone to verify that some
exception has been thrown, without regard to type. This is
not a recommended practice since you should normally know
what exception you are expecting.
Throws.TypeOf and Throws.InstanceOf are provided
as a shorter syntax for this common test. They work exactly like
the corresponding forms following Throws.Exception.
Throws.TargetInvocationException/b>, Throws.ArgumentException
and Throws.InvalidOperationException provide a shortened form
for some common exceptions.
Used alone, Throws.InnerException simply tests the InnerException
value of the thrown exception. More commonly, it will be used in
combination with a test for the type of the outer exception as shown
in the examples above.
The CombinatorialAttribute is used on a test to specify that NUnit should
generate test cases for all possible combinations of the individual
data items provided for the parameters of a test. Since this is the
default, use of this attribute is optional.
Example
The following test will be executed six times, as follows:
The Platform attribute is used to specify platforms for which a test or fixture
should be run. Platforms are specified using case-insensitive string values
and may be either included or excluded from the run by use of the Include or
Exclude properties respectively. Platforms to be included may alternatively
be specified as an argument to the PlatformAttribute constructor. In either
case, multiple comma-separated values may be specified.
If a test or fixture with the Platform attribute does not satisfy the specified
platform requirements it is skipped. The test does not affect the outcome of
the run at all: it is not considered as ignored and is not even counted in
the total number of tests. In the gui, the tree node for the test remains
gray and the status bar color is not affected.
Note: In versions of NUnit prior to 2.4, these tests were
shown as ignored.
namespace NUnit.Tests
{
using System;
using NUnit.Framework;
[TestFixture]
[Platform("NET-2.0")]
public class DotNetTwoTests
{
// ...
}
}
Imports System
Imports Nunit.Framework
Namespace Nunit.Tests
<TestFixture(), Platform("NET-2.0")>
Public Class DotNetTwoTests
' ...
End Class
End Namespace
#using <Nunit.Framework.dll>
using namespace System;
using namespace NUnit::Framework;
namespace NUnitTests
{
[TestFixture]
[Platform("NET-2.0")]
public __gc class DotNetTwoTests
{
// ...
};
}
#include "cppsample.h"
namespace NUnitTests {
// ...
}
namespace NUnit.Tests
{
using System;
using NUnit.Framework;
[TestFixture]
public class SuccessTests
{
[Test]
[Platform(Exclude="Win98,WinME")]
public void SomeTest()
{ /* ... */ }
}
Imports System
Imports Nunit.Framework
Namespace Nunit.Tests
<TestFixture()>
Public Class SuccessTests
<Test(), Platform(Exclude="Win98,WinME")> Public Sub SomeTest()
' ...
End Sub
End Class
End Namespace
#using <Nunit.Framework.dll>
using namespace System;
using namespace NUnit::Framework;
namespace NUnitTests
{
[TestFixture]
public __gc class SuccessTests
{
[Test][Platform(Exclude="Win98,WinME")] void SomeTest();
};
}
#include "cppsample.h"
namespace NUnitTests {
// ...
}
If you haven't already done so, go to our Download page, select a version of NUnit and download it. The
Installation page
contains instructions for installing on your system.
To get started using NUnit, read the Quick Start page. This article demonstrates the development process with NUnit in the
context of a C# banking application. Check the
Samples page for additional examples,
including some in VB.Net, J# and managed C++.
Which Test Runner to use?
NUnit has two different ways to run your tests. The
console runner, nunit-console.exe,
is the fastest to launch, but is not interactive.
The gui runner,
nunit.exe, is a Windows Forms application that allows you to work
selectively with your tests and provides graphical feedback.
The RequiresSTAAttribute is used on a test method, class or assembly
to specify that the tests should be run in the Single-threaded apartment.
It causes creation of a new thread if the parent test is not already running
in the STA.
Note: On test methods, you may also use the STAThreadAttribute.
Although the runtime only recognizes this attribute on the entrypoint of
an executable assembly, many users have expected it to work on tests, so
we treat it as a synonym.
Examples
// An STA thread will be created and used to run
// all the tests in the assembly
[assembly:RequiresSTA]
...
// TestFixture requiring a separate thread
[TestFixture, RequiresSTA]
public class FixtureRequiringSTA
{
// An STA thread will be created and all
// tests in the fixture will run on it
// unless the containing assembly is
// already running on an STA Thread
}
[TestFixture]
public class AnotherFixture
{
[Test, RequiresSTA]
public void TestRequiringSTA()
{
// A separate thread will be created for this test
// unless the containing fixture is already running
// in the STA.
}
}
The Assert.Pass method allows you to immediately end the test, recording
it as successful. Since it causes an exception to be thrown, it is more
efficient to simply allow the test to return. However, Assert.Pass allows
you to record a message in the test result and may also make the test
easier to read in some situations. Additionally, like the other methods
on this page, it can be invoked from a nested method call with the
result of immediately terminating test execution.
The Assert.Fail method provides you with the ability to generate a failure based
on tests that are not encapsulated by the other methods. It is also useful in
developing your own project-specific assertions.
Here's an example of its use to create a private assertion that tests whether a
string contains an expected value.
public void AssertStringContains( string expected, string actual )
{
AssertStringContains( expected, actual, string.Empty );
}
public void AssertStringContains( string expected, string actual,
string message )
{
if ( actual.IndexOf( expected ) < 0 )
Assert.Fail( message );
}
The Assert.Ignore method provides you with the ability to dynamically cause a
test or suite to be ignored at runtime. It may be called in a test, setup or
fixture setup method. We recommend that you use this only in isolated cases.
The category facility is provided for more extensive inclusion or exclusion of
tests or you may elect to simply divide tests run on different occasions into
different assemblies.
The Assert.Inconclusive method indicates that the test could not be
completed with the data available. It should be used in situations where
another run with different data might run to completion, with either a
success or failure outcome.
This attribute is used inside a TestFixture to provide a single set of
functions that are performed once after all tests are completed.
Before NUnit 2.5, a TestFixture could have only one SetUp method
and it was required to be an instance method.
Beginning with NUnit 2.5, TestFixtureTearDown methods may be either static or
instance methods and you may define more than one of them in a fixture.
Normally, multiple TestFixtureTearDown methods are only defined at different levels
of an inheritance hierarchy, as explained below.
So long as any TestFixtureSetUp method runs without error, the TestFixtureTearDown method is
guaranteed to run. It will not run if a TestFixtureSetUp method fails or throws an
exception.
namespace NUnit.Tests
{
using System;
using NUnit.Framework;
[TestFixture]
public class SuccessTests
{
[TestFixtureSetUp] public void Init()
{ /* ... */ }
[TestFixtureTearDown] public void Cleanup()
{ /* ... */ }
[Test] public void Add()
{ /* ... */ }
}
}
Imports System
Imports Nunit.Framework
Namespace Nunit.Tests
<TestFixture()> Public Class SuccessTests
<TestFixtureSetUp()> Public Sub Init()
' ...
End Sub
<TestFixtureTearDown()> Public Sub Cleanup()
' ...
End Sub
<Test()> Public Sub Add()
' ...
End Sub
End Class
End Namespace
#using <Nunit.Framework.dll>
using namespace System;
using namespace NUnit::Framework;
namespace NUnitTests
{
[TestFixture]
public __gc class SuccessTests
{
[TestFixtureSetUp] void Init();
[TestFixtureTearDown] void Cleanup();
[Test] void Add();
};
}
#include "cppsample.h"
namespace NUnitTests {
// ...
}
The TestFixtureTearDown attribute is inherited from any base class. Therefore, if a base
class has defined a TestFixtureTearDown method, that method will be called
after each test method in the derived class.
Before NUnit 2.5, you were permitted only one TestFixtureTearDown method. If you wanted to
have some TestFixtureTearDown functionality in the base class and add more in the derived
class you needed to call the base class method yourself.
With NUnit 2.5, you can achieve the same result by defining a TestFixtureTearDown method
in the base class and another in the derived class. NUnit will call base
class TestFixtureTearDown methods after those in the derived classes.
Note: Although it is possible to define multiple TestFixtureTearDown methods
in the same class, you should rarely do so. Unlike methods defined in
separate classes in the inheritance hierarchy, the order in which they
are executed is not guaranteed.
Normally constraints just work. However, attempting to reuse the
same constraint in several places can lead to unexpected results.
Consider the following code as an example:
Constraint myConstraint = Is.Not.Null;
Assert.That("not a null", myConstraint); // Passes, of course
Assert.That("not a null", myConstraint); // Fails! What's that about?
We'll save the technical explanation for later and show the
solution first:
ReusableConstraint myConstraint = Is.Not.Null;
Assert.That("not a null", myConstraint); // Passes
Assert.That("not a null", myConstraint); // Passes
Or alternatively..
var myConstraint = new ReusableConstraint(Is.Not.Null);
Assert.That("not a null", myConstraint); // Passes
Assert.That("not a null", myConstraint); // Passes
Technical Explanation
In the original example, the value assigned to myConstraint is
known as an unresolved constraint. In fact, it's an
unresolved NullConstraint, because that was the last constraint
encountered in the expression. It's associated with a Not
operator that has not yet been applied.
That's OK for use with Assert.That(), because the method
knows how to resolve a constraint before using it. Assert.That()
resolves this constraint to a NotConstraint referencing the
original NullConstraint.
Of course, the original reference in myConstraint is left
unchanged in all of this. But the EqualConstraint it points
to has now been resolved. It is now a resolved constraint
and can't be resolved again by the second Assert.That(), which
only sees the NullConstraint and not the NotConstraint.
So, for reusability, what we want to save is the result
of resolving the constraint, in this case
NotConstraint => NullConstraint
That's what ReusableConstraint does for us. It resolves
the full expression and saves the result. Then it passes all
operations on to that saved result.
When to Use It
Use this constraint any time you want to reuse a constraint
expression and you'll be safe.
If you like to take chances, you'll find that you can
avoid using it in the following cases...
With a simple constraint involving no operators, like...
With any constraint you construct using new, without
using the "dotted" constraint syntax...
Constraint myConstraint = new NotConstraint(new NullConstraint());
Constraint myConstraint = new AndConstraint(
new GreaterThanConstraint(0),
new LessThanConstraint(100));
However, there is no significant penalty to using ReusableConstraint.
It makes your intent much clearer and the exceptions listed are accidents of
the internal implementation and could disappear in future releases.
The RequiresThreadAttribute is used to indicate that a test method,
class or assembly should be run on a separate thread. Optionally, the
desired apartment for the thread may be specified in the constructor.
Note: This attribute, used with or without an ApartmentState
argument will always result in creation of a new thread. To
create a thread only if the current ApartmentState is not appropriate,
use RequiresSTAAttribute or RequiresMTAAttribute.
Examples
// A thread will be created and used to run
// all the tests in the assembly
[assembly:RequiresThread]
...
// TestFixture requiring a separate thread
[TestFixture, RequiresThread]
public class FixtureOnThread
{
// A separate thread will be created and all
// tests in the fixture will run on it.
}
[TestFixture]
public class AnotherFixture
{
[Test, RequiresThread]
public void TestRequiringThread()
{
// A separate thread will be created for this test
}
[Test, RequiresThread(ApartmentState.STA)]
public void TestRequiringSTAThread()
{
// A separate STA thread will be created for tnis test.
}
}
RepeatAttribute is used on a test method to specify that it should be
executed multiple times. If any repetition fails, the remaining ones are
not run and a failure is reported.
Notes:
It is not currently possible to use RepeatAttribute on a TestFixture
or any other type of test suite. Only single tests may be repeated.
Since a parameterized test method represents a suite, RepeatAttribute
is ignored when it appears on such a method.
The Datapoint and Datapoints attributes are used
to provide data for Theories and are ignored for ordinary
tests - including tests with parameters.
DataPointAttribute
When a Theory is loaded, NUnit creates arguments for each
of its parameters by using any fields of the same type
as the parameter annotated with the DatapointAttribute.
Fields must be members of the class containing the Theory
and their Type must exactly match the argument for which
data is being supplied.
DataPointsAttribute
In addition to specifying individual datapoints, collections of
datapoints may be provided by use of the DatapointsAttribute
- note the spelling. This attribute may be placed on methods or
properties in addition to fields. The returned value must be
either an array of the required type or (beginning with NUnit
2.5.5) an IEnumerable<T> returning an enumeration
of the required type. The data Type must exactly match the argument
for which data is being supplied.
Automatically Supplied Datapoints
It is normally not necessary to specify datapoints for
boolean or enum arguments. Beginning with
version 2.5.4, NUnit automatically supplies values of true
and false for boolean arguments and will supply all
defined values of any enumeration.
If for some reason you don't wish to use all possible values, you
can override this behavior by supplying your own datapoints. If you
supply any datapoints for an argument, automatic datapoint generation
is suppressed.
Collection constraints perform tests that are specific to collections.
The following collection constraints are provided. Before NUnit 2.4.6,
these constraints only operated on true Collections. Beginning with 2.4.6,
they can work with any object that implements IEnumerable.
Beginning with NUnit 2.4.2, use of an improper argument type caused tests
to fail. Later releases give an error rather than a failure, so that negated
constraints will not appear to succeed.
For example, both of the following statements give an error in later releases,
but the second would have succeeded in earlier versions of NUnit.
int[] iarray = new int[] { 1, 2, 3 };
Assert.That( 5, Is.SubsetOf( iarray ) ); // Fails in early releases
Assert.That( 5, Is.Not.SubsetOf( iarray ) ); /
AllItemsConstraint
Action
Applies a constraint to each item in a collection, succeeding only if all of them succeed.
For references, Has.Member uses object equality to find a member in a
collection. To check for an object equal to an item the collection, use
Has.Some.EqualTo(...).
CollectionEquivalentConstraint
Action
Tests that two collections are equivalent - that they contain
the same items, in any order.
Constructor
CollectionEquivalentConstraint( IEnumerable other )
The extension object passed to Install must implement either the
IDataPointProvider or the IDataPointProvider2 interface:
public interface IDataPointProvider
{
bool HasDataFor( ParameterInfo parameter );
IEnumerable GetDataFor( ParameterInfo parameter );
}
public interface IDataPointProvider2 : IDatapointProvider
{
bool HasDataFor( ParameterInfo parameter, Test parentSuite );
IEnumerable GetDataFor( ParameterInfo parameter, Test parentSuite );
}
NUnit will call IDataPointProvider2 if it is available. Otherwise
IDataPointProvider will be used.
The HasDataFor method should return true if the provider is able to
supply data for the specified parameter. If a provider only wants to be used
on certain types of tests, it can examine the supplied ParameterInfo and
its associated MethodInfo and Type and/or the parent test suite.
The GetDataFor method should return a list of individual values to
use for the supplied parameter in running the test.
Notes:
Most providers will delegate one of the interface implementations
to the other if they implement both.
DataPointProviders that use data from the fixture class should use
IDataPointProvider2 interface so that they are able to access any
arguments supplied for constructing the fixture object.
Providers that acquire data from outside the fixture will usually
be able to work with IDataPointProvider alone.
The IDataPointProvider2 interface was added in the NUnit 2.5.1 release.
NUnit 2.6 Final Release - Version 2.6.0.12051 - February 20, 2012
Bug Fixes
881715 Frequent socketexception in nUnit GUI
881958 nunit-console-x86 crashes with socketexception
928018 Issue with test time print out
930774 Adding or Removing a category in the Gui causes an exception
933800 NUnit will crash when started and dll from previous project doesn't compile
NUnit 2.6 Release Candidate - Version 2.6.0.12035 - February 4, 2012
General
The Windows installer is now built using WiX 3.5, upgraded from 2.0.
Framework
The API used to create Action Attributes has been changed from the
earlier beta releases. See the docs for more info.
Visual Basic users may now use Assert.ByVal rather than Assert.That()
to avoid errors when the first argument is a property with a non-public setter.
PlatformAttribute now supports arguments 'Windows8' and 'Windows2012Server'.
Bug Fixes
498659 Registry entries and shortcuts remain after install
498690 Assert.That() doesn't like properties with scoped setters
638289 Install uses CURRENT_USER instead of LOCAL_MACHINE for AssemblyFoldersEx
910189 Eliminate NUnit Configuration Section in config file
919876 NUnit.Util.Transform.resources missing from nunit.util.dll
920472 CollectionAssert.IsNotEmpty must dispose Enumerator
922455 Add Support for Windows 8 and Windows 2012 Server to PlatformAttribute
924504 NUnit project files should have an Edit command association with the project editor
NUnit 2.6 Beta 4 - Version 2.6.0.12017 - January 17, 2012
General
NUnit no longer stores settings in the test configuration file, as it
did in earlier versions. Specifically, we no longer recognize or support
OldStyleTestCases, ApartmentState, ThreadPriority or DefaultLogThreshold
in the configuration file. Further details on each of these features are
included in the appropriate sections below.
The TestRunner interface has been modified. Applications using this
interface will need to be modified but general users are not effected.
The build now uses the NAnt 0.91 final release.
Framework
User-defined equality comparers specified with the Using syntax
element may now be used with arrays and dictionaries. Essentially, this
means that there are no longer any restrictions on the Types for which a
user-defined equality comparer may be specified.
So-called "old-style" tests, identified by having a name beginning with
"Test" are no longer supported in NUnit 2.6.
Setting a ThreadPriority for the test runner thread is no longer supported
under NUnit 2.6.
Console
The following new command-line options are provided:
-stoponerror causes execution of the test run to terminate
immediately on the first test failure or error.
-apartment is used to specify the ApartmentState (STA or MTA)
of the test runner thread. Since the default is MTA, the option is
only needed to force execution in the Single Threaded Apartment.
Gui
A number of new settings are available using the Settings Dialog:
The Tree Display page allows the user to select alternate image sets for
use in the test tree. Additional user-provided image sets may be added if desired.
The Text Output page allows setting the threshold for capture and display
of log4net output (previously controlled by the test config file).
By default, test Cases under a Theory that fail an assumption are no longer shown in the tree.
A context menu item has been added to allow the user to view them.
The properties dialog has been redesigned to be more compact and readable.
The context menu for the test tree has been simplified.
Bug Fixes
605034 Log4net not working with NUnit
708173 NUnit's logic for comparing arrays - use Comparer<T[]> if it is provided
719184 Platformdependency in src/ClientUtilities/util/Services/DomainManager.cs:40
761579 Tests using log4net run very slowly
848713 Feature request: Add switch for console to break on any test case error
882192 Ignored test icon should be more prominent
885173 Tests are still executed after cancellation by user
896615 Tests can't be run in existing AppDomain
897289 Is.Empty constraint has unclear failure message
899178 Wrong failure message for parameterized tests that expect exceptions
902305 Gui should not normally display Inconclusive test cases for a Theory
902343 Gui 'Hide Tests' function no longer works
903078 DomainUsage.None setting crashes nunit-gui
903080 Test tree context menu needs to be simplified
904841 After exiting for timeout the teardown method is not executed
907270 Gui enables run when the assembly specified on the command line is not found
908829 TestCase attribute does not play well with variadic test functions
910218 NUnit should add a trailing separator to the ApplicationBase
912955 Project files missing in source code package
NUnit 2.6 Beta 3 - Version 2.6.0.11340 - December 6, 2011
Framework
The Constraint syntax now supports Is.Positive, which is interpreted
as greater than zero, and Is.Negative, which is interpreted as less than zero.
Bug Fixes
892844 Not using Mono 4.0 profile under Windows
892845 "Mono" is not clearly shown in About box or Test Assemblies dialog
892847 Gui offers to load assemblies under a lower CLR version
893919 DelayedConstraint fails polling properties on references which are initially null
893991 When working directory contains # sign, it is truncated
898192 Feature Request: Is.Negative, Is.Positive
898256 IEnumerable for Datapoints doesn't work
898850 NUnit 2.6 beta 2 crashes on assemblies without tests
NUnit 2.6 Beta 2 - Version 2.6.0.11324 - November 20, 2011
General
NUnit's executables now use config files that allow smoother running
of mixed assemblies built for .NET 2.0 under .NET 4.0.
When opening Visual Studio formatted solutions, NUnit now uses the
solution configuration by default, resulting in changed behavior from
previous releases. The Settings Dialog may be used to revert NUnit to
the earlier behavior, which ignored solution configurations.
Changing the URL to be used for NUnit help through the config file
is no longer supported.
Framework
TestCaseAttribute now accepts Explicit and Reason
named parameters.
TestCaseSourceAttribute now accepts a Category named parameter.
TestCaseData now supports marking individual test cases as Explicit.
EqualConstraint now recognizes and uses IEquatable<T> if
it is implemented on either the actual or the expected value. The interface
is used in preference to any override of Object.Equals(), so long as
the other argument is of Type T. Note that this applies to all equality tests
performed by NUnit.
When Assert.Throws() fails due to an exception of the wrong Type being
thrown, the error message now includes the Message and Stack Trace from the
exception.
The constraint syntax now supports Has.Exactly(n)... in place of
Has.Some... in order to allow tests over collections that must
be satisfied a specific number of times.
The Using(...) syntactic element may now be repeated multiple
times in an expression, so long as each comparer applies to a different
Type. NUnit will use the appropriate comparer, depending on the Type
of the arguments. Among other things, this allows overriding the default
NUnit comparison of collections.
Documentation is provided for the previously undocumented TestContext.
A new property TestContext.WorkDirectory allows tests to access the
name of a directory to be used for file output. This directory may be
specified by use of the /work option of nunit-console.
Gui
The test reload functionality in the Gui has been rewritten and simplified so that
the same logic is used for all cases where the visual state of the tree is to be
recovered. Test results are now found even if changes to the assembly have resulted
in the assignment of new ids to the tests.
The Gui now displays invalid tests in red immediately upon load, without waiting
for the user to run them. Tests marked with the IgnoreAttribute are displayed
in yellow immediately as well.
The directory containing the log files may be opened directly from the Gui by
use of a new item on the Tools menu.
Test summary results are truncated when the window size is too small. The full
summary is displayed when hovering over the field.
A number of new settings are available using the Settings Dialog:
The Project Editor page allows the user to select whether the NUnit
Project Editor or another external program will be used when editing
the settings file.
The Runtime Selection page allows enabling or disabling automatic
detection of the target runtime for each test assembly.
The Advanced Loader Settings page now allows specifying the argument to use
in calling SetPrincipalPolicy for each test AppDomain.
The Visual Studio page now includes a setting that enables or disables
the use of solution configs when loading Visual Studio solution files.
The Internal Trace page now shows the directory path to which log files
will be saved.
The location of the settings dialog under the Windows AppData directory has been
changed from Roaming to Local. Users will need to reset their preferences in some cases.
Bug Fixes
602761 nunit-agent hangs after tests complete
625672 NUnit GUI bounces to background on reload
657801 Help URL should not be in config file
676560 Assert.AreEqual does not support IEquatable<T>
697069 Feature request: dynamic location for TestResult.xml
697329 NUnit tries to test disabled projects
709062 "System.ArgumentException : Cannot compare" when the element is a list
712156 Tests cannot use AppDomain.SetPrincipalPolicy
766749 net-2.0\nunit-console-x86.exe.config should have a startup element and also enable loadFromRemoteSources
770471 Assert.IsEmpty does not support IEnumerable
785460 Add Category parameter to TestCaseSourceAttribute
794115 HashSet incorrectly reported
800089 Assert.Throws() hides details of inner AssertionException
836080 Log Directory shown incorrectly in settings dialog
836360 When size of the Gui window is reduced, test result info may not fit in the field provided
841894 UI won't run tests marked Explicit from the context menu
878376 Add 'Exactly(n)' to the NUnit constraint syntax
878899 Changing logging level has no effect until NUnit is restarted
878955 ParameterizedTest not in their parent test-suite when FixtureSetup fails in .xml result file
881617 Tests with invalid category attributes should be more visible
882137 When no tests are run, higher level suites display as Inconclusive
882517 NUnit 2.5.10 doesn't recognize TestFixture if there are only TestCaseSource inside
883271 Reload Tests sometimes "loses" tests
885277 Exception when project calls for a runtime using only 2 digits
885604 Feature request: Explicit named parameter to TestCaseAttribute
887005 NUnit.exe ignores categories when using /run option
890129 DelayedConstraint doesn't appear to poll properties of objects
890384 When font is enlarged, layout of settings pages is incorrect
891237 When font is enlarged, gui Test Result disappears and suite name is truncated
891265 Add /cleanup to nunit-console.exe
891326 Non-runnable and statically ignored tests should disable the Run item on the context menu
NUnit 2.6 Beta 1 - Version 2.6.0.11240 - August 28, 2011
General
NUnit is now built using .NET 3.5. All NUnit assemblies and most tests
target .NET 2.0 but the full set of tests requires 3.5 to execute.
The build script now supports building from source under .NET 4.0.
The script selects either .NET 3.5 or .NET 4.0 to perform the build,
depending on what is available.
NAnt 0.91 alpha2 release is now used for building on Windows. The 0.90
release is still used on Linux.
Support for .NET 1.0 / 1.1 is no longer included in the main distribution
for NUnit but is provided as a separate package.
NUnit Mocks is now deprecated. All classes are now marked as obsolete.
NUnit now uses the NSubstitute mock framework its own tests. A copy of the
NSubstitute dll is included in the distribution.
Framework
NUnit now supports composable Action Attributes, which allow the
test developer to put reusable test actions into attributes and attach
these actions to suites, tests, and test cases. The actions can run
arbitrary code before and after suites, tests, and test cases execute.
It enables the test developer to build smaller reusable actions and to
compose them in unique ways for each suite, test, or test case.
Note: This feature is experimental and details are likely
to change in the final release.
PlatformAttribute accepts "Net-3.0", "Net-3.5", "Mono-3.0" and "Mono-3.5" as arguments. Since these frameworks all
use the 2.0 runtime, the semantics of their use is slightly different
from other key words. The "3.5" arguments also include "3.0" and "2.0"
and the "3.0" arguments include "2.0" in their interpretation.
TestFixtureAttribute now accepts a Category named parameter,
allowing individual fixture instances to be included in or excluded from
a test run.
Console
The .NET 1.1 build of nunit-console no longer supports the -process
or -framework option. There is no automatic runtime detection and
tests execute under same runtime as the console runner itself. If this
functionality is needed when running tests under .NET 1.1, use the standard
console runner to execute the tests in a separate process.
The following new command-line options are provided:
-result is a synonym for -xml, specifying the file to be used for output of the test results in XML form. The -xml option is still recognized but will be removed in a future release.
-noresult allows supressing the xml result output entirely.
-work is used to specify the directory to be used for output files. Any relative paths specified with the -output, -err or -result options are resolved using this directory as a base.
-runlist allows the user to specify a file that contains the names of the tests to be executed rather than listing them directly on the command line.
Gui
The Project Editor is now a separate program, which may be executed directly
or run through the Project | Edit dropdown menu of the NUnit GUI. The editor
now provides two main views of the project: a property-oriented view based
on the Project Editor that was built into earlier versions of the NUnit GUI
and an xml view, which allows simple editing of the .nunit file.
PNUnit
The PNUnit code has been updated using the latest build from the developers
at Codice Software and additional examples are provided in the source.
Bug Fixes
691129 Add Category parameter to TestFixture
692180 Script should allow building for net-2.0 under 3.5 or 4.0
701331 TestFixture attributes on base classes are not ignored
702734 Separate packaging of NUnit for .NET 1.1 and 2.0
711330 Test-free assembly given failure icon in tree display
The TimeoutAttribute is used to specify a timeout value in milliseconds
for a test case. If the test case runs longer than the time specified it
is immediately cancelled and reported as a failure, with a message
indicating that the timeout was exceeded.
The attribute may also be specified on a fixture or assembly, in which
case it indicates the default timeout for any subordinate test cases.
Example
[Test, Timeout(2000)]
public void PotentiallyLongRunningTest()
{
...
}
Notes
Beginning with NUnit 2.5.5, timeouts are suppressed when running under a debugger.
The Category attribute provides an alternative to suites for dealing with groups
of tests. Either individual test cases or fixtures may be identified as
belonging to a particular category. Both the gui and console test runners allow
specifying a list of categories to be included in or excluded from the run.
When categories are used, only the tests in the selected categories will be
run. Those tests in categories that are not selected are not reported at all.
This feature is accessible by use of the /include and /exclude arguments to the
console runner and through a separate "Categories" tab in the gui. The gui
provides a visual indication of which categories are selected at any time.
namespace NUnit.Tests
{
using System;
using NUnit.Framework;
[TestFixture]
[Category("LongRunning")]
public class LongRunningTests
{
// ...
}
}
Imports System
Imports Nunit.Framework
Namespace Nunit.Tests
<TestFixture(), Category("LongRunning")>
Public Class LongRunningTests
' ...
End Class
End Namespace
#using <Nunit.Framework.dll>
using namespace System;
using namespace NUnit::Framework;
namespace NUnitTests
{
[TestFixture]
[Category("LongRunning")]
public __gc class LongRunningTests
{
// ...
};
}
#include "cppsample.h"
namespace NUnitTests {
// ...
}
namespace NUnit.Tests
{
using System;
using NUnit.Framework;
[TestFixture]
public class SuccessTests
{
[Test]
[Category("Long")]
public void VeryLongTest()
{ /* ... */ }
}
Imports System
Imports Nunit.Framework
Namespace Nunit.Tests
<TestFixture()>
Public Class SuccessTests
<Test(), Category("Long")> Public Sub VeryLongTest()
' ...
End Sub
End Class
End Namespace
#using <Nunit.Framework.dll>
using namespace System;
using namespace NUnit::Framework;
namespace NUnitTests
{
[TestFixture]
public __gc class SuccessTests
{
[Test][Category("Long")] void VeryLongTest();
};
}
#include "cppsample.h"
namespace NUnitTests {
// ...
}
Beginning with NUnit 2.4, it is possible to define custom
attributes that derive from CategoryAttribute and have them
recognized by NUnit. The default protected constructor of CategoryAttribute
sets the category name to the name of your class.
Here's an example that creates a category of Critical tests. It works
just like any other category, but has a simpler syntax. A test reporting
system might make use of the attribute to provide special reports.
[AttributeUsage(AttributeTargets.Method, AllowMultiple=false)]
public class CriticalAttribute : CategoryAttribute { }
...
[Test, Critical]
public void MyTest()
{ /*...*/ }
The following methods test whether one object is greater than than another.
Contrary to the normal order of Asserts, these methods are designed to be
read in the "natural" English-language or mathematical order. Thus
Assert.Greater( x, y ) asserts that x is greater than y ( x > y ).
The following methods test whether one object is greater than or equal to another.
Contrary to the normal order of Asserts, these methods are designed to be
read in the "natural" English-language or mathematical order. Thus
Assert.GreaterOrEqual( x, y ) asserts that x is greater than or equal to y ( x >= y ).
The following methods test whether one object is less than than another.
Contrary to the normal order of Asserts, these methods are designed to be
read in the "natural" English-language or mathematical order. Thus
Assert.Less( x, y ) asserts that x is less than y ( x < y ).
The following methods test whether one object is less than or equal to another.
Contrary to the normal order of Asserts, these methods are designed to be
read in the "natural" English-language or mathematical order. Thus
Assert.LessOrEqual( x, y ) asserts that x is less than or equal to y ( x <= y ).
The SetCulture attribute is used to set the current Culture for the duration
of a test. It may be specified at the level of a test or a fixture. The culture
remains set until the test or fixture completes and is then reset to its original
value. If you wish to use the current culture setting to decide whether to run
a test, use the Culture attribute instead of this one.
Only one culture may be specified. Running a test under
multiple cultures is a planned future enhancement. At this time, you can
achieve the same result by factoring out your test code into a private method
that is called by each individual test method.
namespace NUnit.Tests
{
using System;
using NUnit.Framework;
[TestFixture]
[SetCulture("fr-FR")]
public class FrenchCultureTests
{
// ...
}
}
Imports System
Imports Nunit.Framework
Namespace Nunit.Tests
<TestFixture(), SetCulture("fr-FR")>
Public Class FrenchCultureTests
' ...
End Class
End Namespace
#using <Nunit.Framework.dll>
using namespace System;
using namespace NUnit::Framework;
namespace NUnitTests
{
[TestFixture]
[SetCulture("fr-FR")]
public __gc class FrenchCultureTests
{
// ...
};
}
#include "cppsample.h"
namespace NUnitTests {
// ...
}
