async executeStrategyBacktest(strategyName, exchange, symbol, options, lastSignal, lastSignalEntry) {
    const results = await this.getTaResult(strategyName, exchange, symbol, options);
    if (!results || Object.keys(results).length === 0) {
      return {};
    }

    const price = results._candle ? results._candle.close : undefined;

    let context;
    if (lastSignal && lastSignalEntry && price) {
      // provide a suitable value; its just backtesting
      const amount = lastSignal === 'short' ? -1 : 1;

      context = StrategyContext.createFromPosition(
        options,
        new Ticker(exchange, symbol, undefined, price, price),
        new Position(
          symbol,
          lastSignal,
          amount,
          CommonUtil.getProfitAsPercent(lastSignal, price, lastSignalEntry),
          undefined,
          lastSignalEntry
        ),
        true
      );
    } else {
      context = StrategyContext.create(options, new Ticker(exchange, symbol, undefined, price, price), true);
    }

    context.lastSignal = lastSignal;

    const indicatorPeriod = new IndicatorPeriod(context, results);

    const strategy = this.getStrategies().find(strategy => strategy.getName() === strategyName);
    const strategyResult = await strategy.period(indicatorPeriod, options);

    if (typeof strategyResult !== 'undefined' && !(strategyResult instanceof SignalResult)) {
      throw `Invalid strategy return:${strategyName}`;
    }

    const result = {
      price: price,
      columns: this.getCustomTableColumnsForRow(strategyName, strategyResult ? strategyResult.getDebug() : {})
    };

    if (strategyResult) {
      result.result = strategyResult;
    }

    return result;
  }
@param strategyName
@param exchange
@param symbol
@param options
@param lastSignal
@param lastSignalEntry
@returns {Promise<array>}