def METHOD_NAME(self, conn_type, shape_a, shape_b, shape_w, *args, **kwargs):
    print("Testing:", conn_type)
    time = 100
    weights = [None, torch.Tensor(*shape_w)]
    wmins = [
        -np.inf,
        0,
        torch.zeros(*shape_w),
        torch.zeros(*shape_w).masked_fill(
            torch.bernoulli(torch.rand(*shape_w)) == 1, -np.inf
        ),
    ]
    wmaxes = [
        np.inf,
        0,
        torch.ones(*shape_w),
        torch.randn(*shape_w).masked_fill(
            torch.bernoulli(torch.rand(*shape_w)) == 1, np.inf
        ),
    ]
    update_rule = kwargs.get("update_rule", None)
    for w in weights:
        for wmin in wmins:
            for wmax in wmaxes:
                ### Conditional checks ###
                # WeightDependentPostPre does not handle infinite ranges
                if (
                    (torch.tensor(wmin, dtype=torch.float32) == -np.inf).any()
                    or (torch.tensor(wmax, dtype=torch.float32) == np.inf).any()
                ) and update_rule == WeightDependentPostPre:
                    continue
                # Rmax only supported for Connection & LocalConnection
                elif (
                    not (conn_type == Connection or conn_type == LocalConnection)
                    and update_rule == Rmax
                ):
                    return
                print(
                    f"- w: {type(w).__name__}, "
                    f"wmin: {type(wmax).__name__}, wmax: {type(wmax).__name__}"
                )
                if kwargs.get("update_rule") == Rmax:
                    l_a = SRM0Nodes(
                        shape=shape_a, traces=True, traces_additive=True
                    )
                    l_b = SRM0Nodes(
                        shape=shape_b, traces=True, traces_additive=True
                    )
                else:
                    l_a = LIFNodes(shape=shape_a, traces=True, traces_additive=True)
                    l_b = LIFNodes(shape=shape_b, traces=True, traces_additive=True)
                ### Create network ###
                network = Network(dt=1.0)
                network.add_layer(
                    Input(n=100, traces=True, traces_additive=True), name="input"
                )
                network.add_layer(l_a, name="a")
                network.add_layer(l_b, name="b")
                network.add_connection(
                    conn_type(l_a, l_b, w=w, wmin=wmin, wmax=wmax, *args, **kwargs),
                    source="a",
                    target="b",
                )
                network.add_connection(
                    Connection(
                        wmin=0,
                        wmax=1,
                        source=network.layers["input"],
                        target=network.layers["a"],
                        **kwargs,
                    ),
                    source="input",
                    target="a",
                )
                ### Run network ###
                network.run(
                    inputs={"input": torch.bernoulli(torch.rand(time, 100)).byte()},
                    time=time,
                    reward=1,
                )