def test_same_result_output_chunk_shift(self, config):
        """Tests that a model with that uses an output shift gets identical results for a multi-model
        without a shift. This only applies to the regressors that overlap.

        Example models:
        * non-shifted model with ocl=5, shift=0, multi_models=True
        * shifted model with ocl=2, shift=3, multi_models=True

        The 4th and 5th regressors from the non-shifted models should generate identical results as the 1st
        and 2nd regressor of the shifted model.
        """
        list_lags, multiple_series, output_chunk_shift, ocl_shifted = config
        ocl = output_chunk_shift + ocl_shifted
        max_forecast = ocl
        series, past_cov, future_cov = self.helper_generate_input_series_from_lags(
            list_lags,
            {},
            multiple_series,
            output_chunk_shift,
            max_forecast,
            output_chunk_length=ocl,
        )

        model = LinearRegressionModel(
            **list_lags, output_chunk_shift=0, output_chunk_length=ocl
        )

        # with output shift, future lags are shifted
        model_shift = LinearRegressionModel(
            **list_lags,
            output_chunk_shift=output_chunk_shift,
            output_chunk_length=ocl_shifted,
        )
        # adjusting the future lags should give identical models to non-shifted
        list_lags_adj = deepcopy(list_lags)
        # this loop works for both component-specific and non-component-specific future lags
        if "lags_future_covariates" in list_lags_adj:
            if isinstance(list_lags_adj["lags_future_covariates"], dict):
                for key in list_lags_adj["lags_future_covariates"]:
                    list_lags_adj["lags_future_covariates"][key] = [
                        lag_ - output_chunk_shift
                        for lag_ in list_lags_adj["lags_future_covariates"][key]
                    ]
            else:
                list_lags_adj["lags_future_covariates"] = [
                    lag_ - output_chunk_shift
                    for lag_ in list_lags_adj["lags_future_covariates"]
                ]
        model_shift_adj = LinearRegressionModel(
            **list_lags_adj,
            output_chunk_shift=output_chunk_shift,
            output_chunk_length=ocl_shifted,
        )

        if not multiple_series:
            series = [series]
            past_cov = [past_cov] if past_cov is not None else past_cov
            future_cov = [future_cov] if future_cov is not None else future_cov

        for m_ in [model, model_shift, model_shift_adj]:
            m_.fit(
                series=series,
                past_covariates=past_cov,
                future_covariates=future_cov,
            )

        pred = model.predict(
            ocl,
            series=series,
            past_covariates=past_cov,
            future_covariates=future_cov,
        )
        pred_shift = model_shift.predict(
            ocl_shifted,
            series=series,
            past_covariates=past_cov,
            future_covariates=future_cov,
        )
        pred_shift_adj = model_shift_adj.predict(
            ocl_shifted,
            series=series,
            past_covariates=past_cov,
            future_covariates=future_cov,
        )
        # expected shifted start is `output_chunk_shift` steps after non-shifted pred start
        for s_, pred_, pred_shift_, pred_shift_adj_ in zip(
            series, pred, pred_shift, pred_shift_adj
        ):
            pred_shift_start_expected = (
                s_.end_time() + (1 + output_chunk_shift) * s_.freq
            )
            assert pred_.start_time() == s_.end_time() + pred_.freq
            assert (
                pred_.end_time()
                == pred_shift_start_expected + (ocl_shifted - 1) * pred_.freq
            )
            assert pred_shift_.start_time() == pred_shift_start_expected
            assert (
                pred_shift_.end_time()
                == pred_shift_start_expected + (ocl_shifted - 1) * pred_shift_.freq
            )
            assert pred_shift_.time_index.equals(pred_shift_adj_.time_index)

            if "lags_future_covariates" not in list_lags:
                # without future lags, all lags should be identical between shift and non-shifted model
                np.testing.assert_almost_equal(
                    pred_[-ocl_shifted:].all_values(copy=False),
                    pred_shift_.all_values(copy=False),
                )
            else:
                # without future lags, the shifted model also shifts future lags
                with pytest.raises(AssertionError):
                    np.testing.assert_almost_equal(
                        pred_[-ocl_shifted:].all_values(copy=False),
                        pred_shift_.all_values(copy=False),
                    )

            # with adjusted future lags, the models should be identical
            np.testing.assert_almost_equal(
                pred_[-ocl_shifted:].all_values(copy=False),
                pred_shift_adj_.all_values(copy=False),
            )
Tests that a model with that uses an output shift gets identical results for a multi-model
        without a shift. This only applies to the regressors that overlap.

        Example models:
        * non-shifted model with ocl=5, shift=0, multi_models=True
        * shifted model with ocl=2, shift=3, multi_models=True

        The 4th and 5th regressors from the non-shifted models should generate identical results as the 1st
        and 2nd regressor of the shifted model.
        
darts/tests/models/forecasting/test_sklearn_models.py