def METHOD_NAME(in_splits, out_splits, bias, in_f, out_f):
    base = LinearWrapper(in_f, out_f, bias=bias)
    test = TiledLinearReturnBias(in_f,
                                 out_f,
                                 bias=bias,
                                 linear_cls=LinearWrapper,
                                 init_linear=copy.deepcopy(base),
                                 out_splits=out_splits,
                                 in_splits=in_splits)
    inp = torch.rand(in_f)
    base_out_t, base_out_b = base(copy.deepcopy(inp))
    test_out_t, test_out_b = test(copy.deepcopy(inp))
    assert torch.allclose(base_out_t, test_out_t, rtol=1e-4)
    if base_out_b is None:
        assert test_out_b is None
        base_out_b = torch.zeros_like(base_out_t)
        test_out_b = torch.zeros_like(test_out_t)
    else:
        assert test_out_b is not None
        assert torch.allclose(base_out_b, test_out_b, rtol=1e-4)
    (base_out_t + base_out_b).sum().backward()
    (test_out_t + test_out_b).sum().backward()
    # compare grads
    for row in range(out_splits):
        rstart = test.out_parts[row]
        rstop = test.out_parts[row + 1]
        for col in range(in_splits):
            cstart = test.in_parts[col]
            cstop = test.in_parts[col + 1]
            local = test.linears[row][col]
            base_grad = base.weight.grad[rstart:rstop, cstart:cstop]
            assert torch.allclose(base_grad, local.weight.grad, rtol=1e-4)
            if local.bias is not None:
                base_grad = base.bias.grad[rstart:rstop]
                assert torch.allclose(base_grad, local.bias.grad, rtol=1e-4)