def METHOD_NAME(self,
                             size,
                             input_channels,
                             batch_size,
                             inputs,
                             inplace,
                             gc,
                             dc):
    sum_fp32 = core.CreateOperator(
        "Sum",
        ["X_{}".format(i) for i in range(inputs)],
        ["X_0" if inplace else "Y"],
    )
    Xs = [np.random.rand(batch_size, input_channels, size, size).astype(
        np.float32) for _ in range(inputs)]
    old_ws_name = workspace.CurrentWorkspace()
    workspace.SwitchWorkspace("_device_check_", True)
    Xi_scales = []
    Xi_zero_points = []
    for i, X in enumerate(Xs):
        workspace.FeedBlob("X_{}".format(i), X, dc[0])
        if X.min() >= 0:
            Xi_scales.append(np.absolute(X).max() / 0xFF)
            Xi_zero_points.append(0)
        else:
            Xi_scales.append(np.absolute(X).max() / 0x7F)
            Xi_zero_points.append(128)
    workspace.RunOperatorOnce(sum_fp32)
    Y = workspace.FetchBlob("X_0" if inplace else "Y")
    if Y.min() >= 0:
        Y_scale = np.absolute(Y).max() / 0xFF
        Y_zero_point = 0
    else:
        Y_scale = np.absolute(Y).max() / 0x7F
        Y_zero_point = 128
    workspace.ResetWorkspace()
    net = caffe2_pb2.NetDef()
    for i, Xi in enumerate(Xs):
        workspace.FeedBlob("Xi_{}".format(i), Xi, dc[1])
        sw2nhwc = core.CreateOperator(
            "NCHW2NHWC",
            ["Xi_{}".format(i)],
            ["Xi_{}_nhwc".format(i)],
            device_option=dc[1]
        )
        quantize = core.CreateOperator(
            "Int8Quantize",
            ["Xi_{}_nhwc".format(i)],
            ["Xi_{}_quantized".format(i)],
            engine="DNNLOWP",
            device_option=dc[1],
            Y_zero_point=Xi_zero_points[i],
            Y_scale=Xi_scales[i],
        )
        net.op.extend([sw2nhwc, quantize])
    sum = core.CreateOperator(
        "Int8Sum",
        ["Xi_{}_quantized".format(i) for i in range(inputs)],
        ["Xi_0_quantized" if inplace else "Y_quantized"],
        engine="DNNLOWP",
        device_option=dc[1],
        Y_zero_point=Y_zero_point,
        Y_scale=Y_scale,
    )
    dequantize = core.CreateOperator(
        "Int8Dequantize",
        ["Xi_0_quantized" if inplace else "Y_quantized"],
        ["Y_nhwc"],
        engine="DNNLOWP",
        device_option=dc[1],
    )
    sw2nchw = core.CreateOperator(
        "NHWC2NCHW",
        ["Y_nhwc"],
        ["Y_out"],
        device_option=dc[1]
    )
    net.op.extend([sum, dequantize, sw2nchw])
    workspace.RunNetOnce(net)
    Y_out = workspace.FetchBlob("Y_out")
    MSE = np.square(np.subtract(Y, Y_out)).mean()
    if MSE > 0.005:
        print(Y.flatten())
        print(Y_out.flatten())
        print(np.max(np.abs(Y_out - Y)))
        print("MSE", MSE)
        self.assertTrue(False)
    workspace.SwitchWorkspace(old_ws_name)