JSTprove 1.0.0__py3-none-macosx_11_0_arm64.whl → 1.1.0__py3-none-macosx_11_0_arm64.whl

python/tests/onnx_quantizer_tests/layers/conv_config.py

@@ -0,0 +1,154 @@
+import numpy as np
+
+from python.core.model_processing.onnx_quantizer.exceptions import InvalidParamError
+from python.tests.onnx_quantizer_tests import TEST_RNG_SEED
+from python.tests.onnx_quantizer_tests.layers.base import (
+    LayerTestSpec,
+    e2e_test,
+    error_test,
+    valid_test,
+)
+from python.tests.onnx_quantizer_tests.layers.factory import (
+    BaseLayerConfigProvider,
+    LayerTestConfig,
+)
+
+
+class ConvConfigProvider(BaseLayerConfigProvider):
+    """Test configuration provider for Conv layers"""
+
+    @property
+    def layer_name(self) -> str:
+        return "Conv"
+
+    def get_config(self) -> LayerTestConfig:
+        rng = np.random.default_rng(TEST_RNG_SEED)
+        return LayerTestConfig(
+            op_type="Conv",
+            valid_inputs=["input", "conv_weight", "conv_bias"],
+            valid_attributes={
+                "strides": [1, 1],
+                "kernel_shape": [3, 3],
+                "dilations": [1, 1],
+                "pads": [1, 1, 1, 1],
+            },
+            required_initializers={
+                "conv_weight": rng.normal(0, 1, (32, 16, 3, 3)),
+                "conv_bias": rng.normal(0, 1, 32),
+            },
+        )
+
+    def get_test_specs(self) -> list[LayerTestSpec]:
+        """Return all test specifications for Conv layers"""
+        rng = np.random.default_rng(TEST_RNG_SEED)
+        return [
+            # Valid variations
+            valid_test("basic")
+            .description("Basic 2D convolution")
+            .tags("basic", "2d")
+            .build(),
+            valid_test("different_padding")
+            .description("Convolution with different padding")
+            .override_attrs(pads=[2, 2, 2, 2], kernel_shape=[5, 5])
+            .override_initializer("conv_weight", rng.normal(0, 1, (32, 16, 5, 5)))
+            .tags("padding", "5x5_kernel")
+            .build(),
+            # E2E test
+            e2e_test("e2e_basic")
+            .description("End-to-end test for basic 2D convolution")
+            .override_input_shapes(input=[1, 3, 4, 4])
+            .override_output_shapes(conv_output=[1, 8, 4, 4])
+            .override_initializer("conv_weight", rng.normal(0, 1, (8, 3, 3, 3)))
+            .override_initializer("conv_bias", rng.normal(0, 1, 8))
+            .tags("e2e", "basic", "2d")
+            .build(),
+            # Error cases
+            error_test("no_bias")
+            .description("2D convolution without bias")
+            .override_inputs("input", "conv_weight")
+            .override_attrs(strides=[2, 2], kernel_shape=[5, 5])
+            .override_initializer("conv_weight", rng.normal(0, 1, (64, 16, 5, 5)))
+            .expects_error(
+                InvalidParamError,
+                "Expected at least 3 inputs (input, weights, bias), got 2",
+            )
+            .tags("no_bias", "stride_2")
+            .build(),
+            error_test("conv3d_unsupported")
+            .description("3D convolution should raise error")
+            .override_attrs(
+                kernel_shape=[3, 3, 3],
+                strides=[1, 1, 1],
+                dilations=[1, 1, 1],
+                pads=[1, 1, 1, 1, 1, 1],
+            )
+            .override_initializer(
+                "conv_weight",
+                rng.normal(0, 1, (32, 16, 3, 3, 3)),
+            )
+            .expects_error(
+                InvalidParamError,
+                "Unsupported Conv weight dimensionality 5",
+            )
+            .tags("3d", "unsupported")
+            .build(),
+            error_test("invalid_stride")
+            .description("Invalid stride values")
+            .override_attrs(strides=[0, 1])
+            .override_inputs("input", "conv_weight")
+            .expects_error(InvalidParamError, "stride must be positive")
+            .tags("invalid_params")
+            .skip("Not yet supported")
+            .build(),
+            error_test("negative_dilation")
+            .description("Negative dilation values")
+            .override_attrs(dilations=[-1, 1])
+            .expects_error(InvalidParamError, "dilation must be positive")
+            .tags("invalid_params")
+            .skip("Not yet supported")
+            .build(),
+            error_test("invalid_kernel_shape_long")
+            .description("kernel_shape too long (length 3)")
+            .override_attrs(kernel_shape=[3, 3, 3])
+            .override_initializer(
+                "conv_weight",
+                rng.normal(0, 1, (32, 16, 3, 3, 3)),
+            )
+            .expects_error(InvalidParamError, "kernel_shape")
+            .tags("invalid_attr_length")
+            .build(),
+            # Missing required attributes
+            error_test("missing_strides")
+            .description("Conv node missing 'strides' attribute")
+            .omit_attrs("strides")  # exclude strides
+            .override_attrs(
+                kernel_shape=[3, 3],
+                dilations=[1, 1],
+                pads=[1, 1, 1, 1],
+            )  # supply others explicitly
+            .expects_error(InvalidParamError, "strides")
+            .tags("missing_attr")
+            .build(),
+            error_test("missing_kernel_shape")
+            .description("Conv node missing 'kernel_shape' attribute")
+            .omit_attrs("kernel_shape")  # exclude kernel_shape
+            .override_attrs(
+                strides=[3, 3],
+                dilations=[1, 1],
+                pads=[1, 1, 1, 1],
+            )  # supply others explicitly
+            .expects_error(InvalidParamError, "kernel_shape")
+            .tags("missing_attr")
+            .build(),
+            error_test("missing_dilations")
+            .description("Conv node missing 'dilations' attribute")
+            .omit_attrs("dilations")  # exclude dilations
+            .override_attrs(
+                strides=[3, 3],
+                kernel_shape=[3, 3],
+                pads=[1, 1, 1, 1],
+            )  # supply others explicitly
+            .expects_error(InvalidParamError, "dilations")
+            .tags("missing_attr")
+            .build(),
+        ]

python/tests/onnx_quantizer_tests/layers/factory.py

@@ -0,0 +1,142 @@
+from __future__ import annotations
+
+import importlib
+import inspect
+import logging
+import typing
+from pathlib import Path
+
+from .base import BaseLayerConfigProvider, LayerTestConfig, LayerTestSpec, SpecType
+
+logger = logging.getLogger(__name__)
+
+
+class TestLayerFactory:
+    """Enhanced factory for creating test configurations for different layer types"""
+
+    _providers: typing.ClassVar = {}
+    _initialized = False
+
+    @classmethod
+    def _discover_providers(cls: TestLayerFactory) -> None:
+        """Automatically discover all BaseLayerConfigProvider subclasses"""
+        if cls._initialized:
+            return
+
+        current_dir = Path(__file__).parent
+        config_files = [
+            f.stem
+            for f in Path(current_dir).iterdir()
+            if f.is_file() and f.name.endswith("_config.py") and f.name != "__init__.py"
+        ]
+        logger.debug("Discovered config files: %s", config_files)
+
+        for module_name in config_files:
+            try:
+                module = importlib.import_module(f".{module_name}", package=__package__)
+
+                for _, obj in inspect.getmembers(module, inspect.isclass):
+                    if (
+                        issubclass(obj, BaseLayerConfigProvider)
+                        and obj is not BaseLayerConfigProvider
+                    ):
+
+                        provider_instance = obj()
+                        cls._providers[provider_instance.layer_name] = provider_instance
+
+            except ImportError as e:  # noqa: PERF203
+                msg = f"Warning: Could not import {module_name}: {e}"
+                logger.warning(msg)
+
+        cls._initialized = True
+
+    # Existing methods (keep your current implementation)
+    @classmethod
+    def get_layer_configs(cls) -> dict[str, LayerTestConfig]:
+        """Get test configurations for all supported layers"""
+        cls._discover_providers()
+        logger.debug("Retrieved layer configs: %s", list(cls._providers.keys()))
+        return {
+            name: provider.get_config() for name, provider in cls._providers.items()
+        }
+
+    @classmethod
+    def get_layer_config(cls, layer_name: str) -> LayerTestConfig:
+        """Get test configuration for a specific layer"""
+        cls._discover_providers()
+        if layer_name not in cls._providers:
+            msg = f"No config provider found for layer: {layer_name}"
+            raise ValueError(msg)
+        return cls._providers[layer_name].get_config()
+
+    @classmethod
+    def get_available_layers(cls) -> list[str]:
+        """Get list of all available layer types"""
+        cls._discover_providers()
+        return list(cls._providers.keys())
+
+    @classmethod
+    def register_provider(cls, provider: BaseLayerConfigProvider) -> None:
+        """Register a new config provider"""
+        cls._providers[provider.layer_name] = provider
+
+    # NEW enhanced methods for test specifications
+    @classmethod
+    def get_all_test_cases(cls) -> list[tuple[str, LayerTestConfig, LayerTestSpec]]:
+        """Get all test cases as (layer_name, config, test_spec) tuples"""
+        cls._discover_providers()
+        test_cases = []
+
+        for layer_name, provider in cls._providers.items():
+            config = provider.get_config()
+            test_specs = provider.get_test_specs()
+
+            # If no test specs defined, create a basic valid test
+            if not test_specs:
+
+                test_specs = [LayerTestSpec("basic", SpecType.VALID, "Basic test")]
+
+            test_cases.extend((layer_name, config, spec) for spec in test_specs)
+
+        return test_cases
+
+    @classmethod
+    def get_test_cases_by_type(
+        cls,
+        test_type: SpecType,
+    ) -> list[tuple[str, LayerTestConfig, LayerTestSpec]]:
+        """Get test cases of a specific type"""
+        return [
+            (layer, config, spec)
+            for layer, config, spec in cls.get_all_test_cases()
+            if spec.spec_type == test_type
+        ]
+
+    @classmethod
+    def get_test_cases_by_layer(
+        cls,
+        layer_name: str,
+    ) -> list[tuple[str, LayerTestConfig, LayerTestSpec]]:
+        """Get test cases for a specific layer"""
+        return [
+            (layer, config, spec)
+            for layer, config, spec in cls.get_all_test_cases()
+            if layer == layer_name
+        ]
+
+    @classmethod
+    def get_test_cases_by_tag(
+        cls,
+        tag: str,
+    ) -> list[tuple[str, LayerTestConfig, LayerTestSpec]]:
+        """Get test cases with a specific tag"""
+        result = [
+            (layer, config, spec)
+            for layer, config, spec in cls.get_all_test_cases()
+            if tag in spec.tags
+        ]
+        logger.debug("Found tests %s", result)
+        if not result:
+            msg = f"No test cases found for tag: {tag}"
+            raise ValueError(msg)
+        return result

python/tests/onnx_quantizer_tests/layers/flatten_config.py

@@ -0,0 +1,61 @@
+from python.tests.onnx_quantizer_tests.layers.base import (
+    e2e_test,
+    valid_test,
+)
+from python.tests.onnx_quantizer_tests.layers.factory import (
+    BaseLayerConfigProvider,
+    LayerTestConfig,
+)
+
+
+class FlattenConfigProvider(BaseLayerConfigProvider):
+    """Test configuration provider for Flatten layers"""
+
+    @property
+    def layer_name(self) -> str:
+        return "Flatten"
+
+    def get_config(self) -> LayerTestConfig:
+        return LayerTestConfig(
+            op_type="Flatten",
+            valid_inputs=["input"],
+            valid_attributes={"axis": 1},
+            required_initializers={},
+        )
+
+    def get_test_specs(self) -> list:
+        return [
+            # --- VALID TESTS ---
+            valid_test("basic")
+            .description("Basic Flatten from (1,3,4,4) to (1,48)")
+            .tags("basic", "flatten")
+            .build(),
+            valid_test("flatten_axis0")
+            .description("Flatten with axis=0 (entire tensor flattened)")
+            .override_attrs(axis=0)
+            .tags("flatten", "axis0")
+            .build(),
+            valid_test("flatten_axis2")
+            .description("Flatten starting at axis=2")
+            .override_attrs(axis=2)
+            .tags("flatten", "axis2")
+            .build(),
+            valid_test("flatten_axis3")
+            .description("Flatten starting at axis=3 (minimal flatten)")
+            .override_attrs(axis=3)
+            .tags("flatten", "axis3")
+            .build(),
+            e2e_test("e2e_basic")
+            .description("End-to-end test for Flatten layer")
+            .override_input_shapes(input=[1, 3, 4, 4])
+            .override_output_shapes(flatten_output=[1, 48])
+            .tags("e2e", "flatten")
+            .build(),
+            # --- EDGE CASE / SKIPPED TEST ---
+            valid_test("large_input")
+            .description("Large input flatten (performance test)")
+            .override_input_shapes(input=[1, 3, 256, 256])
+            .tags("flatten", "large", "performance")
+            .skip("Performance test, skipped by default")
+            .build(),
+        ]

python/tests/onnx_quantizer_tests/layers/gemm_config.py

@@ -0,0 +1,160 @@
+import numpy as np
+
+from python.core.model_processing.onnx_quantizer.exceptions import InvalidParamError
+from python.tests.onnx_quantizer_tests import TEST_RNG_SEED
+from python.tests.onnx_quantizer_tests.layers.base import (
+    LayerTestSpec,
+    e2e_test,
+    error_test,
+    valid_test,
+)
+from python.tests.onnx_quantizer_tests.layers.factory import (
+    BaseLayerConfigProvider,
+    LayerTestConfig,
+)
+
+
+class GemmConfigProvider(BaseLayerConfigProvider):
+    """Test configuration provider for Gemm layers"""
+
+    @property
+    def layer_name(self) -> str:
+        return "Gemm"
+
+    def get_config(self) -> LayerTestConfig:
+        rng = np.random.default_rng(TEST_RNG_SEED)
+        return LayerTestConfig(
+            op_type="Gemm",
+            valid_inputs=["input", "gemm_weight", "gemm_bias"],
+            valid_attributes={"alpha": 1.0, "beta": 1.0, "transA": 0, "transB": 0},
+            required_initializers={
+                "gemm_weight": rng.normal(0, 1, (128, 256)),
+                "gemm_bias": rng.normal(0, 1, (1, 256)),
+            },
+            input_shapes={"input": [1, 128]},  # Match weight input dimension K=128
+            output_shapes={
+                "gemm_output": [1, 256],
+            },  # Match weight output dimension N=256
+        )
+
+    def get_test_specs(self) -> list[LayerTestSpec]:
+        """Return test specifications for Gemm layers"""
+        rng = np.random.default_rng(TEST_RNG_SEED)
+        return [
+            # --- VALID TESTS ---
+            valid_test("basic")
+            .description("Basic Gemm operation (no transposes, alpha=1, beta=1)")
+            .tags("basic")
+            .build(),
+            valid_test("transposed_weights")
+            .description("Gemm with transposed weight matrix (transB=1)")
+            .override_attrs(transB=1)
+            .override_initializer(
+                "gemm_weight",
+                rng.normal(0, 1, (256, 128)),
+            )  # Transposed shape
+            .tags("transpose", "transB")
+            .build(),
+            valid_test("transposed_input")
+            .description("Gemm with transposed input (transA=1)")
+            .override_attrs(transA=1)
+            .override_input_shapes(input=[128, 1])  # Aᵀ shape → (K, M)
+            .override_output_shapes(gemm_output=[1, 256])
+            .tags("transpose", "transA")
+            .build(),
+            valid_test("double_transpose")
+            .description("Gemm with transA=1 and transB=1")
+            .override_attrs(transA=1, transB=1)
+            .override_input_shapes(input=[128, 1])
+            .override_initializer("gemm_weight", rng.normal(0, 1, (256, 128)))
+            .override_output_shapes(gemm_output=[1, 256])
+            .tags("transpose", "transA", "transB")
+            .build(),
+            e2e_test("e2e_basic")
+            .description("End-to-end test for basic Gemm layer")
+            .override_attrs(alpha=1.0, beta=1.0, transA=0, transB=0)
+            .override_input_shapes(input=[1, 4])
+            .override_output_shapes(gemm_output=[1, 8])
+            .override_initializer("gemm_weight", rng.normal(0, 1, (4, 8)))
+            .override_initializer("gemm_bias", rng.normal(0, 1, (1, 8)))
+            .tags("e2e", "basic")
+            .build(),
+            e2e_test("e2e_transA_small")
+            .description("Small end-to-end Gemm test with transposed input (transA=1)")
+            .override_attrs(transA=1, transB=0, alpha=1.0, beta=1.0)
+            .override_input_shapes(input=[4, 1])  # A^T shape → (K, M)
+            .override_output_shapes(gemm_output=[1, 6])
+            .override_initializer("gemm_weight", rng.normal(0, 1, (4, 6)))
+            .override_initializer("gemm_bias", rng.normal(0, 1, (1, 6)))
+            .tags("e2e", "transpose", "transA", "small")
+            .build(),
+            e2e_test("e2e_transB_small")
+            .description(
+                "Small end-to-end Gemm test with transposed weights (transB=1)",
+            )
+            .override_attrs(transA=0, transB=1, alpha=1.0, beta=1.0)
+            .override_input_shapes(input=[1, 4])  # A shape
+            .override_output_shapes(gemm_output=[1, 6])
+            .override_initializer("gemm_weight", rng.normal(0, 1, (6, 4)))  # B^T shape
+            .override_initializer("gemm_bias", rng.normal(0, 1, (1, 6)))
+            .tags("e2e", "transpose", "transB", "small")
+            .build(),
+            e2e_test("e2e_transA_transB_small")
+            .description("Small end-to-end Gemm test with both matrices transposed")
+            .override_attrs(transA=1, transB=1, alpha=1.0, beta=1.0)
+            .override_input_shapes(input=[4, 1])  # A^T shape
+            .override_output_shapes(gemm_output=[1, 6])
+            .override_initializer("gemm_weight", rng.normal(0, 1, (6, 4)))  # B^T shape
+            .override_initializer("gemm_bias", rng.normal(0, 1, (1, 6)))
+            .tags("e2e", "transpose", "transA", "transB", "small")
+            .build(),
+            # --- ERROR TESTS ---
+            # Add check on weights matrix in check_supported
+            error_test("invalid_alpha_type")
+            .description("Invalid alpha type (should be numeric)")
+            .override_attrs(alpha=-1.0)
+            .expects_error(
+                InvalidParamError,
+                "alpha value of -1.0 not supported [Attribute: alpha] [Expected: 1.0]",
+            )
+            .tags("invalid_param", "alpha")
+            .build(),
+            error_test("no_bias")
+            .description("Gemm without bias term (beta=0 should ignore bias)")
+            .override_inputs("input", "gemm_weight")
+            .override_attrs(beta=0.0)
+            .expects_error(InvalidParamError, match="3 inputs")
+            .tags("no_bias")
+            .build(),
+            error_test("different_alpha_beta")
+            .description("Gemm with different alpha and beta scaling factors")
+            .override_attrs(alpha=0.5, beta=2.0)
+            .expects_error(
+                InvalidParamError,
+                "alpha value of 0.5 not supported [Attribute: alpha] [Expected: 1.0]",
+            )
+            .tags("scaling", "alpha_beta")
+            .build(),
+            error_test("invalid_transA_value")
+            .description("transA must be 0 or 1")
+            .override_attrs(transA=2)
+            .expects_error(InvalidParamError, "transA value of 2 not supported")
+            .tags("transpose", "invalid_attr")
+            .build(),
+            error_test("invalid_transB_value")
+            .description("transB must be 0 or 1")
+            .override_attrs(transB=-1)
+            .expects_error(InvalidParamError, "transB value of -1 not supported")
+            .tags("transpose", "invalid_attr")
+            .build(),
+            # --- EDGE CASE / SKIPPED TESTS ---
+            valid_test("large_matrix")
+            .description("Large matrix multiplication performance test")
+            .override_initializer("gemm_weight", rng.normal(0, 1, (1024, 2048)))
+            .override_initializer("gemm_bias", rng.normal(0, 1, (1, 2048)))
+            .override_input_shapes(input=[1, 1024])
+            .override_output_shapes(gemm_output=[1, 2048])
+            .tags("large", "performance")
+            .skip("Performance test, not run by default")
+            .build(),
+        ]

python/tests/onnx_quantizer_tests/layers/maxpool_config.py

@@ -0,0 +1,82 @@
+from python.core.model_processing.onnx_quantizer.exceptions import InvalidParamError
+from python.tests.onnx_quantizer_tests.layers.base import (
+    e2e_test,
+    error_test,
+    valid_test,
+)
+from python.tests.onnx_quantizer_tests.layers.factory import (
+    BaseLayerConfigProvider,
+    LayerTestConfig,
+)
+
+
+class MaxPoolConfigProvider(BaseLayerConfigProvider):
+    """Test configuration provider for MaxPool layers"""
+
+    @property
+    def layer_name(self) -> str:
+        return "MaxPool"
+
+    def get_config(self) -> LayerTestConfig:
+        return LayerTestConfig(
+            op_type="MaxPool",
+            valid_inputs=["input"],
+            valid_attributes={
+                "kernel_shape": [2, 2],
+                "strides": [2, 2],
+                "dilations": [1, 1],
+                "pads": [0, 0, 0, 0],
+            },
+            required_initializers={},
+        )
+
+    def get_test_specs(self) -> list:
+        return [
+            # --- VALID TESTS ---
+            valid_test("basic")
+            .description("Basic MaxPool with 2x2 kernel and stride 2")
+            .tags("basic", "pool", "2d")
+            .build(),
+            valid_test("larger_kernel")
+            .description("MaxPool with 3x3 kernel and stride 1")
+            .override_attrs(kernel_shape=[3, 3], strides=[1, 1])
+            .tags("kernel_3x3", "stride_1", "pool")
+            .build(),
+            valid_test("dilated_pool")
+            .description("MaxPool with dilation > 1")
+            .override_attrs(dilations=[2, 2])
+            .tags("dilation", "pool")
+            .build(),
+            valid_test("stride_one")
+            .description("MaxPool with stride 1 (overlapping windows)")
+            .override_attrs(strides=[1, 1])
+            .tags("stride_1", "pool", "overlap")
+            .build(),
+            e2e_test("e2e_basic")
+            .description("End-to-end test for 2D MaxPool")
+            .override_input_shapes(input=[1, 3, 4, 4])
+            .override_output_shapes(maxpool_output=[1, 3, 2, 2])
+            .tags("e2e", "pool", "2d")
+            .build(),
+            # # --- ERROR TESTS ---
+            error_test("asymmetric_padding")
+            .description("MaxPool with asymmetric padding")
+            .override_attrs(pads=[1, 0, 2, 1])
+            .expects_error(InvalidParamError, "pads[2]=2 >= kernel[0]=2")
+            .tags("padding", "asymmetric", "pool")
+            .build(),
+            error_test("invalid_kernel_shape")
+            .description("Invalid kernel shape length (3D instead of 2D)")
+            .override_attrs(kernel_shape=[2, 2, 2])
+            .expects_error(InvalidParamError, "Currently only MaxPool2D is supported")
+            .tags("invalid_attr_length", "kernel_shape")
+            .build(),
+            # --- EDGE CASE / SKIPPED TEST ---
+            valid_test("large_input")
+            .description("Large MaxPool input (performance/stress test)")
+            .override_input_shapes(input=[1, 3, 64, 64])
+            .override_attrs(kernel_shape=[3, 3], strides=[2, 2])
+            .tags("large", "performance", "pool")
+            .skip("Performance test, skipped by default")
+            .build(),
+        ]

python/tests/onnx_quantizer_tests/layers/relu_config.py

@@ -0,0 +1,61 @@
+from python.tests.onnx_quantizer_tests.layers.base import (
+    e2e_test,
+    valid_test,
+)
+from python.tests.onnx_quantizer_tests.layers.factory import (
+    BaseLayerConfigProvider,
+    LayerTestConfig,
+)
+
+
+class ReluConfigProvider(BaseLayerConfigProvider):
+    """Test configuration provider for Relu layers"""
+
+    @property
+    def layer_name(self) -> str:
+        return "Relu"
+
+    def get_config(self) -> LayerTestConfig:
+        return LayerTestConfig(
+            op_type="Relu",
+            valid_inputs=["input"],
+            valid_attributes={},
+            required_initializers={},
+        )
+
+    def get_test_specs(self) -> list:
+        return [
+            # --- VALID TESTS ---
+            valid_test("basic")
+            .description("Basic ReLU activation")
+            .tags("basic", "activation")
+            .build(),
+            valid_test("negative_inputs")
+            .description("ReLU should zero out negative input values")
+            .override_input_shapes(input=[1, 3, 4, 4])
+            .tags("activation", "negative_values")
+            .build(),
+            valid_test("high_dimension_input")
+            .description("ReLU applied to a 5D input tensor (NCHWT layout)")
+            .override_input_shapes(input=[1, 3, 4, 4, 2])
+            .tags("activation", "high_dim", "5d")
+            .build(),
+            valid_test("scalar_input")
+            .description("ReLU with scalar input (edge case)")
+            .override_input_shapes(input=[1])
+            .tags("activation", "scalar")
+            .build(),
+            e2e_test("e2e_basic")
+            .description("End-to-end test for ReLU activation")
+            .override_input_shapes(input=[1, 3, 4, 4])
+            .override_output_shapes(relu_output=[1, 3, 4, 4])
+            .tags("e2e", "activation")
+            .build(),
+            # --- EDGE CASE / SKIPPED TEST ---
+            valid_test("large_input")
+            .description("Large input tensor for ReLU (performance/stress test)")
+            .override_input_shapes(input=[1, 3, 512, 512])
+            .tags("large", "performance", "activation")
+            .skip("Performance test, skipped by default")
+            .build(),
+        ]