def METHOD_NAME(
    self,
    model: Module,
    layer: Module,
    inputs: TensorOrTupleOfTensorsGeneric,
    baselines: Union[TensorOrTupleOfTensorsGeneric, Callable],
    target: TargetType,
    expected: Union[
        Tensor,
        Tuple[Tensor, ...],
        List[float],
        List[List[float]],
        Tuple[List[float], ...],
        Tuple[List[List[float]], ...],
    ],
    expected_delta: Tensor = None,
    n_samples: int = 5,
    attribute_to_layer_input: bool = False,
    add_args: Any = None,
) -> None:
    lgs = LayerGradientShap(model, layer)
    attrs, delta = lgs.attribute(
        inputs,
        baselines,
        target=target,
        additional_forward_args=add_args,
        n_samples=n_samples,
        stdevs=0.0009,
        return_convergence_delta=True,
        attribute_to_layer_input=attribute_to_layer_input,
    )
    assertTensorTuplesAlmostEqual(self, attrs, expected, delta=0.005)
    if expected_delta is None:
        _assert_attribution_delta(
            self, inputs, attrs, n_samples, delta, is_layer=True
        )
    else:
        for delta_i, expected_delta_i in zip(delta, expected_delta):
            assertTensorAlmostEqual(self, delta_i, expected_delta_i, delta=0.01)