def test_lagged_prediction_data_unequal_freq(self, series_type):
        """
        Tests that `create_lagged_prediction_data` produces `X` and `times`
        outputs that are consistent with those generated by using the helper
        functions `get_feature_times` and `construct_X_block`. Consistency is
        checked over all of the combinations of parameter values specified by
        `self.target_lag_combos`, `self.covariates_lag_combos`, and
        `self.max_samples_per_ts_combos`.

        This particular test uses timeseries with time indices of unequal
        frequencies. Since all of the timeseries are *not* of the same frequency,
        the implementation of the 'time intersection' method is being tested here.
        """
        # Define range index timeseries - each has different number of components,
        # different start times, different lengths, different values, and of
        # different frequencies:
        if series_type == "integer":
            target = self.create_multivariate_linear_timeseries(
                n_components=2, start_value=0, end_value=10, start=2, end=20, freq=1
            )
            past = self.create_multivariate_linear_timeseries(
                n_components=3, start_value=10, end_value=20, start=4, end=23, freq=2
            )
            future = self.create_multivariate_linear_timeseries(
                n_components=4, start_value=20, end_value=30, start=6, end=26, freq=3
            )
        else:
            target = self.create_multivariate_linear_timeseries(
                n_components=2,
                start_value=0,
                end_value=10,
                start=pd.Timestamp("1/2/2000"),
                end=pd.Timestamp("1/20/2000"),
                freq="1d",
            )
            past = self.create_multivariate_linear_timeseries(
                n_components=3,
                start_value=10,
                end_value=20,
                start=pd.Timestamp("1/4/2000"),
                end=pd.Timestamp("1/23/2000"),
                freq="2d",
            )
            future = self.create_multivariate_linear_timeseries(
                n_components=4,
                start_value=20,
                end_value=30,
                start=pd.Timestamp("1/6/2000"),
                end=pd.Timestamp("1/26/2000"),
                freq="3d",
            )
        # Conduct test for each input parameter combo:
        for lags, lags_past, lags_future, max_samples_per_ts in product(
            self.target_lag_combos,
            self.past_lag_combos,
            self.future_lag_combos,
            self.max_samples_per_ts_combos,
        ):
            all_lags = (lags, lags_past, lags_future)
            # Skip test where all lags are `None` - can't assemble features
            # for this single combo of input params:
            lags_is_none = [x is None for x in all_lags]
            if all(lags_is_none):
                continue
            X, times = create_lagged_prediction_data(
                target_series=target if lags else None,
                past_covariates=past if lags_past else None,
                future_covariates=future if lags_future else None,
                lags=lags,
                lags_past_covariates=lags_past,
                lags_future_covariates=lags_future,
                uses_static_covariates=False,
                max_samples_per_ts=max_samples_per_ts,
                use_moving_windows=True,
            )
            feats_times = self.get_feature_times(
                target,
                past,
                future,
                lags,
                lags_past,
                lags_future,
                max_samples_per_ts,
            )
            # Construct `X` by constructing each block, then concatenate these
            # blocks together along component axis:
            X_target = self.construct_X_block(target, feats_times, lags)
            X_past = self.construct_X_block(past, feats_times, lags_past)
            X_future = self.construct_X_block(future, feats_times, lags_future)
            all_X = (X_target, X_past, X_future)
            to_concat = [X for X in all_X if X is not None]
            expected_X = np.concatenate(to_concat, axis=1)
            # Number of observations should match number of feature times:
            assert X.shape[0] == len(feats_times)
            assert X.shape[0] == len(times[0])
            # Check that outputs match:
            assert np.allclose(expected_X, X[:, :, 0])
            assert feats_times.equals(times[0])

        Tests that `create_lagged_prediction_data` produces `X` and `times`
        outputs that are consistent with those generated by using the helper
        functions `get_feature_times` and `construct_X_block`. Consistency is
        checked over all of the combinations of parameter values specified by
        `self.target_lag_combos`, `self.covariates_lag_combos`, and
        `self.max_samples_per_ts_combos`.

        This particular test uses timeseries with time indices of unequal
        frequencies. Since all of the timeseries are *not* of the same frequency,
        the implementation of the 'time intersection' method is being tested here.
        
darts/tests/utils/tabularization/test_create_lagged_prediction_data.py