cover(3)

MODULE
cover - A Coverage Analysis Tool for Erlang

DESCRIPTION

The module cover provides a set of functions for coverage analysis of Erlang programs, counting how many times each executable line of code is executed when a program is run.
 An executable line contains an Erlang expression such as a matching or a function call. A blank line or a line containing a comment, function head or pattern in a case- or receive statement is not executable.

Coverage analysis can be used to verify test cases, making sure all relevant code is covered, and may also be helpful when looking for bottlenecks in the code.

Before any analysis can take place, the involved modules must be Cover compiled. This means that some extra information is added to the module before it is compiled into a binary which then is loaded. The source file of the module is not affected and no .beam file is created.

Each time a function in a Cover compiled module is called, information about the call is added to an internal database of Cover. The coverage analysis is performed by examining the contents of the Cover database. The output Answer is determined by two parameters, Level and Analysis.

    *   Level = module

        Answer = {Module, Value}, where Module is the module name.

    *   Level = function

        Answer = [{Function, Value}], one tuple for each function in the module. A function is specified by its module name M, function name F and arity A as a tuple {M, F, A}.

    *   Level = clause

        Answer = [{Clause, Value}], one tuple for each clause in the module. A clause is specified by its module name M, function name F, arity A and position in the function definition C as a tuple {M, F, A, C}.

    *   Level = line

        Answer = [{Line, Value}], one tuple for each executable line in the module. A line is specified by its module name M and line number in the source file N as a tuple {M, N}.

    *   Analysis = coverage

        Value = {Cov, NotCov} where Cov is the number of executable lines in the module, function, clause or line that have been executed at least once and NotCov is the number of executable lines that have not been executed.

    *   Analysis = calls

        Value = Calls which is the number of times the module, function, or clause has been called. In the case of line level analysis, Calls is the number of times the line has been executed.

EXPORTS

start() -> {ok,Pid} | {error,Reason}

    Types
        Pid = pid()
        Reason = {already_started, Pid}

    Starts the Cover server which owns the Cover internal database. This function is called automatically by the other functions in the module.

compile(ModFile) -> Result
compile(ModFile, Options) -> Result
compile_module(ModFile) -> Result
compile_module(ModFile, Options) -> Result

    Types
        ModFile = Module | File
         Module = atom()
         File = string()
        Options = [Option]
         Option = {i, Dir} | {d, Macro} | {d, Macro, Value}
          See compile:file/2.
        Result = {ok, Module} | {error, File}

    Compiles a module for Cover analysis. The module is given by its module name Module or by its file name File. The .erl extension may be omitted. If the module is located in another directory, the path has to be specified.

    Options is a list of compiler options which defaults to []. Only options defining include file directories and macros are passed to compile:file/2, everything else is ignored.

    If the module is successfully Cover compiled, the function returns {ok, Module}. Otherwise the function returns {error, File}. Errors and warnings are printed as they occur.

    Note that the internal database is (re-)initiated during the compilation, meaning any previously collected coverage data for the module will be lost.

compile_directory() -> [Result] | {error,Reason}
compile_directory(Dir) -> [Result] | {error,Reason}
compile_directory(Dir, Options) -> [Result] | {error,Reason}

    Types
        Dir = string()
        Options = [Option]
          See compile_module/1, 2
        Result = {ok, Module} | {error, File}
          See compile_module/1, 2
        Reason = eacces | enoent

    Compiles all modules (.erl files) in a directory Dir for Cover analysis the same way as compile_module/1, 2 and returns a list with the return values.

    Dir defaults to the current working directory.

    The function returns {error, eacces} if the directory is not readable or {error, enoent} if the directory does not exist.

analyse(Module) -> {ok,Answer} | {error,Error}
analyse(Module, Analysis) -> {ok,Answer} | {error,Error}
analyse(Module, Level) -> {ok,Answer} | {error,Error}
analyse(Module, Analysis, Level) -> {ok,Answer} | {error,Error}

    Types
        Module = atom()
        Analysis = coverage | calls
        Level = line | clause | function | module
        Answer = {Module, Value} | [{Item, Value}]
         Item = Line | Clause | Function
          Line = {M, N}
          Clause = {M, F, A, C}
          Function = {M, F, A}
           M = F = atom()
           N = A = C = integer()
         Value = {Cov, NotCov} | Calls
          Cov = NotCov = Calls = integer()
        Error = {not_cover_compiled, Module}

    Performs analysis of a Cover compiled module Module, as specified by Analysis and Level (see above), by examining the contents of the internal database.

    Analysis defaults to coverage and Level defaults to function.

    If Module is not Cover compiled, the function returns {error, {not_cover_compiled, Module}}.

analyse_to_file(Module) ->
analyse_to_file(Module, OutFile) -> {ok,OutFile} | {error,Error}

    Types
        Module = atom()
        OutFile = string()
        Error = {not_cover_compiled, Module} | {file, File, Reason}
         File = string()
         Reason = term()

    Makes a copy OutFile of the source file for a module Module, where it for each executable line is specified how many times it has been executed.

    The output file OutFile defaults to Module.COVER.out.

    If Module is not Cover compiled, the function returns {error, {not_cover_compiled, Module}}.

    If the source file and/or the output file cannot be opened using file:open/2, the function returns {error, {file, File, Reason}} where File is the file name and Reason is the error reason.

modules() -> [Module]

    Types
        Module = atom()

    Returns a list with all modules that are currently Cover compiled.

is_compiled(Module) -> {file,File} | false

    Types
        Module = atom()
        Beam = string()

    Returns {file, File} if the module Module is Cover compiled, or false otherwise. File is the .erl file used by cover:compile_module/1, 2.

reset(Module) -> ok
reset() -> ok

    Types
        Module = atom()

    Resets all coverage data for a Cover compiled module Module in the Cover database. If the argument is omitted, the coverage data will be reset for all modules known by Cover.

    If Module is not Cover compiled, the function returns {error, {not_cover_compiled, Module}}.

stop() -> ok

    Stops the Cover server and unloads all Cover compiled code.

SEE ALSO

code(3), compile(3)

AUTHOR
Gunilla Hugosson - support@erlang.ericsson.se