def test_lagged_training_data_positive_lags(self, config):
        """
        Tests that `create_lagged_training_data` correctly handles case when
        `0` is included in `lags_future_covariates` (i.e. when we're using the values
        `future_covariates` at time `t` to predict the value of `target_series` at
        that same time point). This particular test checks this behaviour by using
        datetime index timeseries.
        """
        # Define `future` so that only value occurs one timestep *after*
        # the only possible label that can be extracted from `target_series`; the
        # only possible feature that can be created using these series utilises
        # the value of `future` one timestep after the time of the label (i.e. a lag
        # of `1` away from the only feature time):
        output_chunk_shift, use_moving_windows, series_type, multi_models, stride = (
            config
        )

        if series_type == "integer":
            target = linear_timeseries(
                start=0, length=2 + output_chunk_shift, start_value=0, end_value=1
            )
            future = linear_timeseries(
                start=target.end_time() - (output_chunk_shift - 1) * target.freq,
                length=1,
                start_value=1,
                end_value=2,
            )
        else:
            target = linear_timeseries(
                start=pd.Timestamp("1/1/2000"),
                length=2 + output_chunk_shift,
                start_value=0,
                end_value=1,
            )
            future = linear_timeseries(
                start=target.end_time() - (output_chunk_shift - 1) * target.freq,
                length=1,
                start_value=1,
                end_value=2,
            )
        # X comprises of first value of `target` (i.e. 0) and only value in `future`:
        expected_X = np.array([[[0.0], [1.0]]])
        expected_y = np.ones((1, 1, 1))
        expected_times = generate_index(
            start=target.end_time() - output_chunk_shift * target.freq,
            length=1,
            freq=target.freq,
        )
        if stride > 1:
            expected_X = expected_X[::-stride][::-1]
            expected_y = expected_y[::-stride][::-1]
            expected_times = expected_times[::-stride][::-1]

        # Check correctness for 'moving windows' and 'time intersection' methods, as
        # well as for different `multi_models` values:
        kwargs = {
            "expected_X": expected_X,
            "expected_y": expected_y,
            "expected_times_x": expected_times,
            "expected_times_y": expected_times,
            "target": target,
            "past_cov": None,
            "future_cov": future,
            "lags": [-1],
            "lags_past": None,
            "lags_future": [1],
            "output_chunk_length": 1,
            "output_chunk_shift": output_chunk_shift,
            "use_static_covariates": False,
            "multi_models": multi_models,
            "max_samples_per_ts": None,
            "use_moving_windows": use_moving_windows,
            "concatenate": True,
            "stride": stride,
        }

        self.helper_check_lagged_data(convert_lags_to_dict=False, **kwargs)

        if use_moving_windows:
            self.helper_check_lagged_data(convert_lags_to_dict=True, **kwargs)
        else:
            with pytest.raises(ValueError) as err:
                self.helper_check_lagged_data(convert_lags_to_dict=True, **kwargs)
            assert str(err.value).startswith(
                "`use_moving_windows=False` is not supported when any of the lags"
            )

        Tests that `create_lagged_training_data` correctly handles case when
        `0` is included in `lags_future_covariates` (i.e. when we're using the values
        `future_covariates` at time `t` to predict the value of `target_series` at
        that same time point). This particular test checks this behaviour by using
        datetime index timeseries.
        
darts/tests/utils/tabularization/test_create_lagged_training_data.py