sigima 0.0.1.dev0__py3-none-any.whl → 1.0.0__py3-none-any.whl

sigima/tests/common/shape_unit_test.py

@@ -0,0 +1,183 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Unit tests for shape module
+"""
+
+from __future__ import annotations
+
+import numpy as np
+
+from sigima.objects import shape
+
+
+def test_point_inplace_transform_and_copy() -> None:
+    """
+    Test inplace transformations and copy for PointCoordinates.
+
+    Verifies that translation and rotation work inplace, and that copy creates
+    an independent object.
+    """
+    pt = shape.PointCoordinates([1, 2])
+    pt2 = pt.copy()
+    assert np.allclose(pt.data, pt2.data)
+    pt.translate(3, 4)
+    assert np.allclose(pt.data, [4, 6])
+    pt2.rotate(np.pi, center=(1, 2))
+    assert np.allclose(pt2.data, [1, 2])  # Rotating at own center: no change
+
+
+def test_segment_inplace_transform() -> None:
+    """Test inplace transformations for SegmentCoordinates."""
+    seg = shape.SegmentCoordinates([0, 0, 1, 1])
+    seg2 = seg.copy()
+    seg.translate(1, 1)
+    assert np.allclose(seg.data, [1, 1, 2, 2])
+    seg2.rotate(np.pi / 2, center=(0, 0))
+    assert np.allclose(seg2.data, [0, 0, -1, 1])
+
+
+def test_rectangle_inplace_transform() -> None:
+    """
+    Test inplace horizontal and vertical flipping for RectangleCoordinates.
+
+    Verifies that flipping is performed inplace and independently on copies.
+    """
+    rect = shape.RectangleCoordinates([0.0, 0.0, 2.0, 3.0])
+    rect2 = rect.copy()
+    rect.fliph(cx=1.5)
+    assert np.allclose(rect.data, [1.0, 0.0, 2.0, 3.0])
+    rect2.flipv(cy=2.5)
+    assert np.allclose(rect2.data, [0.0, 2.0, 2.0, 3.0])
+
+
+def test_circle_inplace_transform() -> None:
+    """
+    Test inplace translation and scaling for CircleCoordinates.
+
+    Verifies that only the center is transformed and the radius remains
+    unchanged.
+    """
+    circ = shape.CircleCoordinates([1, 2, 5])
+    circ2 = circ.copy()
+    circ.translate(2, -1)
+    assert np.allclose(circ.data, [3, 1, 5])
+    circ2.scale(2, 2)
+    assert np.allclose(circ2.data, [2, 4, 5])  # Only center is scaled
+
+
+def test_polygon_inplace_transform() -> None:
+    """
+    Test inplace transpose and rotation for PolygonCoordinates.
+
+    Verifies that transpose and rotation are performed inplace and
+    independently on copies.
+    """
+    poly = shape.PolygonCoordinates([0, 0, 1, 0, 1, 1, 0, 1])
+    poly2 = poly.copy()
+    poly.transpose()
+    assert np.allclose(poly.data, [0, 0, 0, 1, 1, 1, 1, 0])
+    poly2.rotate(np.pi / 2, center=(0, 0))
+    assert np.allclose(poly2.data, [0, 0, 0, 1, -1, 1, -1, 0])
+
+
+def test_inplace_vs_copy() -> None:
+    """
+    Test that inplace transformation does not affect a copy.
+
+    Verifies that after translating the original, the copy remains unchanged.
+    """
+    pt = shape.PointCoordinates([1, 2])
+    pt2 = pt.copy()
+    pt.translate(1, 1)
+    assert not np.allclose(pt.data, pt2.data)
+
+
+def test_rotate_arbitrary_center() -> None:
+    """
+    Test rotation around an arbitrary center for all coordinate types.
+    """
+    pt = shape.PointCoordinates([2, 3])
+    pt.rotate(np.pi / 2, center=(1, 1))
+    # (2,3) rotated 90° CCW around (1,1) -> ( -1,2 )
+    assert np.allclose(pt.data, [-1, 2])
+
+    rect = shape.RectangleCoordinates([2, 3, 4, 5])
+    rect.rotate(np.pi / 2, center=(1, 1))
+    expected = [-6, 2, 5, 4]
+    assert np.allclose(rect.data, expected)
+
+    circ = shape.CircleCoordinates([2, 3, 5])
+    circ.rotate(np.pi / 2, center=(1, 1))
+    assert np.allclose(circ.data, [-1, 2, 5])
+
+    poly = shape.PolygonCoordinates([2, 3, 4, 5, 6, 7])
+    poly.rotate(np.pi / 2, center=(1, 1))
+    expected_poly = [-1, 2, -3, 4, -5, 6]
+    assert np.allclose(poly.data, expected_poly)
+
+
+def test_fliph_flipv_arbitrary_axis() -> None:
+    """
+    Test horizontal and vertical flip with respect to arbitrary axis
+    for all coordinate types.
+    """
+    pt = shape.PointCoordinates([2, 3])
+    pt.fliph(cx=1.5)
+    assert np.allclose(pt.data, [1.0, 3])
+    pt2 = shape.PointCoordinates([2, 3])
+    pt2.flipv(cy=2.5)
+    assert np.allclose(pt2.data, [2, 2.0])
+
+    rect = shape.RectangleCoordinates([2, 3, 4, 5])
+    rect.fliph(cx=3)
+    assert np.allclose(rect.data, [0, 3, 4, 5])
+    rect2 = shape.RectangleCoordinates([2, 3, 4, 5])
+    rect2.flipv(cy=4)
+    assert np.allclose(rect2.data, [2, 0, 4, 5])
+
+    circ = shape.CircleCoordinates([2, 3, 5])
+    circ.fliph(cx=1)
+    assert np.allclose(circ.data, [0, 3, 5])
+    circ2 = shape.CircleCoordinates([2, 3, 5])
+    circ2.flipv(cy=2)
+    assert np.allclose(circ2.data, [2, 1, 5])
+
+    poly = shape.PolygonCoordinates([2, 3, 4, 5])
+    poly.fliph(cx=3)
+    assert np.allclose(poly.data, [4, 3, 2, 5])
+    poly2 = shape.PolygonCoordinates([2, 3, 4, 5])
+    poly2.flipv(cy=4)
+    assert np.allclose(poly2.data, [2, 5, 4, 3])
+
+
+def test_transpose_all_types() -> None:
+    """
+    Test transposition (swap x and y) for all coordinate types.
+    """
+    pt = shape.PointCoordinates([2, 3])
+    pt.transpose()
+    assert np.allclose(pt.data, [3, 2])
+
+    rect = shape.RectangleCoordinates([2, 3, 4, 5])
+    rect.transpose()
+    assert np.allclose(rect.data, [3, 2, 5, 4])
+
+    circ = shape.CircleCoordinates([2, 3, 5])
+    circ.transpose()
+    assert np.allclose(circ.data, [3, 2, 5])
+
+    poly = shape.PolygonCoordinates([2, 3, 4, 5, 6, 7])
+    poly.transpose()
+    assert np.allclose(poly.data, [3, 2, 5, 4, 7, 6])
+
+
+if __name__ == "__main__":
+    test_point_inplace_transform_and_copy()
+    test_rectangle_inplace_transform()
+    test_circle_inplace_transform()
+    test_polygon_inplace_transform()
+    test_inplace_vs_copy()
+    test_rotate_arbitrary_center()
+    test_fliph_flipv_arbitrary_axis()
+    test_transpose_all_types()

sigima/tests/common/stat_unit_test.py

@@ -0,0 +1,138 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Statistics unit test
+
+Testing the following:
+  - Create a signal
+  - Compute statistics on signal and compare with expected results
+  - Create an image
+  - Compute statistics on image and compare with expected results
+"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+
+from __future__ import annotations
+
+import numpy as np
+import pytest
+import scipy.integrate as spt
+
+import sigima.objects
+import sigima.proc.image
+import sigima.proc.signal
+
+
+def get_analytical_stats(data: np.ndarray) -> dict[str, float]:
+    """Compute analytical statistics for data
+
+    Args:
+        data: Array of data
+
+    Returns:
+        Dictionary with analytical statistics
+    """
+    results = {}
+    if data.shape[0] == 2:
+        # This is a signal data (row 0: x, row 1: y)
+        results["trapz"] = spt.trapezoid(data[1], data[0])
+        data = data[1]
+    results.update(
+        {
+            "min": np.min(data),
+            "max": np.max(data),
+            "mean": np.mean(data),
+            "median": np.median(data),
+            "std": np.std(data),
+            "snr": np.mean(data) / np.std(data),
+            "ptp": np.ptp(data),
+            "sum": np.sum(data),
+        }
+    )
+    return results
+
+
+def create_reference_signal() -> sigima.objects.SignalObj:
+    """Create reference signal"""
+    param = sigima.objects.GaussParam()
+    sig = sigima.objects.create_signal_from_param(param)
+    sig.roi = sigima.objects.create_signal_roi(
+        [len(sig.x) // 2, len(sig.x) - 1], indices=True
+    )
+    return sig
+
+
+def create_reference_image() -> sigima.objects.ImageObj:
+    """Create reference image"""
+    param = sigima.objects.Gauss2DParam.create(title="2D-Gaussian")
+    ima = sigima.objects.create_image_from_param(param)
+    dy, dx = ima.data.shape
+    ima.roi = sigima.objects.create_image_roi(
+        "rectangle",
+        [
+            [dx // 2, 0, dx, dy],
+            [0, 0, dx // 3, dy // 3],
+            [dx // 2, dy // 2, dx, dy],
+        ],
+    )
+    return ima
+
+
+@pytest.mark.validation
+def test_signal_stats_unit() -> None:
+    """Validate computed statistics for signals"""
+    obj = create_reference_signal()
+    table = sigima.proc.signal.stats(obj)
+    ref = get_analytical_stats(obj.xydata)
+    for key, val in ref.items():
+        assert key in table
+        assert np.isclose(table[key][0], val), f"Incorrect value for {key}"
+
+    # Given the fact that signal ROI is set to [len(sig.x) // 2, len(sig.x) - 1],
+    # we may check the relationship between the results on the whole signal and the ROI:
+    for key, val in ref.items():
+        if key in ("trapz", "sum"):
+            assert np.isclose(table[key][1], val / 2, rtol=0.02)
+        elif key == "median":
+            continue
+        else:
+            assert np.isclose(table[key][1], val, rtol=0.01)
+
+
+@pytest.mark.validation
+def test_image_stats_unit() -> None:
+    """Validate computed statistics for images"""
+    obj = create_reference_image()
+
+    # Ignore "RuntimeWarning: invalid value encountered in scalar divide" in the test
+    # (this warning is due to the fact that the 2nd ROI has zero sum of pixel values,
+    # hence the mean/std is NaN)
+    with np.errstate(invalid="ignore"):
+        res = sigima.proc.image.stats(obj)
+
+    ref = get_analytical_stats(obj.data)
+    for key, val in ref.items():
+        assert key in res
+        assert np.isclose(res[key][0], val, rtol=1e-4, atol=1e-5), (
+            f"Incorrect value for {key}"
+        )
+
+    # Given the fact that image ROI is set to
+    # [[dx // 2, 0, dx, dy], [0, 0, dx // 3, dy // 3], [dx // 2, dy // 2, dx, dy]],
+    # we may check the relationship between the results on the whole image and the ROIs:
+    for key, val in ref.items():
+        if key == "sum":
+            assert np.isclose(res[key][1], val / 2, rtol=0.02)
+            assert np.isclose(res[key][3], val / 4, rtol=0.02)
+        elif key == "median":
+            continue
+        else:
+            assert np.isclose(res[key][1], val, rtol=0.01)
+            assert np.isclose(res[key][3], val, rtol=0.01)
+            if key != "snr":
+                assert np.isclose(res[key][2], 0.0, atol=0.001)
+
+
+if __name__ == "__main__":
+    test_signal_stats_unit()
+    test_image_stats_unit()

sigima/tests/common/title_formatting_unit_test.py

@@ -0,0 +1,338 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Title formatting system unit tests
+
+Testing the configurable title formatting system that allows different applications
+(Sigima standalone vs DataLab integration) to use different title formatting strategies.
+
+This test verifies:
+  - SimpleTitleFormatter: Human-readable titles for standalone Sigima usage
+  - PlaceholderTitleFormatter: DataLab-compatible placeholder titles
+  - Configuration system: Setting and getting default formatters
+  - Integration: Testing with computation functions from sigima.proc.base
+  - Compatibility: Ensuring DataLab-style placeholder resolution works
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from sigima import create_signal
+from sigima.proc.base import dst_1_to_1, dst_2_to_1, dst_n_to_1
+from sigima.proc.title_formatting import (
+    PlaceholderTitleFormatter,
+    SimpleTitleFormatter,
+    get_default_title_formatter,
+    set_default_title_formatter,
+)
+
+
+class TestSimpleTitleFormatter:
+    """Test suite for SimpleTitleFormatter class."""
+
+    def test_1_to_1_operations(self):
+        """Test SimpleTitleFormatter for 1-to-1 operations."""
+        formatter = SimpleTitleFormatter()
+
+        # Test basic function name formatting
+        assert (
+            formatter.format_1_to_1_title("gaussian_filter") == "Gaussian Filter Result"
+        )
+
+        # Test with suffix
+        result = formatter.format_1_to_1_title("gaussian_filter", "sigma=1.5")
+        assert result == "Gaussian Filter Result (sigma=1.5)"
+
+        # Test with operator
+        assert formatter.format_1_to_1_title("+") == "operator_+"
+
+    def test_n_to_1_operations(self):
+        """Test SimpleTitleFormatter for n-to-1 operations."""
+        formatter = SimpleTitleFormatter()
+
+        # Test basic n-to-1 formatting
+        result = formatter.format_n_to_1_title("add_signals", 3)
+        assert result == "Add Signals of 3 Objects"
+
+        # Test with suffix
+        result = formatter.format_n_to_1_title("mean", 5, "weighted")
+        assert result == "Mean of 5 Objects (weighted)"
+
+    def test_2_to_1_operations(self):
+        """Test SimpleTitleFormatter for 2-to-1 operations."""
+        formatter = SimpleTitleFormatter()
+
+        # Test basic 2-to-1 formatting
+        assert formatter.format_2_to_1_title("subtract") == "Subtract Result"
+
+        # Test with operator
+        assert formatter.format_2_to_1_title("-") == "Binary Operation -"
+
+        # Test with suffix
+        result = formatter.format_2_to_1_title("divide", "method=euclidean")
+        assert result == "Divide Result (method=euclidean)"
+
+    def test_placeholder_resolution(self):
+        """Test SimpleTitleFormatter placeholder resolution (should be unchanged)."""
+        formatter = SimpleTitleFormatter()
+
+        # Should return unchanged for simple formatter
+        result = formatter.resolve_placeholder_title("wiener({0})", [])
+        assert result == "wiener({0})"
+
+    def test_humanize_function_name(self):
+        """Test the function name humanization logic."""
+        formatter = SimpleTitleFormatter()
+
+        # Test the internal logic through the public interface
+        # The formatter converts snake_case to Title Case internally
+        result = formatter.format_1_to_1_title("gaussian_filter")
+        assert "Gaussian Filter" in result
+
+        result = formatter.format_1_to_1_title("moving_average")
+        assert "Moving Average" in result
+
+        # Test single words
+        result = formatter.format_1_to_1_title("normalize")
+        assert "Normalize" in result
+
+        # Test operators (should be handled specially)
+        result = formatter.format_1_to_1_title("+")
+        assert "operator_+" in result
+
+        result = formatter.format_1_to_1_title("-")
+        assert "operator_-" in result
+
+    def test_edge_cases(self):
+        """Test edge cases for SimpleTitleFormatter."""
+        formatter = SimpleTitleFormatter()
+
+        # Test empty function name
+        assert formatter.format_1_to_1_title("") == " Result"
+
+        # Test None suffix (should be handled gracefully)
+        result = formatter.format_1_to_1_title("test", None)
+        assert result == "Test Result"
+
+        # Test empty suffix
+        result = formatter.format_1_to_1_title("test", "")
+        assert result == "Test Result"
+
+
+class TestPlaceholderTitleFormatter:
+    """Test suite for PlaceholderTitleFormatter class."""
+
+    def test_1_to_1_operations(self):
+        """Test PlaceholderTitleFormatter for 1-to-1 operations."""
+        formatter = PlaceholderTitleFormatter()
+
+        # Test basic function name formatting
+        assert formatter.format_1_to_1_title("wiener") == "wiener({0})"
+
+        # Test with suffix
+        result = formatter.format_1_to_1_title("gaussian_filter", "sigma=1.5")
+        assert result == "gaussian_filter({0})|sigma=1.5"
+
+    def test_n_to_1_operations(self):
+        """Test PlaceholderTitleFormatter for n-to-1 operations."""
+        formatter = PlaceholderTitleFormatter()
+
+        # Test basic n-to-1 formatting
+        result = formatter.format_n_to_1_title("sum", 3)
+        assert result == "sum({0}, {1}, {2})"
+
+        # Test with suffix
+        result = formatter.format_n_to_1_title("mean", 5, "weighted=True")
+        assert result == "mean({0}, {1}, {2}, {3}, {4})|weighted=True"
+
+    def test_2_to_1_operations(self):
+        """Test PlaceholderTitleFormatter for 2-to-1 operations."""
+        formatter = PlaceholderTitleFormatter()
+
+        # Test basic 2-to-1 formatting
+        assert formatter.format_2_to_1_title("subtract") == "subtract({0}, {1})"
+
+        # Test with suffix
+        result = formatter.format_2_to_1_title("divide", "method=euclidean")
+        assert result == "divide({0}, {1})|method=euclidean"
+
+    def test_placeholder_resolution(self):
+        """Test PlaceholderTitleFormatter placeholder resolution."""
+        formatter = PlaceholderTitleFormatter()
+
+        # Create mock objects with simple string values (strings are used as fallback)
+        src1 = create_signal("Signal001", x=[1, 2], y=[3, 4])
+
+        # Test basic placeholder resolution (uses obj1 fallback since no short_id)
+        result = formatter.resolve_placeholder_title("wiener({0})", [src1])
+        assert result == "wiener(obj1)"
+
+        # Test with suffix (suffix is preserved in resolution)
+        result = formatter.resolve_placeholder_title("gaussian({0})|sigma=2.0", [src1])
+        assert result == "gaussian(obj1)|sigma=2.0"
+
+        # Test empty placeholders list (should raise IndexError)
+        with pytest.raises(IndexError):
+            formatter.resolve_placeholder_title("wiener({0})", [])
+
+    def test_edge_cases(self):
+        """Test edge cases for PlaceholderTitleFormatter."""
+        formatter = PlaceholderTitleFormatter()
+
+        # Test empty function name
+        assert formatter.format_1_to_1_title("") == "({0})"
+
+        # Test None suffix (should be handled gracefully)
+        result = formatter.format_1_to_1_title("test", None)
+        assert result == "test({0})"
+
+        # Test empty suffix
+        result = formatter.format_1_to_1_title("test", "")
+        assert result == "test({0})"
+
+    def test_datalab_compatibility(self):
+        """Test DataLab-style placeholder resolution compatibility."""
+        formatter = PlaceholderTitleFormatter()
+
+        # Create signal objects for testing
+        sig1 = create_signal("Signal001", x=[1, 2], y=[3, 4])
+
+        # Test typical DataLab usage patterns (uses obj1 fallback without short_id)
+        test_cases = [
+            ("wiener({0})", [sig1], "wiener(obj1)"),
+            ("gaussian({0})|sigma=2.0", [sig1], "gaussian(obj1)|sigma=2.0"),
+            ("add({0})|3 objects", [sig1], "add(obj1)|3 objects"),
+        ]
+
+        for placeholder_title, source_titles, expected in test_cases:
+            result = formatter.resolve_placeholder_title(
+                placeholder_title, source_titles
+            )
+            assert result == expected
+
+        # Test empty list case (should raise IndexError)
+        with pytest.raises(IndexError):
+            formatter.resolve_placeholder_title("fft({0})", [])
+
+
+class TestFormatterConfiguration:
+    """Test suite for the global formatter configuration system."""
+
+    def test_configuration_system(self):
+        """Test the global formatter configuration system."""
+        # Store original formatter to restore later
+        original_formatter = get_default_title_formatter()
+
+        try:
+            # Test setting SimpleTitleFormatter
+            simple_formatter = SimpleTitleFormatter()
+            set_default_title_formatter(simple_formatter)
+            current_formatter = get_default_title_formatter()
+            assert isinstance(current_formatter, SimpleTitleFormatter)
+
+            # Test setting PlaceholderTitleFormatter
+            placeholder_formatter = PlaceholderTitleFormatter()
+            set_default_title_formatter(placeholder_formatter)
+            current_formatter = get_default_title_formatter()
+            assert isinstance(current_formatter, PlaceholderTitleFormatter)
+
+        finally:
+            # Restore original formatter
+            set_default_title_formatter(original_formatter)
+
+
+class TestIntegrationWithComputationFunctions:
+    """Test suite for integration with computation functions from sigima.proc.base."""
+
+    def test_integration_with_dst_1_to_1(self):
+        """Test integration with dst_1_to_1 function."""
+        original_formatter = get_default_title_formatter()
+
+        try:
+            # Test with SimpleTitleFormatter
+            set_default_title_formatter(SimpleTitleFormatter())
+            src = create_signal("Test Signal", x=[1, 2, 3], y=[4, 5, 6])
+            result = dst_1_to_1(src, "gaussian_filter", "sigma=1.0")
+            assert "Gaussian Filter Result" in result.title
+            assert "sigma=1.0" in result.title
+
+            # Test with PlaceholderTitleFormatter
+            set_default_title_formatter(PlaceholderTitleFormatter())
+            result2 = dst_1_to_1(src, "gaussian_filter", "sigma=1.0")
+            assert result2.title == "gaussian_filter({0})|sigma=1.0"
+
+        finally:
+            set_default_title_formatter(original_formatter)
+
+    def test_integration_with_dst_2_to_1(self):
+        """Test integration with dst_2_to_1 function."""
+        original_formatter = get_default_title_formatter()
+
+        try:
+            # Test with SimpleTitleFormatter
+            set_default_title_formatter(SimpleTitleFormatter())
+            src1 = create_signal("Signal1", x=[1, 2, 3], y=[1, 2, 3])
+            src2 = create_signal("Signal2", x=[1, 2, 3], y=[4, 5, 6])
+            result = dst_2_to_1(src1, src2, "subtract")
+            assert result.title == "Subtract Result"
+
+            # Test with PlaceholderTitleFormatter
+            set_default_title_formatter(PlaceholderTitleFormatter())
+            result2 = dst_2_to_1(src1, src2, "subtract")
+            assert result2.title == "subtract({0}, {1})"
+
+        finally:
+            set_default_title_formatter(original_formatter)
+
+    def test_integration_with_dst_n_to_1(self):
+        """Test integration with dst_n_to_1 function."""
+        original_formatter = get_default_title_formatter()
+
+        try:
+            # Test with SimpleTitleFormatter
+            set_default_title_formatter(SimpleTitleFormatter())
+            signals = [
+                create_signal(f"Signal{i}", x=[1, 2, 3], y=[i, i + 1, i + 2])
+                for i in range(1, 4)
+            ]
+            result = dst_n_to_1(signals, "sum")
+            assert result.title == "Sum of 3 Objects"
+
+            # Test with PlaceholderTitleFormatter
+            set_default_title_formatter(PlaceholderTitleFormatter())
+            result2 = dst_n_to_1(signals, "sum")
+            assert result2.title == "sum({0}, {1}, {2})"
+
+        finally:
+            set_default_title_formatter(original_formatter)
+
+
+class TestFormatterConsistency:
+    """Test suite for formatter consistency and compatibility."""
+
+    def test_formatter_consistency(self):
+        """Test that formatters produce consistent results."""
+        simple = SimpleTitleFormatter()
+        placeholder = PlaceholderTitleFormatter()
+
+        # Test same function name produces consistent patterns
+        func_name = "gaussian_filter"
+        suffix = "sigma=1.0"
+
+        simple_result = simple.format_1_to_1_title(func_name, suffix)
+        placeholder_result = placeholder.format_1_to_1_title(func_name, suffix)
+
+        # Both should include the suffix information
+        assert suffix in simple_result
+        assert suffix in placeholder_result
+
+        # Simple should be human-readable
+        assert "Gaussian Filter" in simple_result
+
+        # Placeholder should use function name as-is
+        assert func_name in placeholder_result
+
+
+if __name__ == "__main__":
+    pytest.main([__file__])