code: def test_pf_batch_normalization_execution(
      g_rng,
      inshape,
      axes,
      decay_rate,
      eps,
      batch_stat,
      output_stat,
      param_init,
      fix_parameters,
      rng,
  ):
      p_shape = _get_bn_parameter_shape(inshape, axes)
      if param_init:
          beta_init = np.ones(p_shape)
          gamma_init = np.ones(p_shape) * 2
          mean_init = np.ones(p_shape) * 0.5
          var_init = np.ones(p_shape) * 1.5
          param_init = dict(
              beta=beta_init,
              gamma=gamma_init,
              mean=mean_init,
              var=var_init,
          )
      rng = process_rng(rng)
  
      x = nn.Variable.from_numpy_array(g_rng.randn(*inshape))
  
      kw = {}
      insert_if_not_default(kw, "axes", axes, [1])
      insert_if_not_default(kw, "decay_rate", decay_rate, 0.9)
      insert_if_not_default(kw, "eps", eps, 1e-5)
      insert_if_not_default(kw, "batch_stat", batch_stat, True)
      insert_if_not_default(kw, "output_stat", output_stat, False)
      insert_if_not_default(kw, "fix_parameters", fix_parameters, False)
      insert_if_not_none(kw, "param_init", param_init)
  
      # Check creation
      y = PF.batch_normalization(x, **kw)
  
      # Check parameter values before execution
      h = y[0] if output_stat else y
      _, b, g, m, v = h.parent.inputs
      if param_init:
          assert_allclose(b.d, beta_init)
          assert_allclose(g.d, gamma_init)
          assert_allclose(m.d, mean_init)
          assert_allclose(v.d, var_init)
      else:
          assert_allclose(b.d, 0)
          assert_allclose(g.d, 1)
          assert_allclose(m.d, 0)
          assert_allclose(v.d, 1)
  
      # Check execution
      if output_stat:
          forward_backward_all(*y)
      else:
          y.forward()
          # TODO: Enable when implemented
          if batch_stat:
              y.backward()
  
      # Check values
      # TODO
  
      # Check args
      assert h.parent.info.type_name == "BatchNormalization"
      args = h.parent.info.args
      assert np.isclose(args["decay_rate"], decay_rate)
      assert np.isclose(args["eps"], eps)
      assert args["axes"] == axes
      assert args["batch_stat"] == batch_stat
  
      # Check created parameters
      assert h.parent.inputs[0] == x
      assert len(h.parent.inputs) == 5
      assert len(nn.get_parameters()) == 2
      assert len(nn.get_parameters(grad_only=False)) == 4
      beta, gamma, mean, var = [
          nn.get_parameters(grad_only=False)["bn/" + name]
          for name in ["beta", "gamma", "mean", "var"]
      ]
      assert beta.shape == p_shape
      assert gamma.shape == p_shape
      assert mean.shape == p_shape
      assert var.shape == p_shape
  
      assert beta.need_grad
      assert gamma.need_grad
      assert not mean.need_grad
      assert not var.need_grad
  
      _, b, g, m, v = h.parent.inputs
      assert b.need_grad == (not fix_parameters)
      assert g.need_grad == (not fix_parameters)
      assert not m.need_grad
      assert not v.need_grad
  
imports: import pytest
  import numpy
  import nnabla
  import nnabla.functions
  import nnabla.parametric_functions
  import nnabla.initializer
  from nnabla.testing import assert_allclose
  from nbla_test_utils import list_context
label_desc: Use image node_id 11 for calling a global function with example usage: test_pf_batch_normalization_execution(g_rng, inshape, axes, decay_rate, eps, batch_stat, output_stat, param_init, fix_parameters, rng) without return types