code: def check_cmn_with_out_of_bounds_policy_support(
      cmn_op,
      device,
      batch_size,
      dtype,
      input_layout,
      input_shape,
      output_layout,
      mirror_probability,
      mean,
      std,
      should_pad,
      out_of_bounds_policy=None,
      fill_values=(0x76, 0xB9, 0x00),
  ):
      # This test case is written with HWC layout in mind and "HW" axes in slice arguments
      assert input_layout == "HWC"
      assert len(input_shape) == 3
      if fill_values is not None and len(fill_values) > 1:
          assert input_shape[2] == len(fill_values)
      eii = RandomDataIterator(batch_size, shape=input_shape)
      crop_y, crop_x = 0.5, 0.5
      crop_h, crop_w = input_shape[0] * 2, input_shape[1] * 2
      pipe = CMNRandomDataPipeline(
          cmn_op,
          device,
          batch_size,
          input_layout,
          iter(eii),
          dtype=dtype,
          output_layout=output_layout,
          mirror_probability=mirror_probability,
          mean=mean,
          std=std,
          pad_output=should_pad,
          crop_w=crop_w,
          crop_h=crop_h,
          crop_pos_x=crop_x,
          crop_pos_y=crop_y,
          out_of_bounds_policy=out_of_bounds_policy,
          fill_values=fill_values,
          extra_outputs=True,
      )
      permute = None
      if output_layout != input_layout:
          permute = []
          for d in range(len(input_layout)):
              perm_d = input_layout.find(output_layout[d])
              permute.append(perm_d)
  
      if fill_values is None:
          fill_values = 0
      pipe.build()
      for k in range(3):
          outs = pipe.run()
          out = outs[0]
          in_data = outs[1]
          mirror_data = outs[2]
          if isinstance(out, dali.backend_impl.TensorListGPU):
              out = out.as_cpu()
          if isinstance(in_data, dali.backend_impl.TensorListGPU):
              in_data = in_data.as_cpu()
  
          assert batch_size == len(out)
          for idx in range(batch_size):
              sample_in = in_data.at(idx)
              sample_out = out.at(idx)
              mirror = mirror_data.at(idx)
              flip = [0, mirror]
              in_shape = list(sample_in.shape)
              crop_anchor_norm = [crop_y, crop_x]
              crop_shape = [crop_h, crop_w]
              crop_anchor_abs = [
                  crop_anchor_norm[k] * (input_shape[k] - crop_shape[k])
                  for k in range(2)
              ]
              (
                  abs_start,
                  abs_end,
                  abs_slice_shape,
              ) = abs_slice_start_and_end(
                  in_shape[:2],
                  crop_anchor_abs,
                  crop_shape,
                  False,
                  False,
              )
              check_slice_output(
                  sample_in,
                  sample_out,
                  crop_anchor_abs,
                  abs_slice_shape,
                  abs_start,
                  abs_end,
                  out_of_bounds_policy,
                  fill_values,
                  mean=mean,
                  std=std,
                  flip=flip,
                  permute=permute,
              )
  
imports: import numpy
  import nvidia.dali
  import nvidia.dali.fn
  import nvidia.dali.ops
  import nvidia.dali.types
  import os
  from functools import partial
  from nvidia.dali import pipeline_def
  from nvidia.dali.pipeline import Pipeline
  from nose2.tools import params
  from nose_utils import assert_raises
  from nose_utils import raises
  from test_slice import check_slice_output, abs_slice_start_and_end
  from test_utils import RandomDataIterator
  from test_utils import as_array
  from test_utils import compare_pipelines, dali_type_to_np
  from test_utils import get_dali_extra_path
  import itertools
label_desc: Use image node_id 11 for calling a global function with example usage: check_cmn_with_out_of_bounds_policy_support(cmn_op, device, batch_size, dtype, input_layout, input_shape, output_layout, mirror_probability, mean, std, should_pad, out_of_bounds_policy, fill_values) without return types