Self ! {server_port, Port},

                      Self ! {server_port, Port},

    Port = receive
        {server_port, P} -> P
    end,

    Port =
        receive
            {server_port, P} ->
                P
        end,

    ClientPid =
        spawn_link(fun() ->
                      {ok, AliceConn} =
                          enoise_cable:connect("localhost", Port, [{keypair, AliceKeys}, {psk, PSK}]),
                      Self ! client_ready,

    spawn_link(fun() ->
                  {ok, AliceConn} =
                      enoise_cable:connect("localhost", Port, [{keypair, AliceKeys}, {psk, PSK}]),
                  Self ! client_ready,

                      % Test 1: Send small message
                      Msg1 = <<"Hello, Cable!">>,
                      ok = enoise_cable:send(AliceConn, Msg1),

                  % Test 1: Send small message
                  Msg1 = <<"Hello, Cable!">>,
                  ok = enoise_cable:send(AliceConn, Msg1),

                      % Test 3: Send large message
                      LargeMsg = binary:copy(<<"X">>, 100000),
                      ok = enoise_cable:send(AliceConn, LargeMsg),

                  % Test 3: Send large message
                  LargeMsg = binary:copy(<<"X">>, 100000),
                  ok = enoise_cable:send(AliceConn, LargeMsg),

                      % Test 2: Wait for message from Bob and reply
                      receive
                          {cable_transport, _, Msg2} ->
                              % Echo back for confirmation in main test
                              Self ! {client_received, Msg2},
                              ok
                      after 5000 -> Self ! {client_error, timeout_recv}
                      end,

                  % Test 2: Wait for message from Bob and reply
                  receive
                      {cable_transport, _, Msg2} ->
                          % Echo back for confirmation in main test
                          Self ! {client_received, Msg2},
                          ok
                  after 5000 -> Self ! {client_error, timeout_recv}
                  end,

                      % Cleanup
                      enoise_cable:close(AliceConn)
                   end),

                  % Cleanup
                  enoise_cable:close(AliceConn)
               end),

wait_until_closed(Pid, Timeout) ->
    Ref = erlang:monitor(process, Pid),
    receive
        {'DOWN', Ref, process, Pid, _} ->
            ok
    after Timeout ->
        error({process_not_down, Pid})
    end.

-export([listen/1, listen/2, accept/1, accept/2, connect/3, send/2, close/1, controlling_process/2, port/1]).

-export([
    listen/1, listen/2,
    accept/1, accept/2,
    connect/3,
    send/2,
    close/1,
    controlling_process/2,
    port/1
]).

-define(DEFAULT_PSK, hex:hexstr_to_bin("0808080808080808080808080808080808080808080808080808080808080808")).

-define(DEFAULT_PSK,
    hex:hexstr_to_bin("0808080808080808080808080808080808080808080808080808080808080808")
).

    mode,                % 'listener' or 'connection'
    socket,              % TCP socket (listen socket for listener, connection socket for connection)
    enoise_conn,         % enoise connection state (undefined for listener)
    handler_pid          % Process to send messages to (undefined for listener)

    % 'listener' or 'connection'
    mode,
    % TCP socket (listen socket for listener, connection socket for connection)
    socket,
    % enoise connection state (undefined for listener)
    enoise_conn,
    % Process to send messages to (undefined for listener)
    handler_pid

-spec connect(string() | inet:ip_address(), inet:port_number(), proplists:proplist()) -> {ok, pid()} | {error, term()}.

-spec connect(string() | inet:ip_address(), inet:port_number(), proplists:proplist()) ->
    {ok, pid()} | {error, term()}.

    io:format(user, "[enoise_cable SERVER ~p] New gen_server accepting TCP connection...~n", [self()]),

    io:format(user, "[enoise_cable SERVER ~p] New gen_server accepting TCP connection...~n", [
        self()
    ]),

handle_call({accept_connection, Opts, HandlerPid}, From, State = #state{mode = listener, socket = ListenSocket}) ->

handle_call(
    {accept_connection, Opts, HandlerPid},
    From,
    State = #state{mode = listener, socket = ListenSocket}
) ->

handle_info({noise, ReceivedEConn, Data}, State = #state{
    enoise_conn = StateEConn,
    handler_pid = Handler
}) ->

handle_info(
    {noise, ReceivedEConn, Data},
    State = #state{
        enoise_conn = StateEConn,
        handler_pid = Handler
    }
) ->