anchor.diff:      {Pid, NewState} = get_vnode_pid(State),
       gen_fsm:send_event(Pid, Req),
       {reply, {ok, Pid}, NewState};
  -handle_call(overloaded, _From, State=#state{check_counter=Counter,
  -                                            check_request_interval=RequestInterval,
  -                                            check_mailbox=Mailbox,
  -                                            check_request=RequestState,
  +handle_call(overloaded, _From, State=#state{check_mailbox=Mailbox,
                                               check_threshold=Threshold}) ->
  -    Counter2 = Counter + 1,
  -    %% Mailbox2 count logic extracted from handle_proxy
  -    Mailbox2 = case Counter2 of
  -                   RequestInterval ->
  -                       %% we can adjust our mailbox estimate accordingly.
  -                       case RequestState of
  -                           undefined ->
  -                               Mailbox + 2;
  -                           _ ->
  -                               Mailbox + 1
  -                       end;
  -                   _ ->
  -                       Mailbox + 1
  -               end,
  -    Result = (Mailbox2 > Threshold),
  +    Result = (Mailbox > Threshold),
       {reply, Result, State};
   handle_call(_Msg, _From, State) ->
       {reply, ok, State}.
  
positive.code:             %% we can adjust our mailbox estimate accordingly.
              case RequestState of
                  undefined ->
                      Mailbox2 = Mailbox + 2,
                      RequestState2 = send_proxy_ping(Pid, Mailbox2);
                  _ ->
                      Mailbox2 = Mailbox + 1,
                      RequestState2 = RequestState
              end,
              Counter3 = Counter2;
          Interval ->
              %% Time to directly check the mailbox size. This operation may
  
negative.code:              exit(ProxyPid, kill)
       end,
       [
        fun({_VnodePid, ProxyPid}) ->
                {"should not discard in normal operation", timeout, 60,
                 fun() ->
                         ToSend = ?DEFAULT_OVERLOAD_THRESHOLD * 2,
                         [ProxyPid ! hello || _ <- lists:seq(1, ToSend)],
  
                         %% synchronize on the proxy and the mailbox
                         {ok, ok} = gen:call(ProxyPid, '$vnode_proxy_call', sync, infinity),
                         ProxyPid ! {get_count, self()},
                         receive
                             {count, Count} ->
                                 %% Every ReqInterval happy proxy will do a ping/pong
                                 %%  2500 ->  2501
                                 %%  5000 ->  5002
                                 %%  7500 ->  7503
                                 %% 10000 -> 10004 etc
                                 %% ToSend messages + 4 vnode_proxy_pings
                                 PingReqs = 1 + % for first request intarval
                                     ToSend div ?DEFAULT_CHECK_INTERVAL,
                                 ?assertEqual(ToSend+PingReqs, Count)
                         end
                 end
                }
        end,
        fun({VnodePid, ProxyPid}) ->
                {"should discard during overflow", timeout, 60,
                 fun() ->
                         VnodePid ! block,
                         [ProxyPid ! hello || _ <- lists:seq(1, 50000)],
                         %% synchronize on the mailbox - no-op that hits msg catchall
                         Reply = gen:call(ProxyPid, '$vnode_proxy_call', sync, infinity),
                         ?assertEqual({ok, ok}, Reply),
                         VnodePid ! unblock,
  