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 textwrap import dedent
  from unittest import TestCase
  from nose_parameterized import parameterized
  from numpy import arange, array, asarray, dtype, full, where
  from six.moves import zip_longest
  from toolz import curry
  from catalyst.errors import WindowLengthNotPositive, WindowLengthTooLong
  from catalyst.lib.adjustment import Datetime64Overwrite, Datetime641DArrayOverwrite, Float64Multiply, Float64Overwrite, Float641DArrayOverwrite, Int64Overwrite, ObjectOverwrite
  from catalyst.lib.adjusted_array import AdjustedArray, NOMASK
  from catalyst.lib.labelarray import LabelArray
  from catalyst.testing import check_arrays, parameter_space
  from catalyst.utils.compat import unicode
  from catalyst.utils.numpy_utils import coerce_to_dtype, datetime64ns_dtype, default_missing_value_for_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