anchor.diff:  
       lager:info("Remotely executing the test."),
       Result = rpc:call(Node, ?MODULE, test, []),
  -    ?assertEqual(ok, Result),
  +    ?assertMatch({ok, _}, Result),
   
       pass.
   
   -endif.
   
  +test() ->
  +    lasp_test:test(?MODULE).
  +
  +%% Macro definitions.
  +
  +%% Lasp set type to use.
   -define(SET, lasp_orset).
   
   %% The number of clients.
  
positive.code:     %% Read the leaderboard's current value.
      {ok, {_, _, _, Leaderboard}} = lasp:read(LeaderboardId, undefined),
  
      %% Launch client processes.
      ClientList = clients(Self, LeaderboardId, Leaderboard),
  
      %% Initialize simulation.
      simulate(Self, ClientList),
  
      %% Wait until we receive num events.
      FinalResult = wait_for_events(1, ?NUM_EVENTS, 0),
  
      %% Terminate all clients.
      terminate(ClientList),
  
      %% Read the result and print it.
      {ok, FinalLeaderboard} = lasp:query(LeaderboardId),
      Final = orddict:to_list(FinalLeaderboard),
  
      %% Assert we got the right score.
      [{_, FinalResult}, {_, _}] = Final,
  
      io:format("Final Leaderboard: ~p", [Final]),
  
      ok.
  
  %% @doc Terminate any running clients gracefully issuing final
  %%      synchronization.
  terminate(ClientList) ->
      TerminateFun = fun(Pid) -> Pid ! terminate end,
      lists:map(TerminateFun, ClientList).
  
  %% @doc Launch a series of client processes.
  clients(Runner, LeaderboardId, Leaderboard) ->
      SpawnFun = fun(Id) -> spawn_link(?MODULE, client, [Runner, Id, LeaderboardId, Leaderboard]) end,
      lists:map(SpawnFun, lists:seq(1, ?NUM_CLIENTS)).
  
  %% @doc Client process; standard recurisve looping server.
  client(Runner, Id, LeaderboardId, Leaderboard0) ->
  
negative.code:             %% device.
              Pid ! {complete_game, random:uniform(100000000)}
      end,
      lists:foreach(Viewer, lists:seq(1, ?NUM_EVENTS)),
      {ok, State}.
  
  %% @doc Wait for all events to be delivered in the system.
  wait(#state{count_events=Count, num_events=NumEvents}=State) ->
      receive
          {event, _Score} ->
              case Count >= NumEvents of
                  true ->
                      {ok, State};
                  false ->
                      wait(State#state{count_events=Count + 1})
              end
      end.
  