internlm/SWE-Fixer-Train-110K huggingface dataset:
Repository: ivy-llc/ivy

Issue:
logaddexp



Discussion:

Resolving patch:
diff --git a/ivy/functional/frontends/torch/tensor.py b/ivy/functional/frontends/torch/tensor.py
--- a/ivy/functional/frontends/torch/tensor.py
+++ b/ivy/functional/frontends/torch/tensor.py
@@ -1570,6 +1570,10 @@ def backward(self, gradient=None, retain_graph=None, create_graph=False):
             else:
                 next_function(_grad_list[idx])
 
+    @with_unsupported_dtypes({"2.0.1 and below": ("float16", "bfloat16")}, "torch")
+    def logaddexp(self, other):
+        return torch_frontend.logaddexp(self, other)
+
     @with_supported_dtypes(
         {
             "2.5.0 and below": (


Test patch:
diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py
--- a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py
+++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py
@@ -10357,6 +10357,48 @@ def test_torch_instance_backward(
     )
 
 
+# logaddexp
+@handle_frontend_method(
+    class_tree=CLASS_TREE,
+    init_tree="torch.tensor",
+    method_name="logaddexp",
+    dtype_and_x=helpers.dtype_and_values(
+        available_dtypes=helpers.get_dtypes("float"),
+        num_arrays=2,
+        min_num_dims=1,
+        min_value=-100,
+        max_value=100,
+        shared_dtype=True,
+    ),
+)
+def test_torch_instance_logaddexp(
+    dtype_and_x,
+    frontend_method_data,
+    init_flags,
+    method_flags,
+    frontend,
+    on_device,
+    backend_fw,
+):
+    input_dtype, x = dtype_and_x
+    helpers.test_frontend_method(
+        init_input_dtypes=input_dtype,
+        backend_to_test=backend_fw,
+        init_all_as_kwargs_np={
+            "data": x[0],
+        },
+        method_input_dtypes=input_dtype,
+        method_all_as_kwargs_np={
+            "other": x[1],
+        },
+        frontend_method_data=frontend_method_data,
+        init_flags=init_flags,
+        method_flags=method_flags,
+        frontend=frontend,
+        on_device=on_device,
+    )
+
+
 @handle_frontend_method(
     class_tree=CLASS_TREE,
     init_tree="torch.tensor",
Repository: ivy-llc/ivy

Issue:
is_meta



Discussion:

Resolving patch:
diff --git a/ivy/functional/frontends/torch/tensor.py b/ivy/functional/frontends/torch/tensor.py
--- a/ivy/functional/frontends/torch/tensor.py
+++ b/ivy/functional/frontends/torch/tensor.py
@@ -727,6 +727,10 @@ def is_quantized(self):
     def is_cuda(self):
         return "gpu" in ivy.dev(self.ivy_array)
 
+    @property
+    def is_meta(self):
+        return "meta" in ivy.dev(self.ivy_array)
+
     @with_unsupported_dtypes({"2.0.1 and below": ("bfloat16",)}, "torch")
     def pow(self, exponent):
         return torch_frontend.pow(self, exponent)


Test patch:
diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py
--- a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py
+++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py
@@ -3755,6 +3755,22 @@ def test_torch_tensor_property_is_cuda(
     )
 
 
+@given(
+    dtype_x=helpers.dtype_and_values(
+        available_dtypes=helpers.get_dtypes("valid", prune_function=False)
+    ).filter(lambda x: "bfloat16" not in x[0]),
+)
+def test_torch_tensor_property_is_meta(
+    dtype_x,
+):
+    _, data = dtype_x
+    x = Tensor(data[0])
+    x.ivy_array = data[0]
+    ivy.utils.assertions.check_equal(
+        x.is_meta, "meta" in ivy.dev(ivy.array(data[0])), as_array=False
+    )
+
+
 # logical_and
 @handle_frontend_method(
     class_tree=CLASS_TREE,
Repository: ivy-llc/ivy

Issue:
adaptive_avg_pool1d



Discussion:

Resolving patch:
diff --git a/ivy/functional/frontends/paddle/nn/functional/pooling.py b/ivy/functional/frontends/paddle/nn/functional/pooling.py
--- a/ivy/functional/frontends/paddle/nn/functional/pooling.py
+++ b/ivy/functional/frontends/paddle/nn/functional/pooling.py
@@ -69,3 +69,9 @@ def avg_pool1d(
         ceil_mode=ceil_mode,
         data_format=data_format,
     )
+
+
+@to_ivy_arrays_and_back
+@with_supported_dtypes({"2.5.0 and below": ("float32", "float64")}, "paddle")
+def adaptive_avg_pool1d(x, output_size, name=None):
+    return ivy.adaptive_avg_pool1d(x, output_size)


Test patch:
diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_nn/test_functional/test_pooling.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_nn/test_functional/test_pooling.py
--- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_nn/test_functional/test_pooling.py
+++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_nn/test_functional/test_pooling.py
@@ -106,3 +106,37 @@ def test_paddle_avg_pool1d(
         exclusive=exclusive,
         ceil_mode=ceil_mode,
     )
+
+
+# adaptive_avg_pool1d
+@handle_frontend_test(
+    fn_tree="paddle.nn.functional.adaptive_avg_pool1d",
+    dtype_and_x=helpers.dtype_and_values(
+        available_dtypes=helpers.get_dtypes("float"),
+        min_num_dims=3,
+        max_num_dims=3,
+        min_dim_size=1,
+        max_value=100,
+        min_value=-100,
+    ),
+    output_size=helpers.ints(min_value=1, max_value=5),
+)
+def test_paddle_adaptive_avg_pool1d(
+    *,
+    dtype_and_x,
+    output_size,
+    test_flags,
+    frontend,
+    on_device,
+    fn_tree,
+):
+    input_dtype, x = dtype_and_x
+    helpers.test_frontend_function(
+        input_dtypes=input_dtype,
+        frontend=frontend,
+        test_flags=test_flags,
+        on_device=on_device,
+        fn_tree=fn_tree,
+        x=x[0],
+        output_size=output_size,
+    )
Repository: ivy-llc/ivy

Issue:
adaptive_avg_pool2d



Discussion:

Resolving patch:
diff --git a/ivy/functional/frontends/paddle/nn/functional/pooling.py b/ivy/functional/frontends/paddle/nn/functional/pooling.py
--- a/ivy/functional/frontends/paddle/nn/functional/pooling.py
+++ b/ivy/functional/frontends/paddle/nn/functional/pooling.py
@@ -75,3 +75,9 @@ def avg_pool1d(
 @with_supported_dtypes({"2.5.0 and below": ("float32", "float64")}, "paddle")
 def adaptive_avg_pool1d(x, output_size, name=None):
     return ivy.adaptive_avg_pool1d(x, output_size)
+
+
+@to_ivy_arrays_and_back
+@with_supported_dtypes({"2.5.0 and below": ("float32", "float64")}, "paddle")
+def adaptive_avg_pool2d(x, output_size, data_format="NCHW", name=None):
+    return ivy.adaptive_avg_pool2d(x, output_size)


Test patch:
diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_nn/test_functional/test_pooling.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_nn/test_functional/test_pooling.py
--- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_nn/test_functional/test_pooling.py
+++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_nn/test_functional/test_pooling.py
@@ -140,3 +140,43 @@ def test_paddle_adaptive_avg_pool1d(
         x=x[0],
         output_size=output_size,
     )
+
+
+# adaptive_avg_pool2d
+@handle_frontend_test(
+    fn_tree="paddle.nn.functional.adaptive_avg_pool2d",
+    dtype_and_x=helpers.dtype_and_values(
+        available_dtypes=helpers.get_dtypes("float"),
+        min_num_dims=4,
+        max_num_dims=4,
+        min_dim_size=1,
+        max_value=100,
+        min_value=-100,
+    ),
+    output_size=st.one_of(
+        st.tuples(
+            helpers.ints(min_value=1, max_value=5),
+            helpers.ints(min_value=1, max_value=5),
+        ),
+        helpers.ints(min_value=1, max_value=5),
+    ),
+)
+def test_paddle_adaptive_avg_pool2d(
+    *,
+    dtype_and_x,
+    output_size,
+    test_flags,
+    frontend,
+    on_device,
+    fn_tree,
+):
+    input_dtype, x = dtype_and_x
+    helpers.test_frontend_function(
+        input_dtypes=input_dtype,
+        frontend=frontend,
+        test_flags=test_flags,
+        on_device=on_device,
+        fn_tree=fn_tree,
+        x=x[0],
+        output_size=output_size,
+    )
Repository: ivy-llc/ivy

Issue:
max_unpool1d



Discussion:

Resolving patch:
diff --git a/ivy/functional/frontends/paddle/nn/functional/pooling.py b/ivy/functional/frontends/paddle/nn/functional/pooling.py
--- a/ivy/functional/frontends/paddle/nn/functional/pooling.py
+++ b/ivy/functional/frontends/paddle/nn/functional/pooling.py
@@ -81,3 +81,18 @@ def adaptive_avg_pool1d(x, output_size, name=None):
 @with_supported_dtypes({"2.5.0 and below": ("float32", "float64")}, "paddle")
 def adaptive_avg_pool2d(x, output_size, data_format="NCHW", name=None):
     return ivy.adaptive_avg_pool2d(x, output_size)
+
+
+@to_ivy_arrays_and_back
+@with_supported_dtypes({"2.5.0 and below": ("float32", "float64")}, "paddle")
+def max_unpool1d(
+    x,
+    indices,
+    kernel_size,
+    stride=None,
+    padding=0,
+    data_format="NCL",
+    output_size=None,
+    name=None,
+):
+    return ivy.max_unpool1d(x, indices, kernel_size, stride, padding, data_format)


Test patch:
diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_nn/test_functional/test_pooling.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_nn/test_functional/test_pooling.py
--- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_nn/test_functional/test_pooling.py
+++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_nn/test_functional/test_pooling.py
@@ -180,3 +180,33 @@ def test_paddle_adaptive_avg_pool2d(
         x=x[0],
         output_size=output_size,
     )
+
+
+# max_unpool1d
+@handle_frontend_test(
+    fn_tree="paddle.nn.functional.max_unpool1d",
+    x_k_s_p=helpers.arrays_for_pooling(min_dims=3, max_dims=3, min_side=1, max_side=4),
+    indices=st.lists(st.integers(0, 1), min_size=1, max_size=4),
+)
+def test_paddle_max_unpool1d(
+    *,
+    x_k_s_p,
+    indices,
+    test_flags,
+    frontend,
+    on_device,
+    fn_tree,
+):
+    (input_dtype, x, kernel_size, stride, padding) = x_k_s_p
+    helpers.test_frontend_function(
+        input_dtypes=input_dtype,
+        frontend=frontend,
+        test_flags=test_flags,
+        on_device=on_device,
+        fn_tree=fn_tree,
+        x=x[0],
+        indices=indices,
+        kernel_size=kernel_size,
+        stride=stride,
+        padding=padding,
+    )
Repository: ivy-llc/ivy

Issue:
angle
Implement torch.Tensor.angle


Discussion:

Resolving patch:
diff --git a/ivy/functional/frontends/torch/tensor.py b/ivy/functional/frontends/torch/tensor.py
--- a/ivy/functional/frontends/torch/tensor.py
+++ b/ivy/functional/frontends/torch/tensor.py
@@ -1578,6 +1578,9 @@ def backward(self, gradient=None, retain_graph=None, create_graph=False):
     def logaddexp(self, other):
         return torch_frontend.logaddexp(self, other)
 
+    def angle(self):
+        return torch_frontend.angle(self)
+
     @with_supported_dtypes(
         {
             "2.5.0 and below": (


Test patch:
diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py
--- a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py
+++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py
@@ -10418,6 +10418,40 @@ def test_torch_instance_backward(
     )
 
 
+# angle
+@handle_frontend_method(
+    class_tree=CLASS_TREE,
+    init_tree="torch.tensor",
+    method_name="angle",
+    dtype_and_values=helpers.dtype_and_values(
+        available_dtypes=["float64", "complex64", "complex128"],
+    ),
+)
+def test_torch_instance_angle(
+    dtype_and_values,
+    frontend,
+    frontend_method_data,
+    init_flags,
+    method_flags,
+    on_device,
+):
+    input_dtype, values = dtype_and_values
+
+    helpers.test_frontend_method(
+        init_input_dtypes=input_dtype,
+        init_all_as_kwargs_np={
+            "data": values[0],
+        },
+        method_input_dtypes=input_dtype,
+        method_all_as_kwargs_np={},
+        init_flags=init_flags,
+        method_flags=method_flags,
+        frontend_method_data=frontend_method_data,
+        frontend=frontend,
+        on_device=on_device,
+    )
+
+
 # logaddexp
 @handle_frontend_method(
     class_tree=CLASS_TREE,
Repository: ivy-llc/ivy

Issue:
adjoint
Implement torch.Tensor.adjoint


Discussion:

Resolving patch:
diff --git a/ivy/functional/frontends/torch/tensor.py b/ivy/functional/frontends/torch/tensor.py
--- a/ivy/functional/frontends/torch/tensor.py
+++ b/ivy/functional/frontends/torch/tensor.py
@@ -1566,6 +1566,22 @@ def backward(self, gradient=None, retain_graph=None, create_graph=False):
             else:
                 next_function(_grad_list[idx])
 
+    @with_supported_dtypes(
+        {
+            "2.5.0 and below": (
+                "int64",
+                "float64",
+                "complex128",
+                "float32",
+                "complex64",
+                "int32",
+            )
+        },
+        "paddle",
+    )
+    def adjoint(self):
+        return torch_frontend.adjoint(self)
+
 
 class Size(tuple):
     def __new__(cls, iterable=()):


Test patch:
diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py
--- a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py
+++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py
@@ -10328,3 +10328,38 @@ def test_torch_instance_backward(
         atol=1e-3,
         ground_truth_backend="torch",
     )
+
+
+@handle_frontend_method(
+    class_tree=CLASS_TREE,
+    init_tree="torch.tensor",
+    method_name="adjoint",
+    dtype_and_values=helpers.dtype_and_values(
+        available_dtypes=helpers.get_dtypes("real_and_complex"),
+        min_num_dims=2,
+        min_dim_size=2,
+    ),
+)
+def test_torch_instance_adjoint(
+    dtype_and_values,
+    frontend,
+    frontend_method_data,
+    init_flags,
+    method_flags,
+    on_device,
+):
+    input_dtype, values = dtype_and_values
+
+    helpers.test_frontend_method(
+        init_input_dtypes=input_dtype,
+        init_all_as_kwargs_np={
+            "data": values[0],
+        },
+        method_input_dtypes=input_dtype,
+        method_all_as_kwargs_np={},
+        init_flags=init_flags,
+        method_flags=method_flags,
+        frontend_method_data=frontend_method_data,
+        frontend=frontend,
+        on_device=on_device,
+    )
Repository: ivy-llc/ivy

Issue:
logspace



Discussion:

Resolving patch:
diff --git a/ivy/functional/frontends/paddle/tensor/creation.py b/ivy/functional/frontends/paddle/tensor/creation.py
--- a/ivy/functional/frontends/paddle/tensor/creation.py
+++ b/ivy/functional/frontends/paddle/tensor/creation.py
@@ -131,3 +131,11 @@ def diagflat(x, offset=0, name=None):
 @to_ivy_arrays_and_back
 def meshgrid(*args, **kwargs):
     return ivy.meshgrid(*args, indexing="ij")
+
+
+@with_supported_dtypes(
+    {"2.5.0 and below": ("float32", "float64", "int32", "int64")}, "paddle"
+)
+@to_ivy_arrays_and_back
+def logspace(start, stop, num, base=10.0, dtype=None, name=None):
+    return ivy.logspace(start, stop, num=num, base=base, dtype=dtype)


Test patch:
diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_creation.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_creation.py
--- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_creation.py
+++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_creation.py
@@ -489,3 +489,38 @@ def test_paddle_meshgrid(
         on_device=on_device,
         **args,
     )
+
+
+# logspace
+@handle_frontend_test(
+    fn_tree="paddle.logspace",
+    start=helpers.floats(min_value=-10, max_value=10),
+    stop=helpers.floats(min_value=-10, max_value=10),
+    num=helpers.ints(min_value=1, max_value=5),
+    base=st.floats(min_value=0.1, max_value=10.0),
+    dtype=helpers.get_dtypes("float"),
+    test_with_out=st.just(False),
+)
+def test_paddle_logspace(
+    start,
+    stop,
+    num,
+    base,
+    dtype,
+    frontend,
+    test_flags,
+    fn_tree,
+    on_device,
+):
+    helpers.test_frontend_function(
+        input_dtypes=dtype,
+        frontend=frontend,
+        test_flags=test_flags,
+        fn_tree=fn_tree,
+        on_device=on_device,
+        start=start,
+        stop=stop,
+        num=num,
+        base=base,
+        dtype=dtype[0],
+    )
Repository: ivy-llc/ivy

Issue:
[Bug]: ivy.can_cast
### Bug Explanation

 Function always returns True.

### Steps to Reproduce Bug

```
>>> import numpy as np
>>> import ivy
>>> ivy.can_cast(ivy.float64,ivy.int32)
True
>>> np.can_cast(np.float64,np.int32)
False
```

### Environment

Colab

### Ivy Version

v1.1.9

### Backend

- [ ] NumPy
- [ ] TensorFlow
- [ ] PyTorch
- [ ] JAX

### Device

_No response_


Discussion:

Resolving patch:
diff --git a/ivy/functional/ivy/data_type.py b/ivy/functional/ivy/data_type.py
--- a/ivy/functional/ivy/data_type.py
+++ b/ivy/functional/ivy/data_type.py
@@ -559,8 +559,8 @@ def can_cast(
     if isinstance(from_, (ivy.Array, ivy.NativeArray)):
         from_ = from_.dtype
     try:
-        ivy.promote_types(from_, to)
-        return True
+        dtype = ivy.promote_types(from_, to)
+        return dtype == to
     except KeyError:
         return False
 


Test patch:
Repository: ivy-llc/ivy

Issue:
kl_div



Discussion:

Resolving patch:
diff --git a/ivy/functional/frontends/paddle/nn/functional/loss.py b/ivy/functional/frontends/paddle/nn/functional/loss.py
--- a/ivy/functional/frontends/paddle/nn/functional/loss.py
+++ b/ivy/functional/frontends/paddle/nn/functional/loss.py
@@ -179,3 +179,34 @@ def l1_loss(
     if out.shape == ():
         out = out.expand_dims()
     return paddle.to_tensor(out)
+
+
+@with_supported_dtypes({"2.5.0 and below": ("float32", "float64")}, "paddle")
+@to_ivy_arrays_and_back
+def kl_div(
+    input,
+    label,
+    reduction="mean",
+    name=None,
+):
+    if input.shape != label.shape:
+        raise ValueError(
+            "the shape of input tensor should be equal to target tensor, but found"
+            " inputs with different sizes"
+        )
+
+    out = label * (ivy.log(label) - input)
+
+    size = ivy.shape(input)
+    if len(size) < 1:
+        size = [1]
+
+    if reduction == "mean":
+        out = ivy.mean(out)
+    elif reduction == "batchmean":
+        out = ivy.sum(out) / size[0]
+    elif reduction == "sum":
+        out = ivy.sum(out)
+    else:
+        pass
+    return out.astype(label.dtype)
\ No newline at end of file


Test patch:
diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_nn/test_functional/test_loss.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_nn/test_functional/test_loss.py
--- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_nn/test_functional/test_loss.py
+++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_nn/test_functional/test_loss.py
@@ -297,3 +297,33 @@ def test_paddle_l1_loss(
         label=x[1],
         reduction=reduction,
     )
+
+
+@handle_frontend_test(
+    fn_tree="paddle.nn.functional.kl_div",
+    dtype_and_x=helpers.dtype_and_values(
+        available_dtypes=helpers.get_dtypes("float"),
+        num_arrays=2,
+        shared_dtype=True,
+        min_num_dims=2,
+        max_num_dims=5,
+        min_dim_size=1,
+        max_dim_size=10,
+        min_value=1.0013580322265625e-05,
+    ),
+    reduction=st.sampled_from(["mean", "batchmean", "sum", "none"]),
+)
+def test_paddle_kl_div(
+    dtype_and_x, reduction, on_device, fn_tree, frontend, test_flags
+):
+    input_dtype, x = dtype_and_x
+    helpers.test_frontend_function(
+        input_dtypes=input_dtype,
+        frontend=frontend,
+        test_flags=test_flags,
+        fn_tree=fn_tree,
+        on_device=on_device,
+        input=x[0],
+        label=x[1],
+        reduction=reduction,
+    )
\ No newline at end of file
Repository: ivy-llc/ivy

Issue:
normalize



Discussion:

Resolving patch:
diff --git a/ivy/functional/frontends/paddle/nn/functional/norm.py b/ivy/functional/frontends/paddle/nn/functional/norm.py
--- a/ivy/functional/frontends/paddle/nn/functional/norm.py
+++ b/ivy/functional/frontends/paddle/nn/functional/norm.py
@@ -8,3 +8,11 @@
 @with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle")
 def layer_norm(x, normalized_shape, weight=None, bias=None, epsilon=1e-05, name=None):
     return ivy.layer_norm(x, normalized_shape, weight, bias, epsilon)
+
+
+@to_ivy_arrays_and_back
+@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle")
+def normalize(x, p=2, axis=1, epsilon=1e-12, name=None):
+    if axis < 0:
+        axis = ivy.get_num_dims(x) + axis
+    return ivy.lp_normalize(x, p=p, axis=axis)


Test patch:
diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_nn/test_functional/test_norm.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_nn/test_functional/test_norm.py
--- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_nn/test_functional/test_norm.py
+++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_nn/test_functional/test_norm.py
@@ -43,3 +43,44 @@ def test_paddle_layer_norm(
         bias=offset[0],
         epsilon=eps,
     )
+
+
+# normalize
+@handle_frontend_test(
+    fn_tree="paddle.nn.functional.normalize",
+    dtype_and_x_and_axis=helpers.arrays_and_axes(
+        available_dtypes=helpers.get_dtypes(kind="valid"),
+        num=1,
+        return_dtype=True,
+        force_int_axis=True,
+    ),
+    p=st.floats(min_value=0.1, max_value=2),
+    negative_axis=st.booleans(),
+)
+def test_paddle_normalize(
+    *,
+    dtype_and_x_and_axis,
+    p,
+    negative_axis,
+    test_flags,
+    frontend,
+    backend_fw,
+    on_device,
+    fn_tree,
+):
+    dtype, x, axis = dtype_and_x_and_axis
+    if axis:
+        axis = -axis if negative_axis else axis
+    else:
+        axis = 0
+    helpers.test_frontend_function(
+        input_dtypes=dtype,
+        backend_to_test=backend_fw,
+        frontend=frontend,
+        test_flags=test_flags,
+        on_device=on_device,
+        fn_tree=fn_tree,
+        x=x[0],
+        p=p,
+        axis=axis,
+    )