code: def test_read_with_adjustments(self):
      columns = [USEquityPricing.high, USEquityPricing.volume]
      query_days = self.calendar_days_between(
          TEST_QUERY_START, TEST_QUERY_STOP
      )
      # Our expected results for each day are based on values from the
      # previous day.
      shifted_query_days = self.calendar_days_between(
          TEST_QUERY_START,
          TEST_QUERY_STOP,
          shift=-1,
      )
  
      pricing_loader = USEquityPricingLoader.without_fx(
          self.bcolz_equity_daily_bar_reader,
          self.adjustment_reader,
      )
  
      results = pricing_loader.load_adjusted_array(
          domain=US_EQUITIES,
          columns=columns,
          dates=query_days,
          sids=Int64Index(arange(1, 7)),
          mask=ones((len(query_days), 6), dtype=bool),
      )
      highs, volumes = map(getitem(results), columns)
  
      expected_baseline_highs = expected_bar_values_2d(
          shifted_query_days,
          self.sids,
          self.asset_info,
          "high",
      )
      expected_baseline_volumes = expected_bar_values_2d(
          shifted_query_days,
          self.sids,
          self.asset_info,
          "volume",
      )
  
      # At each point in time, the AdjustedArrays should yield the baseline
      # with all adjustments up to that date applied.
      for windowlen in range(1, len(query_days) + 1):
          for offset, window in enumerate(highs.traverse(windowlen)):
              baseline = expected_baseline_highs[
                  offset : offset + windowlen
              ]
              baseline_dates = query_days[offset : offset + windowlen]
              expected_adjusted_highs = self.apply_adjustments(
                  baseline_dates,
                  self.sids,
                  baseline,
                  # Apply all adjustments.
                  concat(
                      [SPLITS, MERGERS, DIVIDENDS_EXPECTED],
                      ignore_index=True,
                  ),
              )
              assert_allclose(expected_adjusted_highs, window)
  
          for offset, window in enumerate(volumes.traverse(windowlen)):
              baseline = expected_baseline_volumes[
                  offset : offset + windowlen
              ]
              baseline_dates = query_days[offset : offset + windowlen]
              # Apply only splits and invert the ratio.
              adjustments = SPLITS.copy()
              adjustments.ratio = 1 / adjustments.ratio
  
              expected_adjusted_volumes = self.apply_adjustments(
                  baseline_dates,
                  self.sids,
                  baseline,
                  adjustments,
              )
              # FIXME: Make AdjustedArray properly support integral types.
              assert_array_equal(
                  expected_adjusted_volumes,
                  window.astype(uint32),
              )
  
      # Verify that we checked up to the longest possible window.
      with self.assertRaises(WindowLengthTooLong):
          highs.traverse(windowlen + 1)
      with self.assertRaises(WindowLengthTooLong):
          volumes.traverse(windowlen + 1)
  
imports: from nose_parameterized import parameterized
  from numpy import arange, datetime64, float64, ones, uint32
  from numpy.testing import assert_allclose, assert_array_equal
  from pandas import concat, DataFrame, Int64Index, Timestamp
  from pandas.util.testing import assert_frame_equal
  from toolz.curried.operator import getitem
  from zipline.lib.adjustment import Float64Multiply
  from zipline.pipeline.domain import US_EQUITIES
  from zipline.pipeline.loaders.synthetic import NullAdjustmentReader, make_bar_data, expected_bar_values_2d
  from zipline.pipeline.loaders.equity_pricing_loader import USEquityPricingLoader
  from zipline.errors import WindowLengthTooLong
  from zipline.pipeline.data import USEquityPricing
  from zipline.testing import seconds_to_timestamp, str_to_seconds, MockDailyBarReader
  from zipline.testing.fixtures import WithAdjustmentReader, ZiplineTestCase
label_desc: Use image node_id 15 for calling the USEquityPricingLoaderTestCase obj's underlying member method code with example usage: obj.test_read_with_adjustments() without return types