anchor.diff:  -spec watch(torrent_id(), term(), pieceset()) ->
       {ok, reference(), [pos_integer()]}.
   watch(TorrentID, Tag, Pieceset) ->
  -    watch(TorrentID, Tag, Pieceset, 0).
  +    watch(TorrentID, Tag, Pieceset, 5000).
   
   
   %% @doc Receive updates to changes in scarcity
  
positive.code:     {ok, Pid} = ?scarcity:start_link(1),
      ?assertEqual(Pid, ?scarcity:lookup_scarcity_server(1)).
  
  initial_ordering_case() ->
      {ok, _} = ?scarcity:start_link(2),
      {ok, Order} = ?scarcity:get_order(2, pieces([0,1,2,3,4,5,6,7])),
      ?assertEqual([0,1,2,3,4,5,6,7], Order).
  
  empty_ordering_case() ->
      {ok, _} = ?scarcity:start_link(3),
      {ok, Order} = ?scarcity:get_order(3, pieces([])),
      ?assertEqual([], Order).
  
  init_pieceset_case() ->
      {ok, _} = ?scarcity:start_link(4),
      ?assertEqual(ok, ?scarcity:add_peer(4, pieces([]))).
  
  one_available_case() ->
      {ok, _} = ?scarcity:start_link(5),
      ok = ?scarcity:add_peer(5, pieces([])),
      ?assertEqual(ok, ?scarcity:add_piece(5, 0, pieces([0]))),
      Pieces  = pieces([0,1,2,3,4,5,6,7]),
      {ok, Order} = ?scarcity:get_order(5, Pieces),
      ?assertEqual([1,2,3,4,5,6,7,0], Order).
  
  decrement_on_exit_case() ->
      {ok, _} = ?scarcity:start_link(6),
      Main = self(),
      Pid = spawn_link(fun() ->
          ok = ?scarcity:add_peer(6, pieces([0])),
  
negative.code:             ?assertEqual(make_ref(), Other)
      end.
  
  add_piece_update_case({N, Time, Pid}) ->
      {ok, Ref, _} = ?scarcity:watch(9, nine, pieces([0,2,4,6])),
      ok = ?scarcity:add_peer(9, pieces([])),
      ok = ?scarcity:add_piece(9, 2, pieces([2])),
      ?assertEqual(5000, ?timer:step(Time)),
      ?assertEqual(1, ?timer:fire(Time)),
      receive
          {scarcity, Ref, nine, Order} ->
              ?assertEqual([0,4,6,2], Order)
      end.
  
  aggregate_update_case({N, Time, Pid}) ->
      {ok, Ref, _} = ?scarcity:watch(N, aggr, pieces([0,2,4,6])),
      %% Assert that peer is limited by default
      ?assertEqual(5000, ?timer:step(Time)),
      ok = ?scarcity:add_peer(N, pieces([2])),
      ok = ?scarcity:add_piece(N, 0, pieces([0,2])),
      ?assertEqual(1, ?timer:fire(Time)),
      receive
          {scarcity, Ref, aggr, [4,6,0,2]} -> ok;
          Other -> ?assertEqual(make_ref(), Other)
          after 0 -> ?assert(false)
      end.
  
  noaggregate_update_case({N, Time, Pid}) ->
      {ok, Ref, _} = ?scarcity:watch(N, aggr, pieces([0,2,4,6])),
      %% Assert that peer is limited by default
      ?assertEqual(5000, ?timer:step(Time)),
      ok = ?scarcity:add_peer(N, pieces([2])),
      ?assertEqual(1, ?timer:fire(Time)),
      receive
          {scarcity, Ref, aggr, [0,4,6,2]} -> ok;
          O1 -> ?assertEqual(make_ref(), O1)
          after 0 -> ?assert(false)
      end,
      ok = ?scarcity:add_piece(N, 0, pieces([0,2])),
      ?assertEqual(1, ?timer:fire(Time)),
      receive
          {scarcity, Ref, aggr, [4,6,0,2]} -> ok;
          O2 -> ?assertEqual(make_ref(), O2)
          after 0 -> ?assert(false)
      end.
  
  
  
  peer_exit_update_case({N, Time, _}) ->
      Main = self(),
      Pid = spawn_link(fun() ->
          ok = ?scarcity:add_peer(10, pieces([0,1,2,3])),
  