anchor.diff:  
       client_keepalive_test,
       heartbeats_test,
  +    async_request_manager_memory_management_test,
   
   %%    socket_timeout_test,
       closing_last_connection_should_cancel_all_session_transfers_test
  
positive.code: 
      client_keepalive_test/1,
      heartbeats_test/1,
  
      socket_timeout_test/1,
      closing_last_connection_should_cancel_all_session_transfers_test/1
  
negative.code:     await_status_answer(ok, <<"fs2">>, 2).
  
  
  async_request_manager_memory_management_test(Config) ->
      [Worker1 | _] = ?config(op_worker_nodes, Config),
      SessionId = crypto:strong_rand_bytes(10),
  
      {ok, {Sock, _}} = fuse_test_utils:connect_via_macaroon(Worker1, [{active, true}], SessionId),
      {ok, AsyncReqManager} = rpc:call(
          Worker1, session_connections, get_async_req_manager, [SessionId]
      ),
  
      ReqId = <<1>>,
      ReportRequest = fun() ->
          gen_server2:cast(AsyncReqManager, {report_pending_req, self(), ReqId})
      end,
      WithholdHeartBeats = fun() ->
          gen_server2:call(AsyncReqManager, {withhold_heartbeats, self(), ReqId})
      end,
      ReportResponseSent = fun() ->
          gen_server2:call(AsyncReqManager, {response_sent, ReqId})
      end,
  
      lists:foreach(fun({Op1, Op2, Op3}) ->
          assert_empty_async_req_manager_state(AsyncReqManager),
          Op1(),
          Op2(),
          Op3(),
          assert_empty_async_req_manager_state(AsyncReqManager)
      end, [
          {ReportRequest, WithholdHeartBeats, ReportResponseSent},
          {WithholdHeartBeats, ReportResponseSent, ReportRequest},
          {WithholdHeartBeats, ReportRequest, ReportResponseSent}
      ]),
      ok = ssl:close(Sock).
  
  
  socket_timeout_test(Config) ->
      [Worker1 | _] = ?config(op_worker_nodes, Config),
      SID = ?config({session_id, {<<"user1">>, ?GET_DOMAIN(Worker1)}}, Config),
  