OUnit: xUnit testing framework for OCaml

What is unit Testing?

A test-oriented methodology for software development is most effective when tests are easy to create, change, and execute. The JUnit tool pioneered test-first development in Java. OUnit is an adaptation of JUnit to OCaml.

With OUnit, as with JUnit, you can easily create tests, name them, group them into suites, and execute them, with the framework checking the results automatically.

Getting Started

The basic principle of a OUnit test suite is to have a test.ml file which will contain the tests, and an OCaml module under test, here named foo.ml.

File foo.ml:

(* The functions we wish to test *)
let unity x = x;;
let funix ()= 0;;
let fgeneric () = failwith "Not implemented";;

The main point of a test is to check that the function under test has the expected behavior. You check the behavior using assert functions. The simplest one is OUnit2.assert_equal. This function compares the result of the function under test with an expected result.

Some useful functions include:

File test.ml:

open OUnit2;;

let test1 test_ctxt = assert_equal "x" (Foo.unity "x");;

let test2 test_ctxt = assert_equal 100 (Foo.unity 100);;

(* Name the test cases and group them together *)
let suite =
 ["test1">:: test1;
  "test2">:: test2]

let () =
  run_test_tt_main suite

And compile the module

$ ocamlfind ocamlc -o test -package oUnit -linkpkg -g foo.ml test.ml

A executable named "test" will be created. When run it produces the following output.

$ ./test
Ran: 2 tests in: 0.00 Seconds

When using OUnit2.run_test_tt_main, a non-zero exit code signals that the test suite failed.

Extra features

OUnit supports colored output and JUnit/HTML generation. They are command line flags or environment variables that you can set before running OUnit test suites.

Advanced usage

This section is only for advanced users who wish to uncover the power of OUnit.

Error reporting

The error reporting part of OUnit is quite important. If you want to identify the failure, you should tune the display of the value and the test.

Here is a list of things you can display:

open OUnit2;;

let _ =
  (fun test_ctxt ->
      ~msg:"int value"
      (Foo.unity 1))

Command-line arguments

OUnit2.run_test_tt_main already provides a set of command-line arguments to help users run only the tests they want:

It is also possible to add your own command-line arguments, environment variables and config file variables. You should do it if you want to define some extra arguments.

For example:

open OUnit2;;

let my_program =
  Conf.make_exec "my_program"

let test1 test_ctxt =
  assert_command (my_program test_ctxt) []

let () =
  run_test_tt_main ("test1" >:: test1)

The Conf.make_* creates a command-line argument, an environment variable and a config file variable.

Skip and todo tests

Tests are not always meaningful and can even fail because something is missing in the environment. In order to handle this, you can define a skip condition that will skip the test.

If you start by defining your tests rather than implementing the functions under test, you know that some tests will just fail. You can mark these tests as pending todo tests. This way they will be reported differently in your test suite.

open OUnit2;;

let _ =
  "allfuns" >:::
    (fun test_ctxt ->
      skip_if (Sys.os_type = "Win32") "Don't work on Windows";
        (Foo.funix ()));

    (fun test_ctxt ->
      todo "fgeneric not implemented";
        (Foo.fgeneric ()));


This module provide thread related utilities. In particular, it provides a "thread" runner, that allows to run concurrently tests using OCaml threads. This should provide a good level of parallelism on Windows, for UNIX systems it is recommended to use the standard "process" runner.

To install the extra thread runner:

let () = OUnitThreads.init ()

Effective OUnit

This section has general tips about unit testing and OUnit. It is the result of some years using OUnit in real-world applications.

open OUnit2;;

let _ =
    (fun (arg,res) ->
      let title =
        Printf.sprintf "%s->%s" arg res
        title >::
        (fun test_ctxt ->
          assert_equal res (Foo.unity arg)))
      ["abcd", "abcd";
       "defg", "defg";
       "wxyz", "wxyz"])
open OUnit2;;

let _ =
  (* We need to call a function in a particular directory *)
  (fun test_ctxt ->
    assert_command ~chdir:"/foo/test" "ls" [])

The unit testing scope is always hard to define. Unit testing should be about testing a single feature. But OUnit can also help you to test higher-level behavior, by running a full program for example. While it isn't real unit testing, you can use OUnit to do it and should not hesitate to do it.

In terms of lines of codes, a test suite can represent from 10% to 150% of the code under test. With time, your test suite will grow faster than your program/library. A good ratio is 33%.


These modules should only be used when building low-level OUnit features. They allow to create your own process runner or logger.

Modules available in ounit2.advanced: