code: def test_pf_convolution_execution(
      g_rng,
      inshape,
      outmaps,
      kernel,
      pad,
      stride,
      dilation,
      group,
      base_axis,
      w_init,
      b_init,
      with_bias,
      fix_parameters,
      rng,
  ):
      w_shape = (
          outmaps,
          inshape[base_axis] // group,
      ) + kernel
      b_shape = (outmaps,)
      w_init = process_param_init(w_init, w_shape, g_rng)
      b_init = process_param_init(b_init, b_shape, g_rng)
      rng = process_rng(rng)
  
      x = nn.Variable.from_numpy_array(g_rng.randn(*inshape))
      kw = {}
      insert_if_not_none(kw, "pad", pad)
      insert_if_not_none(kw, "stride", stride)
      insert_if_not_none(kw, "dilation", dilation)
      insert_if_not_none(kw, "w_init", w_init)
      insert_if_not_none(kw, "b_init", b_init)
      insert_if_not_none(kw, "rng", rng)
      insert_if_not_default(kw, "group", group, 1)
      insert_if_not_default(kw, "base_axis", base_axis, 1)
      insert_if_not_default(kw, "fix_parameters", fix_parameters, False)
      insert_if_not_default(kw, "with_bias", with_bias, True)
  
      # Check execution
      y = PF.convolution(x, outmaps, kernel, **kw)
      y.forward()
      y.backward()
  
      # Check values
      # TODO
  
      # Check args
      assert y.parent.info.type_name == "Convolution"
      args = y.parent.info.args
      assert args["base_axis"] == base_axis
      assert args["group"] == group
      ndim = len(x.shape) - (base_axis + 1)
      check_none_arg(tuple(args["pad"]), pad, (0,) * ndim)
      check_none_arg(tuple(args["stride"]), stride, (1,) * ndim)
      check_none_arg(tuple(args["dilation"]), dilation, (1,) * ndim)
  
      # Check created parameters
      assert y.parent.inputs[0] == x
      assert len(y.parent.inputs) == 2 + int(with_bias)
      assert len(nn.get_parameters()) == 1 + int(with_bias)
      w = nn.get_parameters()["conv/W"]
      assert w.shape == w_shape
      assert w.need_grad
      assert y.parent.inputs[1].need_grad == (not fix_parameters)
      if isinstance(w_init, np.ndarray):
          assert_allclose(w_init, w.d)
      if with_bias:
          b = nn.get_parameters()["conv/b"]
          assert b.shape == b_shape
          assert b.need_grad
          assert y.parent.inputs[2].need_grad == (not fix_parameters)
          if isinstance(b_init, np.ndarray):
              assert_allclose(b_init, b.d)
  
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 9 for calling a global function with example usage: test_pf_convolution_execution(g_rng, inshape, outmaps, kernel, pad, stride, dilation, group, base_axis, w_init, b_init, with_bias, fix_parameters, rng) without return types