anchor.diff:  stop( Pid ) ->
       { From, To } = from_to( self(), Pid ),
       Pid ! { stop, From },
  -    receive
  -        { stopped, To } -> ok
  -    after
  -        ?DRIVER_TIMEOUT -> { error, timeout }
  -    end.
  +    wait_stop( To ).
  +
  +-spec stop_async( pid() ) -> { ok, { pid(), reference() } } | { error, timeout }.
  +stop_async( Pid ) ->
  +    { From, To } = from_to( self(), Pid ),
  +    Pid ! { stop, From },
  +    { ok, To }.
   
   -spec request_event( pid(), string() ) -> { ok, term() } | { error, timeout }.
   request_event( Pid, Event ) ->
       { From, To } = from_to( self(), Pid ),
       Pid ! { { get_event,  Event }, From },
  -    receive
  -        { { event, Result }, To } -> Result
  -    after
  -        ?DRIVER_TIMEOUT -> { error, timeout }
  -    end.
  +    wait_event( To ).
   
   -spec request_event_async( pid(), string() ) -> { ok, { pid(), reference() } }.
   request_event_async( Pid, Event ) ->
  
positive.code: -spec enter_loop( string() | binary(),
                    [ string() | binary() ],
                    { pid(), reference() } ) ->
      { stopped, { pid(), reference() } }.
  enter_loop( Driver, Parameters, { Pid, Tag } ) ->
      { ok, Port } = start_driver( Driver, Parameters ),
      Pid ! { started, { self(), Tag } },
      receive_loop( Port ).
  
  -spec receive_loop( port() ) -> { stopped, { pid(), reference() } }.
  receive_loop( Port ) ->
      receive
          { stop, { Pid, Tag } } ->
              stop_driver( Port ),
              Pid ! { stopped, { self(), Tag } };
  
          { { get_event, Event }, { Pid, Tag } } ->
              Pid ! { { event, get_event( Port, Event ) }, { self(), Tag } },
  
negative.code: 
  start_test_server( Name ) ->
      start( test_driver_path( Name ), [] ).
  
  start_test_server_async( Name ) ->
      start_async( test_driver_path( Name ), [] ).
  
  
  mock_lurch_os() ->
  