anchor.diff:  
   idle({run_suite, Callback, Config}, State) ->
       Servers = element(1, Config),
  -
       State2 = State#state{callback=Callback,
                            servers=Servers,
                            config=Config},
  +    ok = do_warmup(State2),
  +    {next_state, warmup, State2}.
   
  -    State3 = start_next_test(State2),
  +warmup(run_fulltest, State) ->
  +    ok = do_fulltest(State),
  +    {next_state, fulltest, State}.
   
  -    {next_state, running, State3}.
  -
  -running(next_server, #state{callback=CB, servers=[]}) ->
  -    CB(done),
  -    {next_state, idle, #state{}};
  -running(next_server, State) ->
  -    State2 = start_next_test(State),
  -    {next_state, running, State2}.
  +fulltest(next_server, #state{callback=CB, servers=[_|Rest]} = State) ->
  +    case Rest of
  +        [] ->
  +            CB(done),
  +            % we are out of servers to test, return to the idle state
  +            {next_state, idle, #state{}};
  +        Rest ->
  +            % pop off the current server and move to the warm up phase
  +            % for the next server
  +            State2 = State#state{servers=Rest},
  +            ok = do_warmup(State2),
  +            {next_state, warmup, State2}
  +    end.
   
   handle_event(Event, StateName, _State) ->
       % crash an unknown event
  
positive.code: handle_sync_event(Event, From, StateName, _State) ->
      % crash an unknown event
      exit({error, {invalid_event, {Event, From, StateName}}}).
  
  
  
  handle_info(_Info, StateName, State) ->
      {next_state, StateName, State}.
  
negative.code:                                             {port, Port},
                                              {clients, Clients},
                                              {seconds, Seconds}]]),
      ok = wsdemo_runner_fsm:run(Callback,
                                 DB, Host, Port, Clients, Seconds).
      
  do_warmup(State) ->
      WarmupCallback = fun(done) ->
                               % send the full test event
                               run_fulltest();
                          (cancel) ->
                               pass
                   end,
      [Server|_] = State#state.servers,
      do_atest(WarmupCallback, Server ++ "-warmup", State).
      
  
  do_fulltest(State) ->
      FulltestCB = fun(done) ->
                           % send the next_server event
                           next_server();
                      (cancel) ->
                           pass
                   end,
      [Server|_] = State#state.servers,
      do_atest(FulltestCB, Server, State).
  