code: def check_forward(self, inputs, backend_config):
      if self.running_statistics:
          running_mean_expected = self.running_mean.copy()
          running_var_expected = self.running_var.copy()
      else:
          running_mean_expected = None
          running_var_expected = None
  
      (y_expected,) = self.forward_cpu(
          inputs, running_mean_expected, running_var_expected
      )
  
      inputs = backend_config.get_array(inputs)
      running_mean = backend_config.get_array(self.running_mean)
      running_var = backend_config.get_array(self.running_var)
  
      if not self.c_contiguous:
          with backend_config:
              inputs = _as_noncontiguous_array(inputs)
              running_mean = _as_noncontiguous_array(running_mean)
              running_var = _as_noncontiguous_array(running_var)
  
      with backend_config:
          y = functions.batch_normalization(
              *inputs,
              running_mean=running_mean,
              running_var=running_var,
              **self.bn_options,
          )
      assert y.data.dtype == self.xdtype
  
      testing.assert_allclose(
          y_expected, y.data, **self.check_forward_options
      )
      if self.running_statistics:
          testing.assert_allclose(
              running_mean_expected,
              running_mean,
              **self.check_forward_options,
          )
          testing.assert_allclose(
              running_var_expected,
              running_var,
              **self.check_forward_options,
          )
  
imports: import unittest
  import warnings
  import numpy
  import six
  import chainer
  from chainer.backends import cuda
  from chainer import functions
  from chainer import gradient_check
  from chainer import testing
  from chainer.testing import attr
  from chainer.testing import backend
label_desc: Use image node_id 3 for calling the TestBatchNormalization obj's underlying member method code with example usage: obj.check_forward(inputs, backend_config) without return types