[Backend Tester] Add more pointwise op tests

ghstack-source-id: 2bdf179
ghstack-comment-id: 3116317028
Pull-Request: #12855

Author: GregoryComer

backends/test/suite/operators/test_abs.py

@@ -0,0 +1,92 @@
+# (c) Meta Platforms, Inc. and affiliates. Confidential and proprietary.
+
+# pyre-strict
+
+from typing import Callable
+
+import torch
+
+from executorch.backends.test.compliance_suite import (
+    dtype_test,
+    operator_test,
+    OperatorTest,
+)
+
+class AbsModel(torch.nn.Module):
+    def __init__(self):
+        super().__init__()
+        
+    def forward(self, x):
+        return torch.abs(x)
+
+@operator_test
+class TestAbs(OperatorTest):
+    @dtype_test
+    def test_abs_dtype(self, dtype, tester_factory: Callable) -> None:
+        # Test with different dtypes
+        model = AbsModel().to(dtype)
+        self._test_op(model, (torch.rand(10, 10).to(dtype) * 2 - 1,), tester_factory)
+        
+    def test_abs_basic(self, tester_factory: Callable) -> None:
+        # Basic test with default parameters
+        # Input: tensor with positive and negative values
+        self._test_op(AbsModel(), (torch.randn(10, 10),), tester_factory)
+        
+    def test_abs_shapes(self, tester_factory: Callable) -> None:
+        # Test with different tensor shapes
+        
+        # 1D tensor
+        self._test_op(AbsModel(), (torch.randn(20),), tester_factory)
+        
+        # 2D tensor
+        self._test_op(AbsModel(), (torch.randn(5, 10),), tester_factory)
+        
+        # 3D tensor
+        self._test_op(AbsModel(), (torch.randn(3, 4, 5),), tester_factory)
+        
+        # 4D tensor
+        self._test_op(AbsModel(), (torch.randn(2, 3, 4, 5),), tester_factory)
+        
+        # 5D tensor
+        self._test_op(AbsModel(), (torch.randn(2, 2, 3, 4, 5),), tester_factory)
+        
+    def test_abs_values(self, tester_factory: Callable) -> None:
+        # Test with different value ranges
+        
+        # Small values
+        self._test_op(AbsModel(), (torch.randn(10, 10) * 0.01,), tester_factory)
+        
+        # Large values
+        self._test_op(AbsModel(), (torch.randn(10, 10) * 1000,), tester_factory)
+        
+        # Mixed positive and negative values
+        self._test_op(AbsModel(), (torch.randn(10, 10) * 10,), tester_factory)
+        
+        # All positive values
+        self._test_op(AbsModel(), (torch.rand(10, 10) * 10,), tester_factory)
+        
+        # All negative values
+        self._test_op(AbsModel(), (torch.rand(10, 10) * -10,), tester_factory)
+        
+        # Values close to zero
+        self._test_op(AbsModel(), (torch.randn(10, 10) * 1e-5,), tester_factory)
+        
+    def test_abs_edge_cases(self, tester_factory: Callable) -> None:
+        # Test edge cases
+        
+        # Zero tensor
+        self._test_op(AbsModel(), (torch.zeros(10, 10),), tester_factory)
+        
+        # Tensor with infinity
+        x = torch.tensor([float('inf'), float('-inf'), 1.0, -1.0])
+        self._test_op(AbsModel(), (x,), tester_factory)
+        
+        # Tensor with NaN
+        x = torch.tensor([float('nan'), 1.0, -1.0])
+        self._test_op(AbsModel(), (x,), tester_factory)
+        
+    def test_abs_scalar(self, tester_factory: Callable) -> None:
+        # Test with scalar input (1-element tensor)
+        self._test_op(AbsModel(), (torch.tensor([-5.0]),), tester_factory)
+        self._test_op(AbsModel(), (torch.tensor([5.0]),), tester_factory)
+        self._test_op(AbsModel(), (torch.tensor([0.0]),), tester_factory)

backends/test/suite/operators/test_ceil.py

@@ -0,0 +1,102 @@
+# (c) Meta Platforms, Inc. and affiliates. Confidential and proprietary.
+
+# pyre-strict
+
+from typing import Callable
+
+import torch
+
+from executorch.backends.test.compliance_suite import (
+    dtype_test,
+    operator_test,
+    OperatorTest,
+)
+
+class CeilModel(torch.nn.Module):
+    def __init__(self):
+        super().__init__()
+        
+    def forward(self, x):
+        return torch.ceil(x)
+
+@operator_test
+class TestCeil(OperatorTest):
+    @dtype_test
+    def test_ceil_dtype(self, dtype, tester_factory: Callable) -> None:
+        # Test with different dtypes
+        model = CeilModel().to(dtype)
+        self._test_op(model, (torch.rand(10, 10).to(dtype) * 2 - 1,), tester_factory)
+        
+    def test_ceil_basic(self, tester_factory: Callable) -> None:
+        # Basic test with default parameters
+        # Input: tensor with fractional values
+        self._test_op(CeilModel(), (torch.randn(10, 10),), tester_factory)
+        
+    def test_ceil_shapes(self, tester_factory: Callable) -> None:
+        # Test with different tensor shapes
+        
+        # 1D tensor
+        self._test_op(CeilModel(), (torch.randn(20),), tester_factory)
+        
+        # 2D tensor
+        self._test_op(CeilModel(), (torch.randn(5, 10),), tester_factory)
+        
+        # 3D tensor
+        self._test_op(CeilModel(), (torch.randn(3, 4, 5),), tester_factory)
+        
+        # 4D tensor
+        self._test_op(CeilModel(), (torch.randn(2, 3, 4, 5),), tester_factory)
+        
+        # 5D tensor
+        self._test_op(CeilModel(), (torch.randn(2, 2, 3, 4, 5),), tester_factory)
+        
+    def test_ceil_values(self, tester_factory: Callable) -> None:
+        # Test with different value ranges
+        
+        # Small fractional values
+        self._test_op(CeilModel(), (torch.rand(10, 10) * 0.01,), tester_factory)
+        
+        # Large fractional values
+        self._test_op(CeilModel(), (torch.randn(10, 10) * 1000,), tester_factory)
+        
+        # Mixed positive and negative values
+        self._test_op(CeilModel(), (torch.randn(10, 10) * 10,), tester_factory)
+        
+        # Values with specific fractional parts
+        self._test_op(CeilModel(), (torch.arange(0, 10, 0.5).reshape(4, 5),), tester_factory)
+        
+        # Values close to integers
+        x = torch.randn(10, 10)
+        x = x.round() + torch.rand(10, 10) * 0.01
+        self._test_op(CeilModel(), (x,), tester_factory)
+        
+    def test_ceil_edge_cases(self, tester_factory: Callable) -> None:
+        # Test edge cases
+        
+        # Integer values
+        self._test_op(CeilModel(), (torch.arange(10).reshape(2, 5).float(),), tester_factory)
+        
+        # Zero tensor
+        self._test_op(CeilModel(), (torch.zeros(10, 10),), tester_factory)
+        
+        # Tensor with infinity
+        x = torch.tensor([float('inf'), float('-inf'), 1.0, -1.0])
+        self._test_op(CeilModel(), (x,), tester_factory)
+        
+        # Tensor with NaN
+        x = torch.tensor([float('nan'), 1.0, -1.0])
+        self._test_op(CeilModel(), (x,), tester_factory)
+        
+        # Values just below integers
+        x = torch.arange(10).float() - 0.01
+        self._test_op(CeilModel(), (x,), tester_factory)
+        
+        # Values just above integers
+        x = torch.arange(10).float() + 0.01
+        self._test_op(CeilModel(), (x,), tester_factory)
+        
+    def test_ceil_scalar(self, tester_factory: Callable) -> None:
+        # Test with scalar input (1-element tensor)
+        self._test_op(CeilModel(), (torch.tensor([1.5]),), tester_factory)
+        self._test_op(CeilModel(), (torch.tensor([-1.5]),), tester_factory)
+        self._test_op(CeilModel(), (torch.tensor([0.0]),), tester_factory)

backends/test/suite/operators/test_clamp.py

@@ -0,0 +1,111 @@
+# (c) Meta Platforms, Inc. and affiliates. Confidential and proprietary.
+
+# pyre-strict
+
+from typing import Callable
+
+import torch
+
+from executorch.backends.test.compliance_suite import (
+    dtype_test,
+    operator_test,
+    OperatorTest,
+)
+
+class ClampModel(torch.nn.Module):
+    def __init__(self, min_val=None, max_val=None):
+        super().__init__()
+        self.min_val = min_val
+        self.max_val = max_val
+        
+    def forward(self, x):
+        return torch.clamp(x, min=self.min_val, max=self.max_val)
+
+@operator_test
+class TestClamp(OperatorTest):
+    @dtype_test
+    def test_clamp_dtype(self, dtype, tester_factory: Callable) -> None:
+        # Test with different dtypes
+        model = ClampModel(min_val=-0.5, max_val=0.5).to(dtype)
+        self._test_op(model, (torch.rand(10, 10).to(dtype) * 2 - 1,), tester_factory)
+        
+    def test_clamp_basic(self, tester_factory: Callable) -> None:
+        # Basic test with default parameters
+        # Input: tensor with values outside the clamp range
+        self._test_op(ClampModel(min_val=-0.5, max_val=0.5), (torch.randn(10, 10),), tester_factory)
+        
+    def test_clamp_min_only(self, tester_factory: Callable) -> None:
+        # Test with only min value specified
+        self._test_op(ClampModel(min_val=0.0), (torch.randn(10, 10),), tester_factory)
+        
+    def test_clamp_max_only(self, tester_factory: Callable) -> None:
+        # Test with only max value specified
+        self._test_op(ClampModel(max_val=0.0), (torch.randn(10, 10),), tester_factory)
+        
+    def test_clamp_shapes(self, tester_factory: Callable) -> None:
+        # Test with different tensor shapes
+        model = ClampModel(min_val=-1.0, max_val=1.0)
+        
+        # 1D tensor
+        self._test_op(model, (torch.randn(20),), tester_factory)
+        
+        # 2D tensor
+        self._test_op(model, (torch.randn(5, 10),), tester_factory)
+        
+        # 3D tensor
+        self._test_op(model, (torch.randn(3, 4, 5),), tester_factory)
+        
+        # 4D tensor
+        self._test_op(model, (torch.randn(2, 3, 4, 5),), tester_factory)
+        
+        # 5D tensor
+        self._test_op(model, (torch.randn(2, 2, 3, 4, 5),), tester_factory)
+        
+    def test_clamp_values(self, tester_factory: Callable) -> None:
+        # Test with different value ranges
+        
+        # Small values with narrow clamp range
+        self._test_op(ClampModel(min_val=-0.01, max_val=0.01), (torch.randn(10, 10) * 0.1,), tester_factory)
+        
+        # Large values with wide clamp range
+        self._test_op(ClampModel(min_val=-100, max_val=100), (torch.randn(10, 10) * 1000,), tester_factory)
+        
+        # Mixed positive and negative values
+        self._test_op(ClampModel(min_val=-5, max_val=5), (torch.randn(10, 10) * 10,), tester_factory)
+        
+        # All values within clamp range
+        self._test_op(ClampModel(min_val=-10, max_val=10), (torch.randn(10, 10),), tester_factory)
+        
+        # All values outside clamp range (below min)
+        self._test_op(ClampModel(min_val=1.0, max_val=2.0), (torch.randn(10, 10) - 10,), tester_factory)
+        
+        # All values outside clamp range (above max)
+        self._test_op(ClampModel(min_val=-2.0, max_val=-1.0), (torch.randn(10, 10) + 10,), tester_factory)
+        
+    def test_clamp_edge_cases(self, tester_factory: Callable) -> None:
+        # Test edge cases
+        
+        # Zero tensor
+        self._test_op(ClampModel(min_val=-1.0, max_val=1.0), (torch.zeros(10, 10),), tester_factory)
+        
+        # Min equals max
+        self._test_op(ClampModel(min_val=0.0, max_val=0.0), (torch.randn(10, 10),), tester_factory)
+        
+        # Tensor with infinity
+        x = torch.tensor([float('inf'), float('-inf'), 1.0, -1.0])
+        self._test_op(ClampModel(min_val=-2.0, max_val=2.0), (x,), tester_factory)
+        
+        # Tensor with NaN
+        x = torch.tensor([float('nan'), 1.0, -1.0])
+        self._test_op(ClampModel(min_val=-2.0, max_val=2.0), (x,), tester_factory)
+        
+        # Values at exactly min/max bounds
+        x = torch.tensor([-1.0, -0.5, 0.0, 0.5, 1.0])
+        self._test_op(ClampModel(min_val=-0.5, max_val=0.5), (x,), tester_factory)
+        
+    def test_clamp_scalar(self, tester_factory: Callable) -> None:
+        # Test with scalar input (1-element tensor)
+        model = ClampModel(min_val=-1.0, max_val=1.0)
+        self._test_op(model, (torch.tensor([-5.0]),), tester_factory)
+        self._test_op(model, (torch.tensor([5.0]),), tester_factory)
+        self._test_op(model, (torch.tensor([0.0]),), tester_factory)