anchor.diff:      { noreply, S2 } = handle_cast( { poll_device_event, invalid, Event }, S0 ),
       { noreply, S3 } = handle_cast( { poll_device_event, DeviceId, invalid }, S0 ),
   
  -    [ { "valid device and event", ?_assertEqual( [ Tag ], S1#state.polls ) }
  +    [ { "valid device and event",
  +        ?_assertEqual( { ok, { DeviceId, poll } },
  +                       orddict:find( Tag, S1#state.asyncs ) ) }
       , { "invalid device", ?_assertEqual( S0, S2 ) }
       , { "invalid event", ?_assertEqual( S0, S3 ) }
  +    ].
  +
  +test_start_response( _Pid ) ->
  +    DeviceId = make_ref(),
  +    Tag = make_ref(),
  +    Device = #device{ pid = DeviceId },
  +    Devices = orddict:store( DeviceId, Device, orddict:new() ),
  +
  +    Asyncs = orddict:store( Tag, { DeviceId, start }, orddict:new() ),
  +
  +    S0 = #state{ devices = Devices, asyncs = Asyncs },
  +
  +    { noreply, S1 } = handle_info( { ok, Tag }, S0 ),
  +    { noreply, S2 } = handle_info( { { error, reason }, Tag }, S0 ),
  +
  +    [ { "async purged",
  +        ?_assertEqual( error, orddict:find( Tag, S1#state.asyncs ) ) }
  +    , { "start result ok", ?_assertEqual(
  +            running,
  +            (orddict:fetch( DeviceId, S1#state.devices ))#device.state ) }
  +    , { "async purged",
  +        ?_assertEqual( error, orddict:find( Tag, S2#state.asyncs ) ) }
  +    , { "start result error",
  +        ?_assertEqual( error, orddict:find( DeviceId, S2#state.devices ) ) }
       ].
   
   
  
positive.code:     { noreply, State }.
  
  
  handle_info( _Info, State ) ->
      { noreply, State }.
  
  
  terminate( _Reason, _State ) ->
  
negative.code:     Driver = proplists:get_value(driver, Configuration),
      Parameters = proplists:get_value(parameters, Configuration),
      Events = proplists:get_value(events, Configuration, []),
      { ok, Pid, Tag } = lurch_dev:start_async( Driver, Parameters ),
      Device = #device{ pid = Pid
                      , driver = Driver
                      , parameters = Parameters
                      , events = Events
                      , state = starting },
      Devices = orddict:store( Pid, Device, State#state.devices ),
      Asyncs = orddict:store( Tag, { Pid, start } , State#state.asyncs ),
      NewState = State#state{ devices = Devices, asyncs = Asyncs },
      { reply, { ok, Device#device.pid }, NewState };
  
  handle_call( { stop_device, Pid }, _From, State ) ->
      case orddict:find( Pid, State#state.devices ) of
          { ok, _Device } ->
              { ok, Tag } = lurch_dev:stop_async( Pid ),
              Asyncs = orddict:store( Tag, { Pid, stop }, State#state.asyncs ),
              { reply, ok, State#state{ asyncs = Asyncs } };
          error -> {reply, { error, no_such_device }, State }
      end;
  
  