def test_lagged_training_data_comp_wise_lags(self, config):
        """
        Tests that `create_lagged_training_data` generate the expected values when the
        lags are component-specific over multivariate series.

        Note that this is supported only when use_moving_window=True.
        """
        output_chunk_shift, output_chunk_length, multi_models, series_type, stride = (
            config
        )

        lags_tg = {"target_0": [-4, -1], "target_1": [-4, -1]}
        lags_pc = [-3]
        lags_fc = {"future_0": [-1, 0], "future_1": [-2, 1]}

        if series_type == "integer":
            start_tg = 0
            start_pc = start_tg + 1
            start_fc = start_tg + 2
        else:
            start_tg = pd.Timestamp("2000-01-15")
            start_pc = pd.Timestamp("2000-01-16")
            start_fc = pd.Timestamp("2000-01-17")

        # length = max lag - min lag + 1 = -1 + 4 + 1 = 4
        target = helper_create_multivariate_linear_timeseries(
            n_components=2,
            components_names=["target_0", "target_1"],
            length=4 + output_chunk_shift + output_chunk_length,
            start=start_tg,
        )
        # length = max lag - min lag + 1 = -3 + 3 + 1 = 1
        past = (
            helper_create_multivariate_linear_timeseries(
                n_components=2,
                components_names=["past_0", "past_1"],
                length=1,
                start=start_pc,
            )
            + 100
        )
        # length = max lag - min lag + 1 = 1 + 2 + 1 = 4
        future = (
            helper_create_multivariate_linear_timeseries(
                n_components=2,
                components_names=["future_0", "future_1"],
                length=4 + output_chunk_shift + output_chunk_length,
                start=start_fc,
            )
            + 200
        )

        # extremes lags are manually computed, similarly to the model.lags attribute
        feats_times = self.get_feature_times(
            target,
            past,
            future,
            [-4, -1],  # min, max target lag
            [-3],  # unique past lag
            [-2, 1],  # min, max future lag
            output_chunk_length,
            None,
            output_chunk_shift,
            stride=stride,
        )

        # reorder the features to obtain target_0_lag-4, target_1_lag-4, target_0_lag-1, target_1_lag-1
        X_target = [
            self.construct_X_block(
                target["target_0"], feats_times, lags_tg["target_0"][0:1]
            ),
            self.construct_X_block(
                target["target_1"], feats_times, lags_tg["target_1"][0:1]
            ),
            self.construct_X_block(
                target["target_0"], feats_times, lags_tg["target_0"][1:2]
            ),
            self.construct_X_block(
                target["target_1"], feats_times, lags_tg["target_1"][1:2]
            ),
        ]
        # single lag for all the components, can be kept as is
        X_past = [
            self.construct_X_block(past[name], feats_times, lags_pc)
            for name in ["past_0", "past_1"]
        ]
        # reorder the features to obtain future_1_lag-2, future_0_lag-1, future_0_lag0, future_1_lag1
        X_future = [
            self.construct_X_block(
                future["future_1"], feats_times, lags_fc["future_1"][0:1]
            ),
            self.construct_X_block(
                future["future_0"], feats_times, lags_fc["future_0"][0:1]
            ),
            self.construct_X_block(
                future["future_0"], feats_times, lags_fc["future_0"][1:2]
            ),
            self.construct_X_block(
                future["future_1"], feats_times, lags_fc["future_1"][1:2]
            ),
        ]
        all_X = X_target + X_past + X_future
        expected_X = np.concatenate(all_X, axis=1)[:, :, np.newaxis]
        expected_y = self.create_y(
            target,
            feats_times,
            output_chunk_length,
            multi_models,
            output_chunk_shift,
        )[:, :, np.newaxis]
        if stride > 1:
            expected_X = expected_X[::-stride][::-1]
            expected_y = expected_y[::-stride][::-1]
            feats_times = feats_times[::-stride][::-1]

        # lags are already in dict format
        self.helper_check_lagged_data(
            convert_lags_to_dict=True,
            expected_X=expected_X,
            expected_y=expected_y,
            expected_times_x=feats_times,
            expected_times_y=feats_times,
            target=target,
            past_cov=past,
            future_cov=future,
            lags=lags_tg,
            lags_past=lags_pc,
            lags_future=lags_fc,
            output_chunk_length=output_chunk_length,
            output_chunk_shift=output_chunk_shift,
            use_static_covariates=False,
            multi_models=multi_models,
            max_samples_per_ts=None,
            use_moving_windows=True,
            concatenate=True,
            stride=stride,
        )

        Tests that `create_lagged_training_data` generate the expected values when the
        lags are component-specific over multivariate series.

        Note that this is supported only when use_moving_window=True.
        
darts/tests/utils/tabularization/test_create_lagged_training_data.py