1.覆盖 | 1. cover
1封面
1.1简介
该模块cover为Erlang程序的覆盖率分析提供了一组函数，计算每个executable line执行的次数。
覆盖率分析可用于验证测试用例，确保所有相关代码都已涵盖，并且在查找代码中的瓶颈时可能会有所帮助。
1.2开始使用封面
例
假设应验证以下程序的测试用例：
-module(channel).
-behaviour(gen_server).
-export([start_link/0,stop/0]).
-export([alloc/0,free/1]). % client interface
-export([init/1,handle_call/3,terminate/2]). % callback functions
start_link() ->
gen_server:start_link{local,channel},channel,[],[]).
stop() ->
gen_server:call(channel,stop).
%%%-Client interface functions-------------------------------------------
alloc() ->
gen_server:call(channel,alloc).
free(Channel) ->
gen_server:call(channel,{free,Channel}).
%%%-gen_server callback functions----------------------------------------
init(_Arg) ->
{ok,channels()}.
handle_call(stop,Client,Channels) ->
{stop,normal,ok,Channels};
handle_call(alloc,Client,Channels) ->
{Ch,Channels2} = alloc(Channels),
{reply,{ok,Ch},Channels2};
handle_call{free,Channel},Client,Channels) ->
Channels2 = free(Channel,Channels),
{reply,ok,Channels2}.
terminate(_Reason,Channels) ->
ok.
%%%-Internal functions---------------------------------------------------
channels() ->
[ch1,ch2,ch3].
alloc([Channel|Channels]) ->
{Channel,Channels};
alloc([]) ->
false.
free(Channel,Channels) ->
[Channel|Channels].
测试用例实现如下：
-module(test).
-export([s/0]).
s() ->
{ok,Pid} = channel:start_link(),
{ok,Ch1} = channel:alloc(),
ok = channel:free(Ch1),
ok = channel:stop().
制备
首先，封面必须启动。这产生了一个拥有覆盖数据库的过程，其中所有覆盖数据将被存储。
1> cover:start().
{ok,<0.30.0>}
要在覆盖率分析中包含其他节点，请使用start/1。所有覆盖编译模块将被加载到所有节点上，并且在分析时将汇总所有节点的数据。为了简单起见，这个例子只涉及当前节点。
在进行任何分析之前，涉及的模块必须进行封面编译。这意味着在将模块编译为二进制文件之前，会将一些额外的信息添加到模块中loaded。该模块的源文件不受影响，也没有.beam创建文件。
2> cover:compile_module(channel).
{ok,channel}
每次channel调用Cover编译模块中的函数时，有关该调用的信息都将添加到Cover数据库中。运行测试用例：
3> test:s().
ok
封面分析是通过检查封面数据库的内容来执行的。该输出通过两个参数确定，Level和Analysis。Analysis是coverage或者calls并确定分析的类型。Level或者是module，function，clause，或line，并确定分析的水平。
覆盖率分析
类型分析coverage用于找出有多少代码已被执行以及尚未执行多少代码。覆盖率由一个元组表示{Cov,NotCov}，其中Cov是至少执行过一次NotCov的可执行行数，是尚未执行的可执行行数。
如果分析是在模块层次上进行的，则将整个模块的结果作为元组给出{Module,{Cov,NotCov}}：
4> cover:analyse(channel,coverage,module).
{ok,{channel,{14,1}}}
对于channel，结果显示模块中有14条线被覆盖，但一条线不被覆盖。
如果分析是在功能级别上进行的，则结果将以元组列表的形式给出，{Function,{Cov,NotCov}}模块中的每个函数都会使用一个元组列表。函数由其模块名称，函数名称和参数指定：
5> cover:analyse(channel,coverage,function).
{ok,[{{channel,start_link,0},{1,0}},
{{channel,stop,0},{1,0}},
{{channel,alloc,0},{1,0}},
{{channel,free,1},{1,0}},
{{channel,init,1},{1,0}},
{{channel,handle_call,3},{5,0}},
{{channel,terminate,2},{1,0}},
{{channel,channels,0},{1,0}},
{{channel,alloc,1},{1,1}},
{{channel,free,2},{1,0}}]}
对于channel，结果显示未被覆盖的行在函数中channel:alloc/1。
如果分析是在子句级别进行的，则结果将以元组列表的形式给出，{Clause,{Cov,NotCov}}模块中的每个函数子句都会使用一个元组列表。子句由其模块名称，函数名称，元素和函数定义中的位置指定：
6> cover:analyse(channel,coverage,clause).
{ok,[{{channel,start_link,0,1},{1,0}},
{{channel,stop,0,1},{1,0}},
{{channel,alloc,0,1},{1,0}},
{{channel,free,1,1},{1,0}},
{{channel,init,1,1},{1,0}},
{{channel,handle_call,3,1},{1,0}},
{{channel,handle_call,3,2},{2,0}},
{{channel,handle_call,3,3},{2,0}},
{{channel,terminate,2,1},{1,0}},
{{channel,channels,0,1},{1,0}},
{{channel,alloc,1,1},{1,0}},
{{channel,alloc,1,2},{0,1}},
{{channel,free,2,1},{1,0}}]}
因为channel，结果显示未被覆盖的行在第二个子句中channel:alloc/1。
最后，如果分析是在线级进行的，则结果以元组列表的形式给出，{Line,{Cov,NotCov}}源代码中的每个可执行行都有一个元组列表。一行由其模块名称和行号指定。
7> cover:analyse(channel,coverage,line).
{ok,[{{channel,9},{1,0}},
{{channel,12},{1,0}},
{{channel,17},{1,0}},
{{channel,20},{1,0}},
{{channel,25},{1,0}},
{{channel,28},{1,0}},
{{channel,31},{1,0}},
{{channel,32},{1,0}},
{{channel,35},{1,0}},
{{channel,36},{1,0}},
{{channel,39},{1,0}},
{{channel,44},{1,0}},
{{channel,47},{1,0}},
{{channel,49},{0,1}},
{{channel,52},{1,0}}]}
因为channel，结果显示未被覆盖的行是行号49。
通话统计
类型分析calls用于找出被调用的次数，并用一个整数表示Calls。
如果分析是在模块级别进行的，则结果以元组的形式给出{Module,Calls}。以下Calls是模块中对函数的调用总数：
8> cover:analyse(channel,calls,module).
{ok,{channel,12}}
因为channel结果显示模块中的功能总共有12次调用。
如果分析是在功能级别上进行的，则结果以元组列表的形式给出{Function,Calls}。以下Calls是每个函数的调用次数：
9> cover:analyse(channel,calls,function).
{ok,[{{channel,start_link,0},1},
{{channel,stop,0},1},
{{channel,alloc,0},1},
{{channel,free,1},1},
{{channel,init,1},1},
{{channel,handle_call,3},3},
{{channel,terminate,2},1},
{{channel,channels,0},1},
{{channel,alloc,1},1},
{{channel,free,2},1}]}
因为channel结果显示这handle_call/3是模块中最被称为的函数（三次调用）。所有其他功能都被调用过一次。
如果分析是在子句级别进行的，则结果将以元组列表的形式给出{Clause,Calls}。以下Calls是每个函数子句的调用次数：
10> cover:analyse(channel,calls,clause).
{ok,[{{channel,start_link,0,1},1},
{{channel,stop,0,1},1},
{{channel,alloc,0,1},1},
{{channel,free,1,1},1},
{{channel,init,1,1},1},
{{channel,handle_call,3,1},1},
{{channel,handle_call,3,2},1},
{{channel,handle_call,3,3},1},
{{channel,terminate,2,1},1},
{{channel,channels,0,1},1},
{{channel,alloc,1,1},1},
{{channel,alloc,1,2},0},
{{channel,free,2,1},1}]}
因为channel结果显示所有的子句都被调用过一次，除了第二个子句channel:alloc/1完全没有被调用。
最后，如果分析是在线上进行的，结果将以元组列表的形式给出{Line,Calls}。这Calls是每行执行的次数：
11> cover:analyse(channel,calls,line).
{ok,[{{channel,9},1},
{{channel,12},1},
{{channel,17},1},
{{channel,20},1},
{{channel,25},1},
{{channel,28},1},
{{channel,31},1},
{{channel,32},1},
{{channel,35},1},
{{channel,36},1},
{{channel,39},1},
{{channel,44},1},
{{channel,47},1},
{{channel,49},0},
{{channel,52},1}]}
因为channel结果显示所有行都被执行过一次，只有行号49没有被执行。
分析到文件
channel可以使用cover:analysis_to_file/1以下命令将行级别调用分析写入文件：
12> cover:analyse_to_file(channel).
{ok,"channel.COVER.out"}
该函数channel.erl为每个可执行行指定该行已执行多少次的位置创建一个副本。输出文件被调用channel.COVER.out。
File generated from channel.erl by COVER 2001-05-21 at 11:16:38
****************************************************************************
| -module(channel).
| -behaviour(gen_server).
|
| -export([start_link/0,stop/0]).
| -export([alloc/0,free/1]). % client interface
| -export([init/1,handle_call/3,terminate/2]). % callback functions
|
| start_link() ->
1..| gen_server:start_link{local,channel},channel,[],[]).
|
| stop() ->
1..| gen_server:call(channel,stop).
|
| %%%-Client interface functions------------------------------------
|
| alloc() ->
1..| gen_server:call(channel,alloc).
|
| free(Channel) ->
1..| gen_server:call(channel,{free,Channel}).
|
| %%%-gen_server callback functions---------------------------------
|
| init(_Arg) ->
1..| {ok,channels()}.
|
| handle_call(stop,Client,Channels) ->
1..| {stop,normal,ok,Channels};
|
| handle_call(alloc,Client,Channels) ->
1..| {Ch,Channels2} = alloc(Channels),
1..| {reply,{ok,Ch},Channels2};
|
| handle_call{free,Channel},Client,Channels) ->
1..| Channels2 = free(Channel,Channels),
1..| {reply,ok,Channels2}.
|
| terminate(_Reason,Channels) ->
1..| ok.
|
| %%%-Internal functions--------------------------------------------
|
| channels() ->
1..| [ch1,ch2,ch3].
|
| alloc([Channel|Channels]) ->
1..| {Channel,Channels};
| alloc([]) ->
0..| false.
|
| free(Channel,Channels) ->
1..| [Channel|Channels].
结语
通过查看分析结果，可以推断出，在所有渠道都被分配的情况下，测试用例不能涵盖这种情况，因此test.erl应该进行相应的扩展。
顺便提一句，当测试用例被纠正时，channel确实应该发现一个错误。
当封面分析准备就绪后，封面将停止，所有封面编译模块都会被封上unloaded。代码channel现在按照通常的方式从.beam当前路径中的文件加载。
13> code:which(channel).
cover_compiled
14> cover:stop().
ok
15> code:which(channel).
"./channel.beam"
1.3杂项
性能
Cover编译模块中的代码执行速度比定期编译模块更慢，耗费更多的内存。由于Cover数据库包含每个Cover编译模块中每个可执行文件行的信息，因此性能与Cover编译模块的大小和数量成比例地下降。
为了提高性能，当分析结果盖就可以做多次调用analyse和analyse_to_file一次。您也可以使用async_analyse_to_file便利功能。
可执行的行
封面使用可执行行的概念，这是包含可执行表达式（如匹配或函数调用）的代码行。在case- 或receive语句中包含注释，函数头或模式的空行或行不可执行。
在下面的示例中，编号为2、4、6、8和11的行是可执行行：
1: is_loaded(Module,Compiled) ->
2: case get_file(Module,Compiled) of
3: {ok,File} ->
4: case code:which(Module) of
5: ?TAG ->
6: {loaded,File};
7: _ ->
8: unloaded
9: end;
10: false ->
11: false
12: end.
代码加载机制
当一个模块被Cover编译时，它也使用Erlang的正常代码加载机制加载。这意味着如果在Cover会议期间重新加载Cover编译模块（例如使用）c(Module)，它将不再被Cover编译。
使用cover:is_compiled/1或code:which/1查看一个模块是否被封装编译（并且仍然载入）。
当封面停止时，所有封面编译模块都将被卸载。
