issue/497 - now requires test function definition

Author: wooway777

test/infinicore/framework/base.py

@@ -2,7 +2,7 @@
 import infinicore
 
 from abc import ABC, abstractmethod
-from typing import List, Dict, Any, Tuple, Union
+from typing import List, Dict, Any, Tuple, Union, Callable, Optional
 
 from .datatypes import to_torch_dtype, to_infinicore_dtype
 from .devices import InfiniDeviceNames, torch_device_map
@@ -66,12 +66,12 @@ class TestCase:
 
     def __init__(self, inputs, output=None, **kwargs):
         """
-        简化构造函数
+        Simplified constructor
         Args:
-            inputs: List[TensorSpec] 或简单的形状元组
-            output: TensorSpec 或形状元组
+            inputs: List[TensorSpec] or simple shape tuples
+            output: TensorSpec or shape tuple
         """
-        # 标准化 inputs
+        # Normalize inputs
         self.inputs = []
         for inp in inputs:
             if isinstance(inp, (list, tuple)):
@@ -81,7 +81,7 @@ def __init__(self, inputs, output=None, **kwargs):
             else:
                 self.inputs.append(inp)
 
-        # 标准化 output
+        # Normalize output
         if isinstance(output, (list, tuple)):
             self.output = TensorSpec.from_tensor(output)
         else:
@@ -142,11 +142,11 @@ def __init__(self, test_cases, test_config):
         self.config = test_config
         self.failed_tests = []  # Track failures
 
-    def run_tests(self, devices, test_func):
+    def run_tests(self, devices, test_func, test_type="Test"):
         """Run tests and track failures"""
         for device in devices:
             print(f"\n{'='*60}")
-            print(f"Testing on {InfiniDeviceNames[device]}")
+            print(f"Testing {test_type} on {InfiniDeviceNames[device]}")
             print(f"{'='*60}")
 
             # Filter unsupported data types
@@ -213,15 +213,17 @@ def get_tolerance_map(self):
         """Return tolerance configuration"""
         pass
 
-    @abstractmethod
-    def torch_operator(self, *inputs, **kwargs):
-        """PyTorch operator implementation"""
-        pass
+    def has_out_of_place_test(self):
+        """Check if out-of-place test functions are defined"""
+        return hasattr(self, "torch_operator_out_of_place") and hasattr(
+            self, "infinicore_operator_out_of_place"
+        )
 
-    @abstractmethod
-    def infinicore_operator(self, *inputs, **kwargs):
-        """Infinicore operator implementation"""
-        pass
+    def has_inplace_test(self):
+        """Check if in-place test functions are defined"""
+        return hasattr(self, "torch_operator_inplace") and hasattr(
+            self, "infinicore_operator_inplace"
+        )
 
     def create_strided_tensor(self, shape, strides, dtype, device_str):
         """Create a non-contiguous tensor with specific strides"""
@@ -274,16 +276,19 @@ def prepare_inputs(self, test_case, device_str, dtype):
 
         return inputs, test_case.kwargs
 
-    def run_test(self, device, test_case, dtype, config):
-        """Generic test execution flow with flexible inputs - output is always contiguous"""
+    def run_out_of_place_test(self, device, test_case, dtype, config):
+        """Generic out-of-place test execution flow"""
+        if not self.has_out_of_place_test():
+            raise NotImplementedError("Out-of-place test functions not defined")
+
         device_str = torch_device_map[device]
 
         # Prepare inputs
         inputs, kwargs = self.prepare_inputs(test_case, device_str, dtype)
 
-        # PyTorch reference result - output is always contiguous for out-of-place
+        # PyTorch reference result
         def torch_op():
-            return self.torch_operator(*inputs, **kwargs)
+            return self.torch_operator_out_of_place(*inputs, **kwargs)
 
         torch_result = torch_op()
 
@@ -310,36 +315,39 @@ def torch_op():
             else:
                 infini_inputs.append(inp)
 
-        # Infinicore result - output is always contiguous for out-of-place
+        # Infinicore result
         def infini_op():
-            return self.infinicore_operator(*infini_inputs, **kwargs)
+            return self.infinicore_operator_out_of_place(*infini_inputs, **kwargs)
 
         infini_result = infini_op()
 
         # Result comparison
         compare_fn = create_test_comparator(config, dtype)
         is_valid = compare_fn(infini_result, torch_result)
-        assert is_valid, f"{self.operator_name} test failed"
+        assert is_valid, f"{self.operator_name} out-of-place test failed"
 
         # Performance testing
         if config.bench:
             profile_operation(
-                f"PyTorch {self.operator_name}",
+                f"PyTorch {self.operator_name} Out-of-place",
                 torch_op,
                 device_str,
                 config.num_prerun,
                 config.num_iterations,
             )
             profile_operation(
-                f"Infinicore {self.operator_name}",
+                f"Infinicore {self.operator_name} Out-of-place",
                 infini_op,
                 device_str,
                 config.num_prerun,
                 config.num_iterations,
             )
 
     def run_inplace_test(self, device, test_case, dtype, config):
-        """Generic in-place operation test execution flow - supports strided output"""
+        """Generic in-place operation test execution flow"""
+        if not self.has_inplace_test():
+            raise NotImplementedError("In-place test functions not defined")
+
         device_str = torch_device_map[device]
 
         # Prepare inputs and output
@@ -370,7 +378,7 @@ def run_inplace_test(self, device, test_case, dtype, config):
             torch_preallocated.zero_()
 
         def torch_op_inplace():
-            self.torch_operator(*inputs, out=torch_preallocated, **kwargs)
+            self.torch_operator_inplace(*inputs, out=torch_preallocated, **kwargs)
 
         torch_op_inplace()
 
@@ -392,19 +400,7 @@ def torch_op_inplace():
             else:
                 infini_inputs.append(inp)
 
-        # # Create infinicore output tensor
-        # if test_case.output.is_contiguous or test_case.output.strides is None:
-        #     infini_output = infinicore.empty(
-        #         output_shape, dtype=dtype, device=infinicore.device(device_str, 0)
-        #     )
-        # else:
-        #     infini_output = infinicore.strided_empty(
-        #         output_shape,
-        #         test_case.output.strides,
-        #         dtype=dtype,
-        #         device=infinicore.device(device_str, 0),
-        #     )
-
+        # Create infinicore output tensor
         torch_dummy = torch.zeros(output_shape, dtype=output_dtype, device=device_str)
         if test_case.output.is_contiguous or test_case.output.strides is None:
             infini_output = create_infinicore_tensor(torch_dummy, device_str)
@@ -413,7 +409,9 @@ def torch_op_inplace():
             infini_output = create_strided_infinicore_tensor(torch_dummy, device_str)
 
         def infini_op_inplace():
-            self.infinicore_operator(*infini_inputs, out=infini_output, **kwargs)
+            self.infinicore_operator_inplace(
+                *infini_inputs, out=infini_output, **kwargs
+            )
 
         infini_op_inplace()
 

test/infinicore/framework/runner.py

@@ -34,15 +34,29 @@ def run(self):
         print(f"Starting {self.operator_test.operator_name} tests...")
         all_passed = True
 
-        # Run out-of-place tests
-        print(f"\n--- Testing Out-of-place {self.operator_test.operator_name} ---")
-        out_of_place_passed = runner.run_tests(devices, self.operator_test.run_test)
-        all_passed = all_passed and out_of_place_passed
-
-        # Run in-place tests
-        print(f"\n--- Testing In-place {self.operator_test.operator_name} ---")
-        in_place_passed = runner.run_tests(devices, self.operator_test.run_inplace_test)
-        all_passed = all_passed and in_place_passed
+        # Run out-of-place tests if defined
+        if self.operator_test.has_out_of_place_test():
+            print(f"\n--- Testing Out-of-place {self.operator_test.operator_name} ---")
+            out_of_place_passed = runner.run_tests(
+                devices, self.operator_test.run_out_of_place_test, "Out-of-place"
+            )
+            all_passed = all_passed and out_of_place_passed
+        else:
+            print(
+                f"\n--- Skipping Out-of-place {self.operator_test.operator_name} (not defined) ---"
+            )
+
+        # Run in-place tests if defined
+        if self.operator_test.has_inplace_test():
+            print(f"\n--- Testing In-place {self.operator_test.operator_name} ---")
+            in_place_passed = runner.run_tests(
+                devices, self.operator_test.run_inplace_test, "In-place"
+            )
+            all_passed = all_passed and in_place_passed
+        else:
+            print(
+                f"\n--- Skipping In-place {self.operator_test.operator_name} (not defined) ---"
+            )
 
         # Print summary
         summary_passed = runner.print_summary()

test/infinicore/ops/add.py

@@ -3,19 +3,17 @@
 
 sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
 
+import torch
 import infinicore
 from framework import create_test_cases
-from framework.templates import BinaryOperatorTest
+from framework.base import BaseOperatorTest
 from framework.runner import GenericTestRunner
 
 # ==============================================================================
 # Operator-specific configuration
 # ==============================================================================
 
-# Test cases in flexible format:
-# - Single shape tuple: (13, 4) → automatically expands to ((13, 4), None, None, None)
-# - Nested single shape: ((13, 4),) → automatically expands to ((13, 4), None, None, None)
-# - Full format: ((13, 4), None, None, None) or ((13, 4), (10, 1), (10, 1), (10, 1))
+# Test cases in flexible format
 _TEST_CASES_DATA = [
     ((13, 4)),
     ((13, 4), (10, 1), (10, 1), (10, 1)),
@@ -32,16 +30,14 @@
 ]
 
 # Parameter mapping configuration for add operator
-# Format: (shape, a_stride, b_stride, c_stride)
-# Call signature: add(input, other)
 _ADD_PARAMETER_MAPPING = (
-    "add",  # operator_name
-    "add(input, other)",  # call_signature
-    [  # input_configs
-        {"shape": 0, "stride": 1},  # input: shape from index 0, stride from index 1
-        {"shape": 0, "stride": 2},  # other: shape from index 0, stride from index 2
+    "add",
+    "add(input, other)",
+    [
+        {"shape": 0, "stride": 1},
+        {"shape": 0, "stride": 2},
     ],
-    {"shape": 0, "stride": 3},  # output: shape from index 0, stride from index 3
+    {"shape": 0, "stride": 3},
 )
 
 # Parse test cases using add parameter mapping
@@ -58,15 +54,40 @@
 }
 
 # ==============================================================================
-# Operator test class
+# Operator test class with specific test functions
 # ==============================================================================
 
 
-class AddTest(BinaryOperatorTest):
-    """Add test"""
+class AddTest(BaseOperatorTest):
+    """Add test with operator-specific test functions"""
 
     def __init__(self):
-        super().__init__("add", _TEST_CASES, _TENSOR_DTYPES, _TOLERANCE_MAP)
+        super().__init__("add")
+
+    def get_test_cases(self):
+        return _TEST_CASES
+
+    def get_tensor_dtypes(self):
+        return _TENSOR_DTYPES
+
+    def get_tolerance_map(self):
+        return _TOLERANCE_MAP
+
+    def torch_operator_inplace(self, a, b, out=None, **kwargs):
+        """PyTorch in-place add operation"""
+        torch.add(a, b, out=out)
+
+    def infinicore_operator_inplace(self, a, b, out=None, **kwargs):
+        """Infinicore in-place add operation"""
+        infinicore.add(a, b, out=out)
+
+    def torch_operator_out_of_place(self, a, b, **kwargs):
+        """PyTorch out-of-place add operation"""
+        return torch.add(a, b)
+
+    def infinicore_operator_out_of_place(self, a, b, **kwargs):
+        """Infinicore out-of-place add operation"""
+        return infinicore.add(a, b)
 
 
 # ==============================================================================

test/infinicore/ops/matmul.py

@@ -3,9 +3,10 @@
 
 sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
 
+import torch
 import infinicore
 from framework import create_test_cases
-from framework.templates import BinaryOperatorTest
+from framework.base import BaseOperatorTest
 from framework.runner import GenericTestRunner
 
 # ==============================================================================
@@ -50,15 +51,40 @@
 }
 
 # ==============================================================================
-# Operator test class
+# Operator test class with specific test functions
 # ==============================================================================
 
 
-class MatmulTest(BinaryOperatorTest):
-    """Matmul test"""
+class MatmulTest(BaseOperatorTest):
+    """Matmul test with operator-specific test functions"""
 
     def __init__(self):
-        super().__init__("matmul", _TEST_CASES, _TENSOR_DTYPES, _TOLERANCE_MAP)
+        super().__init__("matmul")
+
+    def get_test_cases(self):
+        return _TEST_CASES
+
+    def get_tensor_dtypes(self):
+        return _TENSOR_DTYPES
+
+    def get_tolerance_map(self):
+        return _TOLERANCE_MAP
+
+    def torch_operator_inplace(self, a, b, out=None, **kwargs):
+        """PyTorch in-place matmul operation"""
+        torch.matmul(a, b, out=out)
+
+    def infinicore_operator_inplace(self, a, b, out=None, **kwargs):
+        """Infinicore in-place matmul operation"""
+        infinicore.matmul(a, b, out=out)
+
+    def torch_operator_out_of_place(self, a, b, **kwargs):
+        """PyTorch out-of-place matmul operation"""
+        return torch.matmul(a, b)
+
+    def infinicore_operator_out_of_place(self, a, b, **kwargs):
+        """Infinicore out-of-place matmul operation"""
+        return infinicore.matmul(a, b)
 
 
 # ==============================================================================