code: def test_forecast_pipeline_rolling_evaluation_prophet():
      """Checks the output rolling evaluation with Prophet template"""
      data = generate_df_with_reg_for_tests(
          freq="D",
          periods=30,
          remove_extra_cols=True,
          mask_test_actuals=True,
      )
      reg_cols = ["regressor1", "regressor2", "regressor3"]
      keep_cols = [TIME_COL, VALUE_COL] + reg_cols
      df = data["df"][keep_cols]
  
      hyperparameter_grid = {
          "estimator__weekly_seasonality": [True],
          "estimator__daily_seasonality": [True, False],
          "estimator__n_changepoints": [
              0
          ],  # to speed up test case, remove for better fit
          "estimator__uncertainty_samples": [
              10
          ],  # to speed up test case
          "estimator__add_regressor_dict": [
              {
                  "regressor1": {
                      "prior_scale": 10,
                      "standardize": True,
                      "mode": "additive",
                  },
                  "regressor2": {
                      "prior_scale": 15,
                      "standardize": False,
                      "mode": "additive",
                  },
                  "regressor3": {},
              }
          ],
      }
      pipeline_params = mock_pipeline(
          df=df,
          forecast_horizon=3,
          regressor_cols=["regressor1", "regressor2", "regressor3"],
          estimator=ProphetEstimator(),
          hyperparameter_grid=hyperparameter_grid,
      )
      tscv = RollingTimeSeriesSplit(
          forecast_horizon=3, expanding_window=True, max_splits=1
      )
      rolling_evaluation = forecast_pipeline_rolling_evaluation(
          pipeline_params=pipeline_params, tscv=tscv
      )
  
      expected_splits_n = tscv.max_splits
      assert len(rolling_evaluation.keys()) == expected_splits_n
      assert set(rolling_evaluation.keys()) == {"split_0"}
  
      split0_output = rolling_evaluation["split_0"]
      assert (
          round(split0_output["runtime_sec"], 3)
          == split0_output["runtime_sec"]
      )
  
      pipeline_result = split0_output["pipeline_result"]
      # Calculates expected pipeline
      train, test = list(tscv.split(X=df))[0]
      df_train = df.loc[train]
      pipeline_params_updated = pipeline_params
      pipeline_params_updated["test_horizon"] = 0
      pipeline_params_updated["df"] = df_train
      expected_pipeline_result = forecast_pipeline(
          **pipeline_params_updated
      )
  
      assert pipeline_result.backtest is None
      # Checks output is identical when there is only 1 split
      pipeline_grid_search = summarize_grid_search_results(
          pipeline_result.grid_search,
          score_func=EvaluationMetricEnum.MeanAbsolutePercentError.name,
      )
      expected_grid_search = summarize_grid_search_results(
          expected_pipeline_result.grid_search,
          score_func=EvaluationMetricEnum.MeanAbsolutePercentError.name,
      )
      assert_equal(
          pipeline_grid_search["mean_test_MAPE"],
          expected_grid_search["mean_test_MAPE"],
      )
      assert_equal(
          pipeline_result.grid_search.cv.__dict__,
          expected_pipeline_result.grid_search.cv.__dict__,
      )
      # Checks forecast df has the correct number of rows
      expected_rows = (
          pipeline_result.timeseries.fit_df.shape[0]
          + tscv.forecast_horizon
      )
      assert pipeline_result.forecast.df.shape[0] == expected_rows
  
imports: import sys
  import numpy
  import pandas
  import pytest
  from sklearn.metrics import mean_absolute_error
  from greykite.common.constants import TIME_COL
  from greykite.common.constants import VALUE_COL
  from greykite.common.evaluation import EvaluationMetricEnum
  from greykite.common.python_utils import assert_equal
  from greykite.common.testing_utils import generate_df_for_tests
  from greykite.common.testing_utils import generate_df_with_reg_for_tests
  from greykite.framework.benchmark.benchmark_class_helper import forecast_pipeline_rolling_evaluation
  from greykite.framework.pipeline.pipeline import forecast_pipeline
  from greykite.framework.utils.framework_testing_utils import mock_pipeline
  from greykite.framework.utils.result_summary import summarize_grid_search_results
  from greykite.sklearn.cross_validation import RollingTimeSeriesSplit
  from greykite.sklearn.estimator.prophet_estimator import ProphetEstimator
  from greykite.sklearn.estimator.silverkite_estimator import SilverkiteEstimator
label_desc: Use image node_id 1 for calling a global function with example usage: test_forecast_pipeline_rolling_evaluation_prophet() without return types