3 people like it.

MbUnit DSL

DSL for functional style, HUnit-like testing with MbUnit.

 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 
11: 
12: 
13: 
14: 
15: 
16: 
17: 
18: 
19: 
20: 
21: 
22: 
23: 
24: 
25: 
26: 
27: 
28: 
29: 
30: 
31: 
32: 
33: 
34: 
35: 
36: 
37: 
38: 
39: 
40: 
41: 
42: 
43: 
44: 
45: 
46: 
47: 
48: 
49: 
50: 
51: 
52: 
53: 
54: 
55: 
56: 
57: 
58: 
59: 
60: 
61: 
62: 
63: 
64: 
65: 
66: 
67: 
68: 
69: 
70: 
71: 
72: 
73: 

open System.IO
open MbUnit.Framework

// DSL to define test suites and cases

let inline (=>>) name tests =
    let suite = TestSuite(name)
    Seq.iter suite.Children.Add tests
    suite :> Test

let inline (=>) name (test: unit -> unit) =
    TestCase(name, Gallio.Common.Action test) :> Test

let inline (+>) f =
     Seq.map (fun (name, partialTest) ->
                    name => f partialTest)

let inline (==>) name test = name,test        

// Higher-order functions as setup/teardown

let withMemoryStream f () =
    use ms = new MemoryStream()
    f ms

let withTempFile f () =
    let file = Path.GetTempFileName()
    try 
        f file
    finally
        File.Delete file

// These can be easily composed:

let withMemoryStreamAndTempFile f =
    withMemoryStream (fun s -> withTempFile (fun t -> f s t) <| ())

// Test definition:


[<StaticTestFactory>]
let tests() = 
    [
        "A test suite" =>> [
            "2 + 2 = 4" => 
                fun _ -> Assert.AreEqual(4, 2+2)
            "A test subsuite" =>> [
                // generate parameterized tests
                for i in 0..3 do
                for j in 1..4 do
                for k in 3..10 ->
                    sprintf "%d + %d = %d" i j k => 
                        fun _ -> Assert.AreEqual(k, i+j)
            ]
        ]
        "Another suite" =>> [
            "With temp file" =>> 
                withTempFile +> [ // apply setup/teardown to a list of "partial tests"
                    "file exists" ==> (Assert.IsTrue << File.Exists)
                    "print" ==> printfn "%s"
                    "nothing" ==> ignore
                ]
            "Write 'Hello World!'" =>
                withMemoryStreamAndTempFile
                    (fun ms tf ->
                        use w = new StreamWriter(ms)
                        w.Write "Hello World!"
                        w.Flush()
                        ms.Position <- 0L
                        File.WriteAllBytes(tf, ms.ToArray())
                        Assert.AreEqual(12L, FileInfo(tf).Length))
        ]
    ]
namespace System
namespace System.IO
val name : 'a
val tests : seq<'b>
val suite : obj
module Seq

from Microsoft.FSharp.Collections
val iter : action:('T -> unit) -> source:seq<'T> -> unit

Full name: Microsoft.FSharp.Collections.Seq.iter
val test : (unit -> unit)
type unit = Unit

Full name: Microsoft.FSharp.Core.unit
val f : ('a -> unit -> unit)
val map : mapping:('T -> 'U) -> source:seq<'T> -> seq<'U>

Full name: Microsoft.FSharp.Collections.Seq.map
val name : 'b
val partialTest : 'a
val test : 'b
val withMemoryStream : f:(MemoryStream -> 'a) -> unit -> 'a

Full name: Script.withMemoryStream
val f : (MemoryStream -> 'a)
val ms : MemoryStream
Multiple items
type MemoryStream =
  inherit Stream
  new : unit -> MemoryStream + 6 overloads
  member CanRead : bool
  member CanSeek : bool
  member CanWrite : bool
  member Capacity : int with get, set
  member Flush : unit -> unit
  member GetBuffer : unit -> byte[]
  member Length : int64
  member Position : int64 with get, set
  member Read : buffer:byte[] * offset:int * count:int -> int
  ...

Full name: System.IO.MemoryStream

--------------------
MemoryStream() : unit
MemoryStream(capacity: int) : unit
MemoryStream(buffer: byte []) : unit
MemoryStream(buffer: byte [], writable: bool) : unit
MemoryStream(buffer: byte [], index: int, count: int) : unit
MemoryStream(buffer: byte [], index: int, count: int, writable: bool) : unit
MemoryStream(buffer: byte [], index: int, count: int, writable: bool, publiclyVisible: bool) : unit
val withTempFile : f:(string -> 'a) -> unit -> 'a

Full name: Script.withTempFile
val f : (string -> 'a)
val file : string
type Path =
  static val DirectorySeparatorChar : char
  static val AltDirectorySeparatorChar : char
  static val VolumeSeparatorChar : char
  static val InvalidPathChars : char[]
  static val PathSeparator : char
  static member ChangeExtension : path:string * extension:string -> string
  static member Combine : [<ParamArray>] paths:string[] -> string + 3 overloads
  static member GetDirectoryName : path:string -> string
  static member GetExtension : path:string -> string
  static member GetFileName : path:string -> string
  ...

Full name: System.IO.Path
Path.GetTempFileName() : string
type File =
  static member AppendAllLines : path:string * contents:IEnumerable<string> -> unit + 1 overload
  static member AppendAllText : path:string * contents:string -> unit + 1 overload
  static member AppendText : path:string -> StreamWriter
  static member Copy : sourceFileName:string * destFileName:string -> unit + 1 overload
  static member Create : path:string -> FileStream + 3 overloads
  static member CreateText : path:string -> StreamWriter
  static member Decrypt : path:string -> unit
  static member Delete : path:string -> unit
  static member Encrypt : path:string -> unit
  static member Exists : path:string -> bool
  ...

Full name: System.IO.File
File.Delete(path: string) : unit
val withMemoryStreamAndTempFile : f:(MemoryStream -> string -> 'a) -> (unit -> 'a)

Full name: Script.withMemoryStreamAndTempFile
val f : (MemoryStream -> string -> 'a)
val s : MemoryStream
val t : string
val tests : unit -> 'a list

Full name: Script.tests
val i : int
val j : int
val k : int
val sprintf : format:Printf.StringFormat<'T> -> 'T

Full name: Microsoft.FSharp.Core.ExtraTopLevelOperators.sprintf
File.Exists(path: string) : bool
val printfn : format:Printf.TextWriterFormat<'T> -> 'T

Full name: Microsoft.FSharp.Core.ExtraTopLevelOperators.printfn
val ignore : value:'T -> unit

Full name: Microsoft.FSharp.Core.Operators.ignore
val tf : string
val w : StreamWriter
Multiple items
type StreamWriter =
  inherit TextWriter
  new : stream:Stream -> StreamWriter + 6 overloads
  member AutoFlush : bool with get, set
  member BaseStream : Stream
  member Close : unit -> unit
  member Encoding : Encoding
  member Flush : unit -> unit
  member Write : value:char -> unit + 3 overloads
  static val Null : StreamWriter

Full name: System.IO.StreamWriter

--------------------
StreamWriter(stream: Stream) : unit
StreamWriter(path: string) : unit
StreamWriter(stream: Stream, encoding: System.Text.Encoding) : unit
StreamWriter(path: string, append: bool) : unit
StreamWriter(stream: Stream, encoding: System.Text.Encoding, bufferSize: int) : unit
StreamWriter(path: string, append: bool, encoding: System.Text.Encoding) : unit
StreamWriter(path: string, append: bool, encoding: System.Text.Encoding, bufferSize: int) : unit
TextWriter.Write(value: obj) : unit
   (+0 other overloads)
TextWriter.Write(value: decimal) : unit
   (+0 other overloads)
TextWriter.Write(value: float) : unit
   (+0 other overloads)
TextWriter.Write(value: float32) : unit
   (+0 other overloads)
TextWriter.Write(value: uint64) : unit
   (+0 other overloads)
TextWriter.Write(value: int64) : unit
   (+0 other overloads)
TextWriter.Write(value: uint32) : unit
   (+0 other overloads)
TextWriter.Write(value: int) : unit
   (+0 other overloads)
TextWriter.Write(value: bool) : unit
   (+0 other overloads)
StreamWriter.Write(value: string) : unit
   (+0 other overloads)
StreamWriter.Flush() : unit
property MemoryStream.Position: int64
File.WriteAllBytes(path: string, bytes: byte []) : unit
MemoryStream.ToArray() : byte []
Multiple items
type FileInfo =
  inherit FileSystemInfo
  new : fileName:string -> FileInfo
  member AppendText : unit -> StreamWriter
  member CopyTo : destFileName:string -> FileInfo + 1 overload
  member Create : unit -> FileStream
  member CreateText : unit -> StreamWriter
  member Decrypt : unit -> unit
  member Delete : unit -> unit
  member Directory : DirectoryInfo
  member DirectoryName : string
  member Encrypt : unit -> unit
  ...

Full name: System.IO.FileInfo

--------------------
FileInfo(fileName: string) : unit

More information

Link:http://fssnip.net/b5
Posted:12 years ago
Author:Mauricio Scheffer
Tags: mbunit , testing

This web site is created using F# and Suave web server. It is hosted on Azure and the source code is on GitHub. Contributions are welcome!

The first version of fssnip.net has been created by @tomaspetricek back in 2010. This web site is a new, open-source and contribution-friendly version.