anchor.diff:  -spec enter_loop( string() | binary(),
                     [ string() | binary() ],
                     { pid(), reference() } ) ->
  -    { stopped, { pid(), reference() } }.
  +    { { stopped, pid() }, { pid(), reference() } }.
   enter_loop( Driver, Parameters, { Pid, Tag } ) ->
  +    % FIXME - propagate error
       { ok, Port } = start_driver( Driver, Parameters ),
  -    Pid ! { started, { self(), Tag } },
  +    Pid ! { { started, { ok, self() } }, { self(), Tag } },
       receive_loop( Port ).
   
  --spec receive_loop( port() ) -> { stopped, { pid(), reference() } }.
  +-spec receive_loop( port() ) -> { { stopped, pid() }, { pid(), reference() } }.
   receive_loop( Port ) ->
       receive
           { stop, { Pid, Tag } } ->
  +            % FIXME - error propagation
               stop_driver( Port ),
  -            Pid ! { stopped, { self(), Tag } };
  +            Pid ! { { stopped, { ok, self() } }, { self(), Tag } };
   
           { { get_event, Event }, { Pid, Tag } } ->
               Pid ! { { event, get_event( Port, Event ) }, { self(), Tag } },
  
positive.code: 
  start_test_server( Name ) ->
      start( test_driver_path( Name ), [] ).
  
  
  mock_lurch_os() ->
  
negative.code:     { self(), make_ref() }.
  
  -spec wait_start( { pid(), reference() } ) -> { ok, pid() } | { error, term() }.
  wait_start( Id ) ->
      wait( Id, started ).
  
  -spec wait_stop( { pid(), reference() } ) -> ok | { error, term() }.
  wait_stop( Id ) ->
      case wait( Id, stopped ) of
          { ok, _ } -> ok;
          E -> E
      end.
  
  -spec wait_event( { pid(), reference() } ) -> { event, term() } | { error, term() }.
  wait_event( Id ) ->
      wait( Id, event ).
  
  -spec wait( { pid(), reference() }, term() ) ->
      { ok, term() } | { error, term() }.
  wait( Id, Type ) ->
      receive
          { { Type, Result }, Id } -> Result;
          Error -> Error
      after
          ?DRIVER_TIMEOUT -> { error, timeout }
      end.
  