code: def make_future_minute_bar_data(cls):
      tc = cls.trading_calendar
      start = pd.Timestamp("2016-01-26", tz="UTC")
      end = pd.Timestamp("2016-04-29", tz="UTC")
      dts = tc.minutes_for_sessions_in_range(start, end)
      sessions = tc.sessions_in_range(start, end)
      # Generate values in the XXY.YYY space, with XX representing the
      # session and Y.YYY representing the minute within the session.
      # e.g. the close of the 23rd session would be 231.440.
      r = 10.0
      day_markers = repeat(
          arange(r, r * len(sessions) + r, r), FUTURES_MINUTES_PER_DAY
      )
      r = 0.001
      min_markers = tile(
          arange(r, r * FUTURES_MINUTES_PER_DAY + r, r), len(sessions)
      )
  
      markers = day_markers + min_markers
  
      # Volume uses a similar scheme as above but times 1000.
      r = 10.0 * 1000
      vol_day_markers = repeat(
          arange(r, r * len(sessions) + r, r, dtype=int64),
          FUTURES_MINUTES_PER_DAY,
      )
      r = 0.001 * 1000
      vol_min_markers = tile(
          arange(r, r * FUTURES_MINUTES_PER_DAY + r, r, dtype=int64),
          len(sessions),
      )
      vol_markers = vol_day_markers + vol_min_markers
      base_df = pd.DataFrame(
          {
              "open": full(len(dts), 102000.0) + markers,
              "high": full(len(dts), 109000.0) + markers,
              "low": full(len(dts), 101000.0) + markers,
              "close": full(len(dts), 105000.0) + markers,
              "volume": full(len(dts), 10000, dtype=int64)
              + vol_markers,
          },
          index=dts,
      )
      # Add the sid to the ones place of the prices, so that the ones
      # place can be used to eyeball the source contract.
  
      # For volume roll tests end sid volume early.
      # FOF16 cuts out day before autoclose of 01-26
      # FOG16 cuts out on autoclose
      # FOH16 cuts out 4 days before autoclose
      # FOJ16 cuts out 3 days before autoclose
      # Make FOG22 have a blip of trading, but not be the actively trading,
      # so that it does not particpate in volume rolls.
  
      sid_to_vol_stop_session = {
          0: Timestamp("2016-01-26", tz="UTC"),
          1: Timestamp("2016-02-26", tz="UTC"),
          2: Timestamp("2016-03-18", tz="UTC"),
          3: Timestamp("2016-04-20", tz="UTC"),
          6: Timestamp("2016-01-27", tz="UTC"),
      }
      for i in range(20):
          df = base_df.copy()
          df += i * 10000
          if i in sid_to_vol_stop_session:
              vol_stop_session = sid_to_vol_stop_session[i]
              m_open = tc.open_and_close_for_session(vol_stop_session)[
                  0
              ]
              loc = dts.searchsorted(m_open)
              # Add a little bit of noise to roll. So that predicates that
              # check for exactly 0 do not work, since there may be
              # stragglers after a roll.
              df.volume.values[loc] = 1000
              df.volume.values[loc + 1 :] = 0
          j = i - 1
          if j in sid_to_vol_stop_session:
              non_primary_end = sid_to_vol_stop_session[j]
              m_close = tc.open_and_close_for_session(non_primary_end)[
                  1
              ]
              if m_close > dts[0]:
                  loc = dts.get_loc(m_close)
                  # Add some volume before a roll, since a contract may be
                  # entered earlier than when it is the primary.
                  df.volume.values[: loc + 1] = 10
          if i == 15:  # No volume for MAH16
              df.volume.values[:] = 0
          if i == 17:
              end_loc = dts.searchsorted("2016-02-16 23:00:00+00:00")
              df.volume.values[:end_loc] = 10
              df.volume.values[end_loc:] = 0
          if i == 18:
              cross_loc_1 = dts.searchsorted(
                  "2016-02-09 23:01:00+00:00"
              )
              cross_loc_2 = dts.searchsorted(
                  "2016-02-11 23:01:00+00:00"
              )
              cross_loc_3 = dts.searchsorted(
                  "2016-02-15 23:01:00+00:00"
              )
              end_loc = dts.searchsorted("2016-03-16 23:01:00+00:00")
              df.volume.values[:cross_loc_1] = 5
              df.volume.values[cross_loc_1:cross_loc_2] = 15
              df.volume.values[cross_loc_2:cross_loc_3] = 5
              df.volume.values[cross_loc_3:end_loc] = 15
              df.volume.values[end_loc:] = 0
          if i == 19:
              early_cross_1 = dts.searchsorted(
                  "2016-03-01 23:01:00+00:00"
              )
              early_cross_2 = dts.searchsorted(
                  "2016-03-03 23:01:00+00:00"
              )
              end_loc = dts.searchsorted("2016-04-19 23:01:00+00:00")
              df.volume.values[:early_cross_1] = 1
              df.volume.values[early_cross_1:early_cross_2] = 20
              df.volume.values[early_cross_2:end_loc] = 10
              df.volume.values[end_loc:] = 0
          yield i, df
  
imports: from collections import deque
  from functools import partial
  from textwrap import dedent
  from numpy import arange, array, int64, full, repeat, tile
  from numpy.testing import assert_almost_equal
  import pandas
  from pandas import Timestamp, DataFrame
  from zipline.assets.continuous_futures import OrderedContracts, delivery_predicate
  from zipline.assets.roll_finder import ROLL_DAYS_FOR_CURRENT_CONTRACT, VolumeRollFinder
  from zipline.data.minute_bars import FUTURES_MINUTES_PER_DAY
  from zipline.errors import SymbolNotFound
  import zipline.testing.fixtures
label_desc: Use image node_id 3 for calling the ContinuousFuturesTestCase obj's underlying member method code with example usage: obj.make_future_minute_bar_data(cls) without return types