code: def test_torch_auto_start_multiple_no_cov(self, model_config):
      forecast_hrz = 10
      model_cls, kwargs, bounds, _ = model_config
      model = model_cls(
          random_state=0,
          **kwargs,
      )
      model.fit(self.ts_pass_train)
  
      # check historical forecasts for several time series,
      # retrain True and overlap_end False
      forecasts = model.historical_forecasts(
          series=[self.ts_pass_val, self.ts_pass_val],
          forecast_horizon=forecast_hrz,
          stride=1,
          retrain=True,
          overlap_end=False,
      )
      assert (
          len(forecasts) == 2
      ), f"Model {model_cls} did not return a list of historical forecasts"
      # If retrain=True and overlap_end=False, as ts has 72 values, we can only forecast
      # (target length)-(training length=input_chunk_length+output_chunk_length) - (horizon - 1)
      # indeed we start to predict after the first trainable point (input_chunk_length+output_chunk_length)
      # and we stop in this case (overlap_end=False) at the end_time:
      # target.end_time() - (horizon - 1) * target.freq
  
      # explanation:
      # (bounds): train sample length
      # (horizon - 1): with overlap_end=False, if entire horizon is available (overlap_end=False),
      # we can predict 1
      theorical_forecast_length = (
          self.ts_val_length
          - (bounds[0] + bounds[1])
          - (forecast_hrz - 1)
      )
      assert (
          len(forecasts[0])
          == len(forecasts[1])
          == theorical_forecast_length
      ), (
          f"Model {model_cls} does not return the right number of historical forecasts in the case of "
          f"retrain=True and overlap_end=False. "
          f"Expected {theorical_forecast_length}, got {len(forecasts[0])} and {len(forecasts[1])}"
      )
  
      model = model_cls(
          random_state=0,
          **kwargs,
      )
  
      model.fit(self.ts_pass_train)
      # check historical forecasts for several time series,
      # retrain True and overlap_end True
      forecasts = model.historical_forecasts(
          series=[self.ts_pass_val, self.ts_pass_val],
          forecast_horizon=forecast_hrz,
          stride=1,
          retrain=True,
          overlap_end=True,
      )
  
      assert (
          len(forecasts) == 2
      ), f"Model {model_cls} did not return a list of historical forecasts"
      theorical_forecast_length = (
          self.ts_val_length
          - (bounds[0] + bounds[1])  # train sample length
          + 1  # with overlap_end=True, we are not restricted by the end of the series or horizon
      )
      assert (
          len(forecasts[0])
          == len(forecasts[1])
          == theorical_forecast_length
      )
  
      model = model_cls(
          random_state=0,
          **kwargs,
      )
      model.fit(self.ts_pass_train)
      # check historical forecasts for several time series,
      # retrain False and overlap_end False
      forecasts = model.historical_forecasts(
          series=[self.ts_pass_val, self.ts_pass_val],
          forecast_horizon=forecast_hrz,
          stride=1,
          retrain=False,
          overlap_end=False,
      )
  
      assert (
          len(forecasts) == 2
      ), f"Model {model_cls} did not return a list of historical forecasts"
      theorical_forecast_length = (
          self.ts_val_length
          - bounds[0]  # prediction input sample length
          - (
              forecast_hrz - 1
          )  # overlap_end=False -> if entire horizon is available, we can predict 1
      )
      assert (
          len(forecasts[0])
          == len(forecasts[1])
          == theorical_forecast_length
      )
      assert (
          forecasts[0].end_time()
          == forecasts[1].end_time()
          == self.ts_pass_val.end_time()
      )
  
      model = model_cls(
          random_state=0,
          **kwargs,
      )
      model.fit(self.ts_pass_train)
      # check historical forecasts for several time series,
      # retrain False and overlap_end True
      forecasts = model.historical_forecasts(
          series=[self.ts_pass_val, self.ts_pass_val],
          forecast_horizon=forecast_hrz,
          stride=1,
          retrain=False,
          overlap_end=True,
      )
  
      assert (
          len(forecasts) == 2
      ), f"Model {model_cls} did not return a list of historical forecasts"
      theorical_forecast_length = (
          self.ts_val_length
          - bounds[0]  # prediction input sample length
          + 1  # overlap_end=True -> last possible prediction start is one step after end of target
      )
      assert (
          len(forecasts[0])
          == len(forecasts[1])
          == theorical_forecast_length
      )
      assert (
          forecasts[0].end_time()
          == forecasts[1].end_time()
          == self.ts_pass_val.end_time()
          + forecast_hrz * self.ts_pass_val.freq
      )
  
imports: import itertools
  from itertools import product
  import numpy
  import pandas
  import pytest
  import darts
  from darts import TimeSeries, concatenate
  from darts.dataprocessing.transformers import Scaler
  from darts.datasets import AirPassengersDataset
  from darts.logging import get_logger
  from darts.models import ARIMA, AutoARIMA, CatBoostModel, LightGBMModel, LinearRegressionModel, NaiveSeasonal, NotImportedModule
  from darts.tests.conftest import tfm_kwargs
  from darts.utils import timeseries_generation
label_desc: Use image node_id 14 for calling the TestHistoricalforecast obj's underlying member method code with example usage: obj.test_torch_auto_start_multiple_no_cov(model_config) without return types