code: def _gen_multiplicative_adjustment_cases(dtype):
      """
      Generate expected moving windows on a buffer with adjustments.
  
      We proceed by constructing, at each row, the view of the array we expect in
      in all windows anchored on that row.
  
      In general, if we have an adjustment to be applied once we process the row
      at index N, should see that adjustment applied to the underlying buffer for
      any window containing the row at index N.
  
      We then build all legal windows over these buffers.
      """
      adjustment_type = {
          float64_dtype: Float64Multiply,
      }[dtype]
  
      nrows, ncols = 6, 3
      adjustments = {}
      buffer_as_of = [None] * 6
      baseline = buffer_as_of[0] = full((nrows, ncols), 1, dtype=dtype)
  
      # Note that row indices are inclusive!
      adjustments[1] = [
          adjustment_type(0, 0, 0, 0, coerce_to_dtype(dtype, 2)),
      ]
      buffer_as_of[1] = array(
          [
              [2, 1, 1],
              [1, 1, 1],
              [1, 1, 1],
              [1, 1, 1],
              [1, 1, 1],
              [1, 1, 1],
          ],
          dtype=dtype,
      )
  
      # No adjustment at index 2.
      buffer_as_of[2] = buffer_as_of[1]
  
      adjustments[3] = [
          adjustment_type(1, 2, 1, 1, coerce_to_dtype(dtype, 3)),
          adjustment_type(0, 1, 0, 0, coerce_to_dtype(dtype, 4)),
      ]
      buffer_as_of[3] = array(
          [
              [8, 1, 1],
              [4, 3, 1],
              [1, 3, 1],
              [1, 1, 1],
              [1, 1, 1],
              [1, 1, 1],
          ],
          dtype=dtype,
      )
  
      adjustments[4] = [
          adjustment_type(0, 3, 2, 2, coerce_to_dtype(dtype, 5))
      ]
      buffer_as_of[4] = array(
          [
              [8, 1, 5],
              [4, 3, 5],
              [1, 3, 5],
              [1, 1, 5],
              [1, 1, 1],
              [1, 1, 1],
          ],
          dtype=dtype,
      )
  
      adjustments[5] = [
          adjustment_type(0, 4, 1, 1, coerce_to_dtype(dtype, 6)),
          adjustment_type(2, 2, 2, 2, coerce_to_dtype(dtype, 7)),
      ]
      buffer_as_of[5] = array(
          [
              [8, 6, 5],
              [4, 18, 5],
              [1, 18, 35],
              [1, 6, 5],
              [1, 6, 1],
              [1, 1, 1],
          ],
          dtype=dtype,
      )
  
      return _gen_expectations(
          baseline,
          default_missing_value_for_dtype(dtype),
          adjustments,
          buffer_as_of,
          nrows,
          perspective_offsets=(0, 1),
      )
  
imports: from collections import namedtuple
  from itertools import chain, product
  from string import ascii_lowercase, ascii_uppercase
  from textwrap import dedent
  from unittest import TestCase
  from nose_parameterized import parameterized
  from numpy import arange, array, asarray, dtype, full
  from six.moves import zip_longest
  from toolz import curry
  from zipline.errors import WindowLengthNotPositive, WindowLengthTooLong
  from zipline.lib.adjustment import Boolean1DArrayOverwrite, BooleanOverwrite, Datetime641DArrayOverwrite, Datetime64Overwrite, Float641DArrayOverwrite, Float64Multiply, Float64Overwrite, Int64Overwrite, Object1DArrayOverwrite, ObjectOverwrite
  from zipline.lib.adjusted_array import AdjustedArray
  from zipline.lib.labelarray import LabelArray
  from zipline.testing import check_arrays
  from zipline.testing.predicates import assert_equal
  from zipline.utils.compat import unicode
  from zipline.utils.numpy_utils import coerce_to_dtype, datetime64ns_dtype, default_missing_value_for_dtype, bool_dtype, float64_dtype, int64_dtype, object_dtype
label_desc: Use image node_id 7 for calling a global function with example usage: _gen_multiplicative_adjustment_cases(dtype) and returns: _gen_expectations