JSTprove 1.2.0__py3-none-macosx_11_0_arm64.whl → 1.4.0__py3-none-macosx_11_0_arm64.whl

python/tests/circuit_parent_classes/test_ort_custom_layers.py

@@ -1,115 +1,97 @@
-import pytest
+from pathlib import Path
+
 import numpy as np
-import torch
 import onnx
-
-from onnx import TensorProto, shape_inference, helper, numpy_helper
+import pytest
+import torch
+from onnx import TensorProto, helper, shape_inference
 
 from python.core.model_processing.converters.onnx_converter import ONNXConverter
-from python.core.model_processing.onnx_custom_ops.onnx_helpers import extract_shape_dict
-from python.core.model_processing.onnx_quantizer.onnx_op_quantizer import ONNXOpQuantizer
-
-from onnxruntime import InferenceSession, SessionOptions
-from onnxruntime_extensions import get_library_path, OrtPyFunction
-from python.core.model_processing.onnx_custom_ops import conv
-
-from python.core.model_processing.onnx_custom_ops.conv import int64_conv
-from python.core.model_processing.onnx_custom_ops.gemm import int64_gemm7
 
 
 @pytest.fixture
-def tiny_conv_model_path(tmp_path):
+def tiny_conv_model_path(tmp_path: Path) -> Path:
     # Create input and output tensor info
-    input_tensor = helper.make_tensor_value_info('X', TensorProto.FLOAT, [1, 1, 4, 4])
-    output_tensor = helper.make_tensor_value_info('Y', TensorProto.FLOAT, [1, 1, 2, 2])
+    input_tensor = helper.make_tensor_value_info("X", TensorProto.FLOAT, [1, 1, 4, 4])
+    output_tensor = helper.make_tensor_value_info("Y", TensorProto.FLOAT, [1, 1, 2, 2])
 
     # Kernel weights (3x3 ones)
-    W_init = helper.make_tensor(
-        name='W',
+    w_init = helper.make_tensor(
+        name="W",
         data_type=TensorProto.FLOAT,
         dims=[1, 1, 3, 3],
-        vals=np.ones((1 * 1 * 3 * 3), dtype=np.float32).tolist()
+        vals=np.ones((1 * 1 * 3 * 3), dtype=np.float32).tolist(),
     )
-    Z_init = helper.make_tensor(
-        name='Z',
+    z_init = helper.make_tensor(
+        name="Z",
         data_type=TensorProto.FLOAT,
         dims=[1],
-        vals=np.ones(( 1), dtype=np.float32).tolist()
+        vals=np.ones((1), dtype=np.float32).tolist(),
     )
 
     # Conv node with no padding, stride 1
     conv_node = helper.make_node(
-        'Conv',
-        inputs=['X', 'W', 'Z'],
-        outputs=['Y'],
+        "Conv",
+        inputs=["X", "W", "Z"],
+        outputs=["Y"],
         kernel_shape=[3, 3],
         pads=[0, 0, 0, 0],
         strides=[1, 1],
-        dilations = [1,1]
+        dilations=[1, 1],
     )
 
     # Build graph and model
     graph = helper.make_graph(
         nodes=[conv_node],
-        name='TinyConvGraph',
+        name="TinyConvGraph",
         inputs=[input_tensor],
         outputs=[output_tensor],
-        initializer=[W_init, Z_init]
+        initializer=[w_init, z_init],
     )
 
-    model = helper.make_model(graph, producer_name='tiny-conv-example')
+    model = helper.make_model(graph, producer_name="tiny-conv-example")
 
     # Save to a temporary file
     model_path = tmp_path / "tiny_conv.onnx"
     onnx.save(model, str(model_path))
 
-    return str(model_path)
+    return model_path
+
 
 @pytest.mark.integration
-def test_tiny_conv(tiny_conv_model_path):
+def test_tiny_conv(tiny_conv_model_path: Path, tmp_path: Path) -> None:
     path = tiny_conv_model_path
 
     converter = ONNXConverter()
 
-    X_input = np.arange(16, dtype=np.float32).reshape(1, 1, 4, 4)
-    id_count = 0
+    # Load and validate original model
     model = onnx.load(path)
-    # Fix, can remove this next line 
-    onnx.checker.check_model(model)
-
-    # Check the model and print Y"s shape information
     onnx.checker.check_model(model)
-    print(f"Before shape inference, the shape info of Y is:\n{model.graph.value_info}")
 
-    # Apply shape inference on the model
+    # Apply shape inference and validate
     inferred_model = shape_inference.infer_shapes(model)
-
-    # Check the model and print Y"s shape information
     onnx.checker.check_model(inferred_model)
-    # print(f"After shape inference, the shape info of Y is:\n{inferred_model.graph.value_info}")
-    
-
-    domain_to_version = {opset.domain: opset.version for opset in model.opset_import}
-    
-    inferred_model = shape_inference.infer_shapes(model)
-    output_name_to_shape = extract_shape_dict(inferred_model)
-    id_count = 0
 
+    # Quantize and add custom domain
     new_model = converter.quantize_model(model, 2, 21)
     custom_domain = onnx.helper.make_operatorsetid(domain="ai.onnx.contrib", version=1)
     new_model.opset_import.append(custom_domain)
     onnx.checker.check_model(new_model)
 
-    with open("model.onnx", "wb") as f:
+    # Save quantized model
+    out_path = tmp_path / "model_quant.onnx"
+    with out_path.open("wb") as f:
         f.write(new_model.SerializeToString())
 
-    model = onnx.load("model.onnx")
-    onnx.checker.check_model(model)  # This throws a descriptive error
+    # Reload quantized model to ensure it is valid
+    model_quant = onnx.load(str(out_path))
+    onnx.checker.check_model(model_quant)
 
+    # Prepare inputs and compare outputs
     inputs = np.arange(16, dtype=np.float32).reshape(1, 1, 4, 4)
     outputs_true = converter.run_model_onnx_runtime(path, inputs)
+    outputs_quant = converter.run_model_onnx_runtime(out_path, inputs)
 
-    outputs_quant = converter.run_model_onnx_runtime("model.onnx", inputs)
     true = torch.tensor(np.array(outputs_true), dtype=torch.float32)
     quant = torch.tensor(np.array(outputs_quant), dtype=torch.float32) / (2**21)
 

python/tests/onnx_quantizer_tests/layers/base.py

@@ -113,9 +113,7 @@ class LayerTestConfig:
         # respect that; otherwise use original valid_inputs.
         inputs = test_spec.input_overrides or self.valid_inputs
 
-        # Prepare attributes
-        attrs = {**self.valid_attributes, **test_spec.attr_overrides}
-        # Remove omitted attributes if specified
+        # Prepare attributes and remove omitted attributes if specified
         attrs = {**self.valid_attributes, **test_spec.attr_overrides}
         for key in getattr(test_spec, "omit_attrs", []):
             attrs.pop(key, None)

python/tests/onnx_quantizer_tests/layers/clip_config.py

@@ -0,0 +1,127 @@
+from __future__ import annotations
+
+import numpy as np
+
+from python.tests.onnx_quantizer_tests import TEST_RNG_SEED
+from python.tests.onnx_quantizer_tests.layers.base import (
+    e2e_test,
+    edge_case_test,
+    valid_test,
+)
+from python.tests.onnx_quantizer_tests.layers.factory import (
+    BaseLayerConfigProvider,
+    LayerTestConfig,
+)
+
+
+class ClipConfigProvider(BaseLayerConfigProvider):
+    """Test configuration provider for elementwise Clip."""
+
+    @property
+    def layer_name(self) -> str:
+        return "Clip"
+
+    def get_config(self) -> LayerTestConfig:
+        # Treat min / max as optional extra inputs, scalar-shaped by default.
+        # Scalars are encoded as shape [1] for the test harness; ONNX/ORT
+        # will still broadcast them over A.
+        return LayerTestConfig(
+            op_type="Clip",
+            valid_inputs=["A", "min", "max"],
+            valid_attributes={},  # no Clip-specific attrs
+            required_initializers={},  # by default, all three can be dynamic inputs
+            input_shapes={
+                "A": [1, 3, 4, 4],
+                "min": [1],  # scalar-ish bound
+                "max": [1],  # scalar-ish bound
+            },
+            output_shapes={
+                "clip_output": [1, 3, 4, 4],
+            },
+        )
+
+    def get_test_specs(self) -> list:
+        rng = np.random.default_rng(TEST_RNG_SEED)
+
+        return [
+            # --- VALID TESTS ---
+            # Basic Clip with scalar min/max as dynamic inputs.
+            valid_test("basic_scalar_bounds")
+            .description("Clip with A, min, max all as inputs; min/max are scalars.")
+            .override_input_shapes(A=[1, 3, 4, 4], min=[1], max=[1])
+            .override_output_shapes(clip_output=[1, 3, 4, 4])
+            .tags("basic", "elementwise", "clip")
+            .build(),
+            # This keeps the name used by the integration tests:
+            # Clip_broadcast_bounds
+            # Broadcasting here is just scalar → full tensor broadcast.
+            valid_test("broadcast_bounds")
+            .description(
+                "Clip with scalar bounds broadcast over all elements of A "
+                "(mirrors Max/Min broadcast tests but respects ORT's scalar bound "
+                "rules).",
+            )
+            .override_input_shapes(A=[1, 3, 2, 4], min=[1], max=[1])
+            .override_output_shapes(clip_output=[1, 3, 2, 4])
+            .tags("broadcast", "elementwise", "clip", "onnxruntime")
+            .build(),
+            # This keeps the name used by the integration tests:
+            # Clip_initializer_bounds
+            valid_test("initializer_bounds")
+            .description(
+                "Clip where min/max are scalar initializers instead of inputs.",
+            )
+            .override_input_shapes(A=[1, 3, 4, 4])  # only A is a true input
+            # Scalar numpy values → ONNX initializers with shape ()
+            .override_initializer(
+                "min",
+                np.array(rng.uniform(-1.0, 0.0), dtype=np.float64),
+            )
+            .override_initializer(
+                "max",
+                np.array(rng.uniform(0.0, 2.0), dtype=np.float64),
+            )
+            .override_output_shapes(clip_output=[1, 3, 4, 4])
+            .tags("initializer", "elementwise", "clip", "onnxruntime")
+            .build(),
+            # --- E2E TESTS ---
+            e2e_test("e2e_small").description(
+                "End-to-end Clip with small random tensor and scalar bounds.",
+            )
+            # All three are treated as runtime inputs here;
+            # min/max are scalar-shaped [1].
+            .override_input_shapes(
+                A=[1, 3, 4, 4],
+                min=[1],
+                max=[1],
+            )
+            .override_output_shapes(clip_output=[1, 3, 4, 4])
+            .tags("e2e", "clip")
+            .build(),
+            e2e_test("e2e_initializer_bounds").description(
+                "End-to-end Clip where min/max are scalar initializers "
+                "instead of inputs.",
+            )
+            # Only A is a true runtime input; min/max are scalar initializers.
+            .override_input_shapes(
+                A=[1, 3, 4, 4],
+            )
+            .override_initializer(
+                "min",
+                np.array(rng.uniform(-1.0, 0.0), dtype=np.float64),
+            )
+            .override_initializer(
+                "max",
+                np.array(rng.uniform(0.0, 2.0), dtype=np.float64),
+            )
+            .override_output_shapes(clip_output=[1, 3, 4, 4])
+            .tags("e2e", "initializer", "clip")
+            .build(),
+            # --- EDGE / STRESS ---
+            edge_case_test("empty_tensor")
+            .description("Clip with empty tensor input and scalar bounds.")
+            .override_input_shapes(A=[0], min=[1], max=[1])
+            .override_output_shapes(clip_output=[0])
+            .tags("edge", "empty", "clip")
+            .build(),
+        ]

python/tests/onnx_quantizer_tests/layers/max_config.py

@@ -0,0 +1,100 @@
+from __future__ import annotations
+
+import numpy as np
+
+from python.tests.onnx_quantizer_tests import TEST_RNG_SEED
+from python.tests.onnx_quantizer_tests.layers.base import (
+    e2e_test,
+    edge_case_test,
+    valid_test,
+)
+from python.tests.onnx_quantizer_tests.layers.factory import (
+    BaseLayerConfigProvider,
+    LayerTestConfig,
+)
+
+
+class MaxConfigProvider(BaseLayerConfigProvider):
+    """Test configuration provider for elementwise Max"""
+
+    @property
+    def layer_name(self) -> str:
+        return "Max"
+
+    def get_config(self) -> LayerTestConfig:
+        return LayerTestConfig(
+            op_type="Max",
+            valid_inputs=["A", "B"],
+            valid_attributes={},  # Max has no layer-specific attributes
+            required_initializers={},  # default: both A and B are dynamic inputs
+            input_shapes={
+                "A": [1, 3, 4, 4],
+                "B": [1, 3, 4, 4],
+            },
+            output_shapes={
+                "max_output": [1, 3, 4, 4],
+            },
+        )
+
+    def get_test_specs(self) -> list:
+        rng = np.random.default_rng(TEST_RNG_SEED)
+        return [
+            # --- VALID TESTS ---
+            valid_test("basic")
+            .description("Basic elementwise Max of two same-shaped tensors")
+            .override_input_shapes(A=[1, 3, 4, 4], B=[1, 3, 4, 4])
+            .tags("basic", "elementwise", "max")
+            .build(),
+            valid_test("broadcast_max")
+            .description("Max with Numpy-style broadcasting along spatial dimensions")
+            .override_input_shapes(A=[1, 3, 4, 4], B=[1, 3, 1, 1])
+            .tags("broadcast", "elementwise", "max", "onnx14")
+            .build(),
+            valid_test("initializer_max")
+            .description("Max where B is an initializer instead of an input")
+            .override_input_shapes(A=[1, 3, 4, 4])
+            .override_initializer(
+                "B",
+                rng.normal(0, 1, (1, 3, 4, 4)).astype(np.float32),
+            )
+            .tags("initializer", "elementwise", "max", "onnxruntime")
+            .build(),
+            # --- E2E TESTS ---
+            e2e_test("e2e_max")
+            .description("End-to-end Max test with random inputs")
+            .override_input_shapes(A=[1, 3, 4, 4], B=[1, 3, 4, 4])
+            .override_output_shapes(max_output=[1, 3, 4, 4])
+            .tags("e2e", "max", "2d")
+            .build(),
+            e2e_test("e2e_broadcast_max")
+            .description(
+                "End-to-end Max with Numpy-style broadcasting along spatial dimensions",
+            )
+            .override_input_shapes(A=[1, 3, 4, 4], B=[1, 3, 1, 1])
+            .override_output_shapes(max_output=[1, 3, 4, 4])
+            .tags("e2e", "broadcast", "elementwise", "max", "onnx14")
+            .build(),
+            e2e_test("e2e_initializer_max")
+            .description("End-to-end Max where B is an initializer")
+            .override_input_shapes(A=[1, 3, 4, 4])
+            .override_initializer(
+                "B",
+                rng.normal(0, 1, (1, 3, 4, 4)).astype(np.float32),
+            )
+            .override_output_shapes(max_output=[1, 3, 4, 4])
+            .tags("e2e", "initializer", "elementwise", "max", "onnxruntime")
+            .build(),
+            # --- EDGE / STRESS ---
+            edge_case_test("empty_tensor")
+            .description("Max with empty tensor input (zero elements)")
+            .override_input_shapes(A=[0], B=[0])
+            .override_output_shapes(max_output=[0])
+            .tags("edge", "empty", "max")
+            .build(),
+            valid_test("large_tensor")
+            .description("Large tensor max performance/stress test")
+            .override_input_shapes(A=[1, 64, 256, 256], B=[1, 64, 256, 256])
+            .tags("large", "performance", "max")
+            .skip("Performance test, skipped by default")
+            .build(),
+        ]

python/tests/onnx_quantizer_tests/layers/maxpool_config.py

@@ -28,6 +28,8 @@ class MaxPoolConfigProvider(BaseLayerConfigProvider):
                 "pads": [0, 0, 0, 0],
             },
             required_initializers={},
+            input_shapes={"input": [1, 3, 4, 4]},
+            output_shapes={"maxpool_output": [1, 3, 2, 2]},
         )
 
     def get_test_specs(self) -> list:
@@ -52,12 +54,97 @@ class MaxPoolConfigProvider(BaseLayerConfigProvider):
             .override_attrs(strides=[1, 1])
             .tags("stride_1", "pool", "overlap")
             .build(),
+            valid_test("missing_dilations_attr")
+            .description("MaxPool without dilations attribute should default to [1, 1]")
+            .override_attrs(dilations=None)
+            .tags("default_attr", "dilations", "pool")
+            .build(),
+            valid_test("non_default_dilations")
+            .description("MaxPool with explicit non-default dilations")
+            .override_attrs(dilations=[2, 2])
+            .tags("dilations", "non_default", "pool")
+            .override_output_shapes(maxpool_output=[1, 3, 1, 1])
+            .build(),
+            valid_test("missing_optional_attrs")
+            .description(
+                "MaxPool without pads/strides/dilations should use default values",
+            )
+            .override_attrs(
+                pads=None,
+                strides=None,
+                dilations=None,
+            )
+            .tags("defaults", "optional_attrs", "pool")
+            .build(),
+            valid_test("non_default_pads")
+            .description("MaxPool with explicit non-default pads")
+            .override_attrs(pads=[1, 1, 1, 1])
+            .override_output_shapes(maxpool_output=[1, 3, 3, 3])
+            .tags("pads", "non_default", "pool")
+            .build(),
+            valid_test("non_default_strides")
+            .description("MaxPool with explicit non-default strides [3, 3]")
+            .override_attrs(strides=[3, 3])
+            .override_output_shapes(maxpool_output=[1, 3, 1, 1])
+            .tags("strides", "non_default", "pool")
+            .build(),
+            valid_test("rectangular_strides")
+            .description("MaxPool with non-square strides [2, 1]")
+            .override_attrs(strides=[2, 1])
+            .override_output_shapes(maxpool_output=[1, 3, 2, 3])
+            .tags("strides", "non_square", "pool")
+            .build(),
+            # --- E2E TESTS ---
             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(),
+            e2e_test("missing_dilations_attr")
+            .description("MaxPool without dilations attribute should default to [1, 1]")
+            .override_attrs(dilations=None)
+            .tags("default_attr", "dilations", "pool")
+            .build(),
+            e2e_test("non_default_dilations")
+            .description("MaxPool with explicit non-default dilations")
+            .override_attrs(dilations=[2, 2])
+            .override_output_shapes(maxpool_output=[1, 3, 1, 1])
+            .tags("dilations", "non_default", "pool")
+            .build(),
+            e2e_test("e2e_defaults_applied")
+            .description("E2E MaxPool with default pads/strides/dilations applied")
+            .override_attrs(
+                pads=None,
+                strides=None,
+                dilations=None,
+            )
+            .override_input_shapes(input=[1, 1, 4, 4])
+            .override_output_shapes(maxpool_output=[1, 1, 3, 3])
+            .tags("e2e", "defaults", "pool")
+            .build(),
+            e2e_test("non_default_pads")
+            .description("MaxPool with explicit non-default pads")
+            .override_attrs(pads=[1, 1, 1, 1])
+            .override_output_shapes(maxpool_output=[1, 3, 3, 3])
+            .tags("pads", "non_default", "pool")
+            .build(),
+            e2e_test("non_default_strides")
+            .description("E2E MaxPool with explicit non-default strides")
+            .override_attrs(strides=[3, 3])
+            .override_input_shapes(input=[1, 3, 4, 4])
+            .override_output_shapes(maxpool_output=[1, 3, 1, 1])
+            .tags("e2e", "strides", "non_default", "pool")
+            .build(),
+            e2e_test("missing_strides_attr_defaults_applied")
+            .description(
+                "E2E MaxPool without strides attribute should default to [1, 1]",
+            )
+            .override_attrs(strides=None)
+            .override_input_shapes(input=[1, 1, 4, 4])
+            .override_output_shapes(maxpool_output=[1, 1, 3, 3])
+            .tags("e2e", "defaults", "strides", "pool")
+            .build(),
             # # --- ERROR TESTS ---
             error_test("asymmetric_padding")
             .description("MaxPool with asymmetric padding")
@@ -71,6 +158,25 @@ class MaxPoolConfigProvider(BaseLayerConfigProvider):
             .expects_error(InvalidParamError, "Currently only MaxPool2D is supported")
             .tags("invalid_attr_length", "kernel_shape")
             .build(),
+            error_test("auto_pad_not_supported")
+            .description("MaxPool with auto_pad should be rejected")
+            .override_attrs(auto_pad="SAME_UPPER")
+            .expects_error(InvalidParamError, "auto_pad must be NOTSET")
+            .tags("invalid", "auto_pad", "pool")
+            .build(),
+            error_test("ceil_mode_not_supported")
+            .description("MaxPool with ceil_mode != 0 should be rejected")
+            .override_attrs(ceil_mode=1)
+            .expects_error(InvalidParamError, "ceil_mode must be 0")
+            .tags("invalid", "ceil_mode", "pool")
+            .build(),
+            error_test("storage_order_not_supported")
+            .description("MaxPool with storage_order != 0 should be rejected")
+            .override_attrs(storage_order=1)
+            .expects_error(InvalidParamError, "storage_order must be 0")
+            .tags("invalid", "storage_order", "pool")
+            .build(),
+            # This can be removed if we start to support explicit None strides
             # --- EDGE CASE / SKIPPED TEST ---
             valid_test("large_input")
             .description("Large MaxPool input (performance/stress test)")

python/tests/onnx_quantizer_tests/layers/min_config.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+import numpy as np
+
+from python.tests.onnx_quantizer_tests import TEST_RNG_SEED
+from python.tests.onnx_quantizer_tests.layers.base import (
+    e2e_test,
+    edge_case_test,
+    valid_test,
+)
+from python.tests.onnx_quantizer_tests.layers.factory import (
+    BaseLayerConfigProvider,
+    LayerTestConfig,
+)
+
+
+class MinConfigProvider(BaseLayerConfigProvider):
+    """Test configuration provider for elementwise Min"""
+
+    @property
+    def layer_name(self) -> str:
+        return "Min"
+
+    def get_config(self) -> LayerTestConfig:
+        return LayerTestConfig(
+            op_type="Min",
+            valid_inputs=["A", "B"],
+            valid_attributes={},  # Min has no layer-specific attributes
+            required_initializers={},  # default: both A and B are dynamic inputs
+            input_shapes={
+                "A": [1, 3, 4, 4],
+                "B": [1, 3, 4, 4],
+            },
+            output_shapes={
+                "min_output": [1, 3, 4, 4],
+            },
+        )
+
+    def get_test_specs(self) -> list:
+        rng = np.random.default_rng(TEST_RNG_SEED)
+        return [
+            # --- VALID TESTS ---
+            valid_test("basic")
+            .description("Basic elementwise Min of two same-shaped tensors")
+            .override_input_shapes(A=[1, 3, 4, 4], B=[1, 3, 4, 4])
+            .tags("basic", "elementwise", "min")
+            .build(),
+            valid_test("broadcast_min")
+            .description("Min with Numpy-style broadcasting along spatial dimensions")
+            .override_input_shapes(A=[1, 3, 4, 4], B=[1, 3, 1, 1])
+            .tags("broadcast", "elementwise", "min", "onnx14")
+            .build(),
+            valid_test("initializer_min")
+            .description("Min where B is an initializer instead of an input")
+            .override_input_shapes(A=[1, 3, 4, 4])
+            .override_initializer("B", rng.normal(0, 1, (1, 3, 4, 4)))
+            .tags("initializer", "elementwise", "min", "onnxruntime")
+            .build(),
+            # --- E2E TESTS ---
+            e2e_test("e2e_min")
+            .description("End-to-end Min test with random inputs")
+            .override_input_shapes(A=[1, 3, 4, 4], B=[1, 3, 4, 4])
+            .override_output_shapes(min_output=[1, 3, 4, 4])
+            .tags("e2e", "min", "2d")
+            .build(),
+            e2e_test("e2e_broadcast_min")
+            .description(
+                "End-to-end Min with Numpy-style broadcasting along spatial dimensions",
+            )
+            .override_input_shapes(A=[1, 3, 4, 4], B=[1, 3, 1, 1])
+            .override_output_shapes(min_output=[1, 3, 4, 4])
+            .tags("e2e", "broadcast", "elementwise", "min", "onnx14")
+            .build(),
+            e2e_test("e2e_initializer_min")
+            .description("End-to-end Min where B is an initializer")
+            .override_input_shapes(A=[1, 3, 4, 4])
+            .override_initializer("B", rng.normal(0, 1, (1, 3, 4, 4)))
+            .override_output_shapes(min_output=[1, 3, 4, 4])
+            .tags("e2e", "initializer", "elementwise", "min", "onnxruntime")
+            .build(),
+            # --- EDGE / STRESS ---
+            edge_case_test("empty_tensor")
+            .description("Min with empty tensor input (zero elements)")
+            .override_input_shapes(A=[0], B=[0])
+            .override_output_shapes(min_output=[0])
+            .tags("edge", "empty", "min")
+            .build(),
+            valid_test("large_tensor")
+            .description("Large tensor min performance/stress test")
+            .override_input_shapes(A=[1, 64, 256, 256], B=[1, 64, 256, 256])
+            .tags("large", "performance", "min")
+            .skip("Performance test, skipped by default")
+            .build(),
+        ]

python/tests/onnx_quantizer_tests/layers_tests/test_integration.py

@@ -159,21 +159,22 @@ class TestIntegration(BaseQuantizerTest):
         quantized_input_names = [inp.name for inp in quantized_session.get_inputs()]
         quantized_output_name = quantized_session.get_outputs()[0].name
 
-        # For quantized model, scale the inputs
-        scaled_inputs = {}
+        # For the quantized model, cast inputs to float64 for ORT
+        quantized_inputs = {}
         for name in quantized_input_names:
             if name in dummy_inputs:
-                scaled_inputs[name] = (dummy_inputs[name]).astype(np.float64)
+                quantized_inputs[name] = dummy_inputs[name].astype(np.float64)
             else:
-                # If quantized model has different inputs, skip or handle
+                # If quantized model has different inputs, skip this case
                 pytest.skip(
                     f"Quantized model input mismatch for {layer_name}.{test_spec.name}",
                 )
 
         quantized_output = quantized_session.run(
             [quantized_output_name],
-            scaled_inputs,
+            quantized_inputs,
         )[0]
+
         quantized_output = quantized_output / (scale_base ** (scale_exponent))
 
         ratio = np.mean(quantized_output / (original_output + 1e-12))

python/tests/onnx_quantizer_tests/layers_tests/test_quantize.py

@@ -37,7 +37,10 @@ class TestQuantize(BaseQuantizerTest):
         scale_base: int = 10,
         *,
         rescale: bool = True,
-    ) -> tuple[onnx.NodeProto, tuple[str, LayerTestConfig, LayerTestSpec, NodeProto]]:
+    ) -> tuple[
+        list[onnx.NodeProto],
+        tuple[str, LayerTestConfig, LayerTestSpec, NodeProto],
+    ]:
         """Common setup for quantization tests"""
         layer_name, config, test_spec = test_case_data
 
@@ -65,6 +68,8 @@ class TestQuantize(BaseQuantizerTest):
             initializer_map=initializer_map,
         )
 
+        if not isinstance(result, list):
+            result = [result]
         return result, (layer_name, config, test_spec, node)
 
     @pytest.mark.unit