anchor.diff:      ok = lcnt:conflicts(),
       ok = lcnt:stop(),
       t_swap_keys_file(Files).
  +
  +%% Simple smoke test of actual lock-counting, if running on
  +%% a run-time with lock-counting enabled.
  +
  +smoke_lcnt(Config) ->
  +    case erlang:system_info(build_type) of
  +        lcnt ->
  +            do_smoke_lcnt(Config);
  +        _ ->
  +            {skip,"Lock counting is not enabled"}
  +    end.
  +
  +do_smoke_lcnt(Config) ->
  +    PrivDir = proplists:get_value(priv_dir, Config),
  +    SaveFile = filename:join(PrivDir, atom_to_list(?FUNCTION_NAME)),
  +    {Time,ok} = timer:tc(fun() -> lcnt:apply(fun() -> big_bang(200) end) end),
  +    io:format("~p ms\n", [Time]),
  +    ok = lcnt:conflicts(),
  +    ok = lcnt:save(SaveFile),
  +    ok = lcnt:load(SaveFile),
  +    ok = lcnt:conflicts(),
  +    lcnt:stop().
  +
  +
  +%%%
  +%%% A slightly modified version of Rickard Green's Big Bang benchmark.
  +%%%
  +
  +big_bang(N) when is_integer(N) ->
  +    Procs = spawn_procs(N),
  +    RMsgs = lists:map(fun (P) -> {done, P} end, Procs),
  +    send_procs(Procs, {procs, Procs, self()}),
  +    receive_msgs(RMsgs),
  +    lists:foreach(fun (P) -> exit(P, normal) end, Procs).
  +
  +pinger([], [], true) ->
  +    receive
  +        {procs, Procs, ReportTo} ->
  +            pinger(Procs, [], ReportTo)
  +    end;
  +pinger([], [], false) ->
  +    receive {ping, From} -> From ! {pong, self()} end,
  +    pinger([],[],false);
  +pinger([], [], ReportTo) ->
  +    ReportTo ! {done, self()},
  +    pinger([],[],false);
  +pinger([],[Po|Pos] = Pongers, ReportTo) ->
  +    receive
  +        {ping, From} ->
  +            From ! {pong, self()},
  +            pinger([], Pongers, ReportTo);
  +        {pong, Po} ->
  +            pinger([], Pos, ReportTo)
  +    end;
  +pinger([Pi|Pis], Pongers, ReportTo) ->
  +    receive {ping, From} -> From ! {pong, self()}
  +    after 0 -> ok
  +    end,
  +    Pi ! {ping, self()},
  +    pinger(Pis, [Pi|Pongers], ReportTo).
  +
  +spawn_procs(N) when N =< 0 ->
  +    [];
  +spawn_procs(N) ->
  +    [spawn_link(fun () -> pinger([], [], true) end) | spawn_procs(N-1)].
  +
  +send_procs([], Msg) ->
  +    Msg;
  +send_procs([P|Ps], Msg) ->
  +    P ! Msg,
  +    send_procs(Ps, Msg).
  +
  +receive_msgs([]) ->
  +    ok;
  +receive_msgs([M|Ms]) ->
  +    receive
  +        M ->
  +            receive_msgs(Ms)
  +    end.
  
positive.code:      {timetrap,{minutes,4}}].
  
  all() ->
      [t_load, t_conflicts, t_locations, t_swap_keys].
  
  %%----------------------------------------------------------------------
  %% Tests
  
negative.code: -export([t_load/1,
           t_conflicts/1,
           t_locations/1,
           t_swap_keys/1,
           smoke_lcnt/1]).
  
  init_per_testcase(_Case, Config) ->
      Config.
  