code: def test_read_no_adjustments(self):
      adjustment_reader = NullAdjustmentReader()
      columns = [USEquityPricing.close, 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,
      )
  
      adjustments = adjustment_reader.load_pricing_adjustments(
          [c.name for c in columns],
          query_days,
          self.sids,
      )
      self.assertEqual(adjustments, [{}, {}])
  
      pricing_loader = USEquityPricingLoader.without_fx(
          self.bcolz_equity_daily_bar_reader,
          adjustment_reader,
      )
  
      results = pricing_loader.load_adjusted_array(
          domain=US_EQUITIES,
          columns=columns,
          dates=query_days,
          sids=self.sids,
          mask=ones((len(query_days), len(self.sids)), dtype=bool),
      )
      closes, volumes = map(getitem(results), columns)
  
      expected_baseline_closes = expected_bar_values_2d(
          shifted_query_days,
          self.sids,
          self.asset_info,
          "close",
      )
      expected_baseline_volumes = expected_bar_values_2d(
          shifted_query_days,
          self.sids,
          self.asset_info,
          "volume",
      )
  
      # AdjustedArrays should yield the same data as the expected baseline.
      for windowlen in range(1, len(query_days) + 1):
          for offset, window in enumerate(closes.traverse(windowlen)):
              assert_array_equal(
                  expected_baseline_closes[offset : offset + windowlen],
                  window,
              )
  
          for offset, window in enumerate(volumes.traverse(windowlen)):
              assert_array_equal(
                  expected_baseline_volumes[
                      offset : offset + windowlen
                  ],
                  window,
              )
  
      # Verify that we checked up to the longest possible window.
      with self.assertRaises(WindowLengthTooLong):
          closes.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 13 for calling the USEquityPricingLoaderTestCase obj's underlying member method code with example usage: obj.test_read_no_adjustments() without return types