it took me some time to play with it and come up with a good method of doing that. eventually i have replaced the unit testing makefile line with:

check:
	@for f in $(MODULES); do \
	echo $$f; \
	erl $(FLAGS) -noshell -eval "
	cover:compile($$f, [{i,\"$(INCLUDE)\"}]),\
	$$f:test(),
	cover:analyse_to_file($$f, \"$(DOC)/$${f}_coverage.html\", [html])."\
	-s init stop; \

This actually do 3 things in a raw:

1. compile each module using cover:compile.
2. run the test, using the eunit test() function.
3. dump analysis into html files on doc directory

enjoy!

edit: i found out, that you compile the whole directory for covearge, so the result you get is thecombined  coverage for all the specified modules and tests.

OBJECTS := $(patsubst %.erl,$(BIN)/%.$(EMULATOR),$(wildcard *.erl))
MODULES := $(patsubst %.erl,%,$(wildcard *.erl))
SKIP_FILES := $(patsubst %.erl,%,$(wildcard *_tests.erl))
MODULES := $(filter-out $(SKIP_FILES), $(MODULES))
MODULES := [$(subst $(space),$(comma),$(MODULES))]
 
check:
	@echo Testing units...
	@$(TIME) erl $(ERL_LIB_FLAGS) \
	-mnesia dir '"$(DATA_DIR)"' -mnesia debug $(MNESIA) -noshell \
	-eval "\
	cover:compile_directory(\".\", [{i,\"$(INCLUDE)\"},{d,'NODEBUG'}]), \
	T = fun(X) -> io:format(user, \"~-20.s\", [X]), X:test() end, \
	[T(X) || X <- "$(MODULES)"], \
	F = fun(X) -> cover:analyse_to_file(X, \"$(LOG)/\" ++ \
	    atom_to_list(X) ++ \"_coverage.html\", [html]) end, \
	[F(X) || X <- "$(MODULES)"]. \
	" -s init stop;

for example, the next function has its own testing function:

flip_sides(Side) ->
	case Side of
		x -> o;
		o -> x
	end.
 
flip_sides_test() ->
	?assert(flip_sides(x) == o),
	?assert(flip_sides(o) == x).

the testing function is invoked automatically by calling the test function of this module, e.g. mymodule:test(). the test function is supplied by the eunit framework, which takes every function that ends with _test() and add it to the testing list of that module.

a more advanced testing method is needed for testing the always loops that keep the state on the erlang module. few problems need to be solved in order to properly test those kind of loops:

• initial state loading.
• external function calls.
• check of the new state, after each event.

the first problem can be solved by adding a new start function for debug use, which takes all the state variables of the always loop as parameters. this allows you to start the always loop in any state you want.

% original start of arity/0
start() -> start([], start).
 
% new function for debug of arity/2
start(State, Status) ->  register(?MODULE, spawn(fun() -> always(State, Status) end)).
 
% the state loop
always(State, Status) ->
	receive
		{From, stop} -> From ! stopped;
		{From, reset} -> always([], start);
		{From, {add, N}} -> always(module2:add(N, State), continue)
	end.

the next problem is the call for external function, shown here as call for module2:add/2, i solved this by adding another parameter to the loop’s state in order to keep a reference to the called function. i have also added it to the start function.

% original start of arity/0
start() -> start([], start, fun module2:add/2).
 
% new function for debug of arity/2
start(State, Status, Func) ->
	register(?MODULE, spawn(fun() -> always(State, Status, Func) end)).
 
% the state loop
always(State, Status, Func) ->
	receive
		{From, stop} -> From ! stopped;
		{From, reset} -> always([], start, Func);
		{From, {add, N}} -> always(Func(N, State), continue, Func)
	end.

adding a reference to the external function allows me to switch to a mocking function as desired. for the new state checking i have added a dump command to the always loop which return me the current state, so i can test it on my testing functions.

% the state loop
always(State, Status, Func) ->
	receive
		{From, stop} -> From ! stopped;
		{From, reset} -> From ! reset, always([], start, Func);
		{From, {add, N}} -> always(Func(N, State), continue, Func);
		{From, dump} -> {State, dump, Func}
	end.

last i’ll show the test function:

always_reset_test() ->
	Fun = fun callback_check_reset_mockup/2,
	start([x, o], continue, Fun),
	rpc(reset),
	?assert(rpc(dump) == {[], start, Fun}),
	stop().

callback_check_reset_mockup(N, State) -> void. % you can check match if applicable

that's it!

]]> http://www.virtual-clouds.com/2008/10/6/more-on-eunit/feed/ 0