def test_lagged_training_data_no_target_lags_future_covariates(self, config):
        """
        Tests that `create_lagged_training_data` correctly handles case without target lags and different
        future covariates lags.
        This test should always result in one training sample.
        Additionally, we test that:
        - future starts before the target but extends far enough to create one training sample
        - future shares same time as target
        - future starts after target but target extends far enough to create one training sample.
        """
        (
            output_chunk_shift,
            use_moving_windows,
            series_type,
            multi_models,
            cov_start_shift,
            cov_lag,
            stride,
        ) = config

        # adapt covariate start, length, and target length so that only 1 sample can be extracted
        target_length = 1 + output_chunk_shift + max(cov_start_shift, 0)
        cov_length = 1 - min(cov_start_shift, 0)
        if series_type == "integer":
            cov_start = 0 + cov_start_shift + cov_lag
            target = linear_timeseries(
                start=0, length=target_length, start_value=0, end_value=1
            )
            future = linear_timeseries(
                start=cov_start, length=cov_length, start_value=2, end_value=3
            )
        else:
            freq = pd.tseries.frequencies.to_offset("D")
            cov_start = pd.Timestamp("1/1/2000") + (cov_start_shift + cov_lag) * freq
            target = linear_timeseries(
                start=pd.Timestamp("1/1/2000"),
                length=target_length,
                start_value=0,
                end_value=1,
                freq=freq,
            )
            future = linear_timeseries(
                start=cov_start,
                length=cov_length,
                start_value=2,
                end_value=3,
                freq=freq,
            )

        # X comprises of first value of `target` (i.e. 0) and only value in `future`:
        expected_X = future[-1].all_values(copy=False)
        expected_y = target[-1].all_values(copy=False)
        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": None,
            "lags_past": None,
            "lags_future": [cov_lag],
            "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 without target lags and different
        future covariates lags.
        This test should always result in one training sample.
        Additionally, we test that:
        - future starts before the target but extends far enough to create one training sample
        - future shares same time as target
        - future starts after target but target extends far enough to create one training sample.
        
darts/tests/utils/tabularization/test_create_lagged_training_data.py