FsUnit


FsUnit for xUnit

The FsUnit library for xUnit can be installed from NuGet:
PM> Install-Package FsUnit.xUnit
Sample FsUnit tests for xUnit can be installed from NuGet:
PM> Install-Package FsUnit.xUnit.Sample

Euler - Problem 1

module ``Project Euler - Problem 1`` =
    open Xunit
    open FsUnit.Xunit

    let GetSumOfMultiplesOf3And5 max =
        seq{3..max-1} |> Seq.fold(fun acc number ->
                            (if (number % 3 = 0 || number % 5 = 0) then
                                acc + number else acc)) 0

    [<Fact>]
    let ``When getting sum of multiples of 3 and 5 to a max number of 10 it should return a sum of 23`` () =
        GetSumOfMultiplesOf3And5(10) |> should equal 23

LightBulb

module ``LightBulb Tests`` =
    open Xunit
    open FsUnit.Xunit

    type LightBulb(state) =
        member x.On = state
        override x.ToString() =
            match x.On with
            | true  -> "On"
            | false -> "Off"

    type ``Given a LightBulb that has had its state set to true`` ()=
        let lightBulb = new LightBulb(true)

        [<Fact>] member x.
         ``when I ask whether it is On it answers true.`` ()=
                lightBulb.On |> should be True

        [<Fact>] member x.
         ``when I convert it to a string it becomes "On".`` ()=
                string lightBulb |> should equal "On"

    type ``Given a LightBulb that has had its state set to false`` ()=
        let lightBulb = new LightBulb(false)

        [<Fact>] member x.
         ``when I ask whether it is On it answers false.`` ()=
                lightBulb.On |> should be False

        [<Fact>] member x.
         ``when I convert it to a string it becomes "Off".`` ()=
                string lightBulb |> should equal "Off"

BowlingGame

Thanks to Keith Nicholas and Julian from hubFS for this example!

module ``BowlingGame A game of bowling`` =
    open Xunit
    open FsUnit.Xunit

    let (|EndOfGame|IncompleteStrike|Strike|Normal|Other|) (l, frame) =
        match l with
        | _ when frame = 11            -> EndOfGame(0)
        | [10;s]                       -> IncompleteStrike(10+s+s)
        | 10::s::n::tail               -> Strike(10+s+n, s::n::tail)
        |  f::s::n::tail when f+s = 10 -> Normal(f+s+n,  n::tail)
        |  f::s::n::tail               -> Normal(f+s,    n::tail)
        | ls                           -> Other(List.fold (+) 0 ls)

    let scoreBowls bowls =
        let rec scoreBowls' frame l current_score =
            let nextframe = scoreBowls' (frame+1)
            match (l, frame) with
            | EndOfGame(score)        -> current_score + score
            | IncompleteStrike(score) -> current_score + score
            | Strike(score, l)        -> nextframe l (current_score + score)
            | Normal(score, l)        -> nextframe l (current_score + score)
            | Other(score)            -> current_score + score
        scoreBowls' 1 bowls 0

    [<Fact>]
    let ``with simple scores should get the expected score.`` () =
        scoreBowls [1;2;3] |> should equal 6

    [<Fact>]
    let ``with a spare should get the expected score (spare).`` () =
        scoreBowls [2;8;1] |> should equal 12

    [<Fact>]
    let ``with a strike should get the expected score (strike).`` () =
        scoreBowls [10;1;2] |> should equal 16

    [<Fact>]
    let ``that is perfect should get a score of 300.``() =
        scoreBowls [for i in 1..18 -> 10] |> should equal 300

    [<Fact>]
    let ``with spares in the last frame should get the expected score (spare in last frame).`` () =
        scoreBowls ([for i in 1..18 -> 0] @ [2;8;1]) |> should equal 11

    [<Fact>]
    let ``with a strike in the last frame should get the expected score (strike in last frame).`` () =
        scoreBowls ([for i in 1..18 -> 0] @ [10;10;1]) |> should equal 21

    [<Fact>]
    let ``with double strikes should add the score of the first strike to the score of the second.`` () =
        scoreBowls [10;10;1] |> should equal 33

    [<Fact>]
    let ``that looks like an average bowler's game should get the expected score (example game).`` () =
        scoreBowls [1;4;4;5;6;4;5;5;10;0;1;7;3;6;4;10;2;8;6] |> should equal 133
Namespace Xunit
Namespace FsUnit
Modul Xunit aus FsUnit
val GetSumOfMultiplesOf3And5: max: int -> int
val max: int
Multiple items
val seq: sequence: 'T seq -> 'T seq

--------------------
type 'T seq = System.Collections.Generic.IEnumerable<'T>
Modul Seq aus Microsoft.FSharp.Collections
val fold<'T,'State> : folder: ('State -> 'T -> 'State) -> state: 'State -> source: 'T seq -> 'State
val acc: int
val number: int
Multiple items
type FactAttribute = inherit Attribute new: unit -> unit member DisplayName: string member Skip: string member Timeout: int
<summary> Attribute that is applied to a method to indicate that it is a fact that should be run by the test runner. It can also be extended to support a customized definition of a test method. </summary>

--------------------
FactAttribute() : FactAttribute
val should: f: ('a -> #NHamcrest.IMatcher<obj>) -> x: 'a -> actual: obj -> unit
val equal: expected: 'b -> NHamcrest.Core.CustomMatcher<obj>
Multiple items
type LightBulb = new: state: bool -> LightBulb override ToString: unit -> string member On: bool

--------------------
new: state: bool -> LightBulb
val state: bool
val x: LightBulb
Eigenschaft LightBulb.On: bool with get
val lightBulb: LightBulb
val x: Given a LightBulb that has had its state set to true
val be: ('b -> 'b)
val True: NHamcrest.Core.CustomMatcher<obj>
Multiple items
val string: value: 'T -> string

--------------------
type string = System.String
val x: Given a LightBulb that has had its state set to false
val False: NHamcrest.Core.CustomMatcher<obj>
val l: int list
val frame: int
aktives Musterergebnis EndOfGame: int list * int -> Choice<int,int,(int * int list),(int * int list),int>
val s: int
aktives Musterergebnis IncompleteStrike: int list * int -> Choice<int,int,(int * int list),(int * int list),int>
val n: int
val tail: int list
aktives Musterergebnis Strike: int list * int -> Choice<int,int,(int * int list),(int * int list),int>
val f: int
aktives Musterergebnis Normal: int list * int -> Choice<int,int,(int * int list),(int * int list),int>
val ls: int list
aktives Musterergebnis Other: int list * int -> Choice<int,int,(int * int list),(int * int list),int>
Multiple items
Modul List aus Microsoft.FSharp.Collections

--------------------
type List<'T> = | op_Nil | op_ColonColon of Head: 'T * Tail: 'T list interface IReadOnlyList<'T> interface IReadOnlyCollection<'T> interface IEnumerable interface IEnumerable<'T> member GetReverseIndex: rank: int * offset: int -> int member GetSlice: startIndex: int option * endIndex: int option -> 'T list static member Cons: head: 'T * tail: 'T list -> 'T list member Head: 'T member IsEmpty: bool member Item: index: int -> 'T with get ...
val fold<'T,'State> : folder: ('State -> 'T -> 'State) -> state: 'State -> list: 'T list -> 'State
val scoreBowls: bowls: int list -> int
val bowls: int list
val scoreBowls': frame: int -> l: int list -> current_score: int -> int
val current_score: int
val nextframe: (int list -> int -> int)
aktive Erkennung EndOfGame: int list * int -> Choice<int,int,(int * int list),(int * int list),int>
val score: int
aktive Erkennung IncompleteStrike: int list * int -> Choice<int,int,(int * int list),(int * int list),int>
aktive Erkennung Strike: int list * int -> Choice<int,int,(int * int list),(int * int list),int>
aktive Erkennung Normal: int list * int -> Choice<int,int,(int * int list),(int * int list),int>
aktive Erkennung Other: int list * int -> Choice<int,int,(int * int list),(int * int list),int>
val i: int
Fork me on GitHub