anchor.diff:                  false ->
                       {noreply, remove_queued_request(Ref, State)}
               end
  +    end;
  +handle_info(reconnect, State) ->
  +    #state{address = Address, port = Port, connects = Connects} = State,
  +    case gen_tcp:connect(Address, Port,
  +                         [binary, {active, once}, {packet, 4}, {header, 1}]) of
  +        {ok, Sock} ->
  +            NewState = State#state{sock = Sock, connects = Connects+1, 
  +                                   reconnect_interval = ?FIRST_RECONNECT_INTERVAL},
  +            {noreply, dequeue_request(NewState)};
  +        {error, Reason} ->
  +            %% Update the failed count and reschedule a reconnection
  +            NewState = State#state{failed = orddict:update_counter(Reason, 1, State#state.failed)},
  +            {noreply, disconnect(NewState)}
       end;
   handle_info(_, State) ->
       {noreply, State}.
  
positive.code: 
  %% @private
  init([Address, Port]) ->
      case gen_tcp:connect(Address, Port,
                           [binary, {active, once}, {packet, 4}, {header, 1}]) of
          {ok, Sock} ->
              {ok, #state{address = Address, port = Port, sock = Sock, queue = queue:new()}};
          {error, Reason} ->
              {stop, Reason}
      end.
  
  %% @private
  handle_call({req, Msg, Timeout}, From, State) when State#state.pending =/= undefined ->
      {noreply, queue_request(new_request(Msg, From, Timeout), State)};
  handle_call({req, Msg, Timeout, Ctx}, From, State) when State#state.pending =/= undefined ->
      {noreply, queue_request(new_request(Msg, From, Timeout, Ctx), State)};
  handle_call({req, Msg, Timeout}, From, State) ->
      {noreply, send_request(new_request(Msg, From, Timeout), State)};
  
negative.code:                  %% Would really like this in a nested {setup, blah} structure
                   %% but eunit does not allow
                   {ok, Pid} = start_link(?TEST_IP, ?TEST_PORT),
                   pause_riak_pb_listener(),
                   Me = self(),
                   %% this request will block as
                   spawn(fun() -> Me ! {1, ping(Pid)} end),
                   %% this request should be queued as socket will not be created
                   spawn(fun() -> Me ! {2, ping(Pid)} end),
                   resume_riak_pb_listener(),
                   receive {1,Ping1} -> ?assertEqual(Ping1, pong) end,
                   receive {2,Ping2} -> ?assertEqual(Ping2, pong) end
               end)},
  