code: function getNext(event) {
          var cycleEvent,
              last = bench,
              async = isAsync(last);
  
          if (async) {
            last.off('complete', getNext);
            last.emit('complete');
          }
          // Emit "cycle" event.
          eventProps.type = 'cycle';
          eventProps.target = last;
          cycleEvent = Event(eventProps);
          options.onCycle.call(benches, cycleEvent);
  
          // Choose next benchmark if not exiting early.
          if (!cycleEvent.aborted && raiseIndex() !== false) {
            bench = queued ? benches[0] : result[index];
            if (isAsync(bench)) {
              delay(bench, execute);
            }
            else if (async) {
              // Resume execution if previously asynchronous but now synchronous.
              while (execute()) {}
            }
            else {
              // Continue synchronous execution.
              return true;
            }
          } else {
            // Emit "complete" event.
            eventProps.type = 'complete';
            options.onComplete.call(benches, Event(eventProps));
          }
          // When used as a listener `event.aborted = true` will cancel the rest of
          // the "complete" listeners because they were already called above and when
          // used as part of `getNext` the `return false` will exit the execution while-loop.
          if (event) {
            event.aborted = true;
          } else {
            return false;
          }
        }
docs: Fetches the next bench or executes `onComplete` callback.