def METHOD_NAME(
    self,
    data_shape,
    kernel_size,
    num_filter,
    in_dtype,
    strides,
    padding,
    groups,
    dilation,
    data_layout,
    kernel_layout,
    out_layout,
    schedule_name,
):
    """Test a subgraph with a single conv2d operator."""
    ref_input_data = np.random.randint(low=-128, high=127, size=data_shape, dtype=in_dtype)
    ref_input_var = relay.var("input", relay.TensorType(data_shape, in_dtype))  # NHWC layout
    kernel_shape = (*kernel_size, data_shape[-1] // groups, num_filter)  # HWIO layout
    ref_kernel_data = np.random.randint(low=-10, high=10, size=kernel_shape, dtype=in_dtype)
    """Our x86 depthwise implementation only supports HWOI with NHWC, so we need to change our
    kernel layout to work around this. We can't just change the whole thing to HWIO or
    something else, as then group conv2d would not work. Eventually, we should switch to using
    TensorFlow to create the reference output so we can ensure our implementation is right.
    See https://github.com/apache/tvm/issues/13137 for details."""
    ref_relay_op = relay.op.nn.conv2d(
        ref_input_var,
        relay.const(change_ndarray_layout(ref_kernel_data, "HWIO", self.ref_kernel_layout)),
        kernel_size=kernel_size,
        strides=strides,
        padding=padding,
        groups=groups,
        dilation=(dilation, dilation),
        data_layout="NHWC",
        kernel_layout=self.ref_kernel_layout,
        out_dtype="int32",
        out_layout="NHWC",
    )
    ref_module = tvm.IRModule.from_expr(relay.Function([ref_input_var], ref_relay_op))
    ref_outputs = generate_ref_data(ref_module, {"input": ref_input_data})
    # Reshape output dictionary to match out_layout
    assert len(ref_outputs) == 1
    output_tensor_name, output_tensor = next(iter(ref_outputs.items()))
    ref_outputs[output_tensor_name] = change_ndarray_layout(output_tensor, "NHWC", out_layout)
    test_input_data = change_ndarray_layout(ref_input_data, "NHWC", data_layout)
    test_input_var = relay.var("input", relay.TensorType(test_input_data.shape, in_dtype))
    test_kernel_data = change_ndarray_layout(ref_kernel_data, "HWIO", kernel_layout)
    test_relay_op = relay.op.nn.conv2d(
        test_input_var,
        relay.const(test_kernel_data),
        kernel_size=kernel_size,
        strides=strides,
        padding=padding,
        groups=groups,
        dilation=(dilation, dilation),
        data_layout=data_layout,
        kernel_layout=kernel_layout,
        out_dtype="int32",
        out_layout=out_layout,
    )
    test_function = relay.Function([test_input_var], test_relay_op)
    test_model = AOTTestModel(
        module=tvm.IRModule.from_expr(test_function),
        inputs={"input": test_input_data},
        outputs=ref_outputs,
    )
    compile_and_run(
        test_model,
        runner=AOT_CORSTONE300_RUNNER,
        interface_api="c",
        use_unpacked_api=True,
        target_opts={
            "-keys": "arm_cpu",
            "-mcpu": "cortex-m7",
        },
        schedule_name=schedule_name,
    )