code: def _expected_data(self, asset_finder):
      sids = {
          symbol: asset_finder.lookup_symbol(
              symbol,
              None,
          ).sid
          for symbol in self.symbols
      }
  
      # Load raw data from quandl test resources.
      data = load_data_table(
          file=test_resource_path(
              "quandl_samples", "QUANDL_ARCHIVE.zip"
          ),
          index_col="date",
      )
      data["sid"] = pd.factorize(data.symbol)[0]
  
      all_ = data.set_index(
          "sid",
          append=True,
      ).unstack()
  
      # fancy list comprehension with statements
      @list
      @apply
      def pricing():
          for column in self.columns:
              vs = all_[column].values
              if column == "volume":
                  vs = np.nan_to_num(vs)
              yield vs
  
      # the first index our written data will appear in the files on disk
      start_idx = (
          self.calendar.all_sessions.get_loc(self.start_date, "ffill")
          + 1
      )
  
      # convert an index into the raw dataframe into an index into the
      # final data
      i = op.add(start_idx)
  
      def expected_dividend_adjustment(idx, symbol):
          sid = sids[symbol]
          return (
              1
              - all_.ix[idx, ("ex_dividend", sid)]
              / all_.ix[idx - 1, ("close", sid)]
          )
  
      adjustments = [
          # ohlc
          {
              # dividends
              i(24): [
                  Float64Multiply(
                      first_row=0,
                      last_row=i(24),
                      first_col=sids["AAPL"],
                      last_col=sids["AAPL"],
                      value=expected_dividend_adjustment(24, "AAPL"),
                  )
              ],
              i(87): [
                  Float64Multiply(
                      first_row=0,
                      last_row=i(87),
                      first_col=sids["AAPL"],
                      last_col=sids["AAPL"],
                      value=expected_dividend_adjustment(87, "AAPL"),
                  )
              ],
              i(150): [
                  Float64Multiply(
                      first_row=0,
                      last_row=i(150),
                      first_col=sids["AAPL"],
                      last_col=sids["AAPL"],
                      value=expected_dividend_adjustment(150, "AAPL"),
                  )
              ],
              i(214): [
                  Float64Multiply(
                      first_row=0,
                      last_row=i(214),
                      first_col=sids["AAPL"],
                      last_col=sids["AAPL"],
                      value=expected_dividend_adjustment(214, "AAPL"),
                  )
              ],
              i(31): [
                  Float64Multiply(
                      first_row=0,
                      last_row=i(31),
                      first_col=sids["MSFT"],
                      last_col=sids["MSFT"],
                      value=expected_dividend_adjustment(31, "MSFT"),
                  )
              ],
              i(90): [
                  Float64Multiply(
                      first_row=0,
                      last_row=i(90),
                      first_col=sids["MSFT"],
                      last_col=sids["MSFT"],
                      value=expected_dividend_adjustment(90, "MSFT"),
                  )
              ],
              i(158): [
                  Float64Multiply(
                      first_row=0,
                      last_row=i(158),
                      first_col=sids["MSFT"],
                      last_col=sids["MSFT"],
                      value=expected_dividend_adjustment(158, "MSFT"),
                  )
              ],
              i(222): [
                  Float64Multiply(
                      first_row=0,
                      last_row=i(222),
                      first_col=sids["MSFT"],
                      last_col=sids["MSFT"],
                      value=expected_dividend_adjustment(222, "MSFT"),
                  )
              ],
              # splits
              i(108): [
                  Float64Multiply(
                      first_row=0,
                      last_row=i(108),
                      first_col=sids["AAPL"],
                      last_col=sids["AAPL"],
                      value=1.0 / 7.0,
                  )
              ],
          },
      ] * (len(self.columns) - 1) + [
          # volume
          {
              i(108): [
                  Float64Multiply(
                      first_row=0,
                      last_row=i(108),
                      first_col=sids["AAPL"],
                      last_col=sids["AAPL"],
                      value=7.0,
                  )
              ],
          }
      ]
      return pricing, adjustments
  
file_path: zipline/tests/data/bundles/test_quandl.py
imports: from __future__ import division
  import numpy
  import pandas
  import toolz.curried.operator
  from zipline import get_calendar
  from zipline.data.bundles import ingest, load, bundles
  from zipline.data.bundles.quandl import format_metadata_url, load_data_table
  from zipline.lib.adjustment import Float64Multiply
  from zipline.testing import test_resource_path, tmp_dir, patch_read_csv
  from zipline.testing.fixtures import ZiplineTestCase, WithResponses
  from zipline.testing.predicates import assert_equal
  from zipline.utils.functional import apply
label_desc: Use image node_id 1 for calling the QuandlBundleTestCase obj's underlying member method code with example usage: obj._expected_data(asset_finder) and returns: pricing,  adjustments, unknown