sonolus.py 0.1.5__tar.gz → 0.1.7__tar.gz

{sonolus_py-0.1.5 → sonolus_py-0.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: sonolus.py
-Version: 0.1.5
+Version: 0.1.7
 Summary: Sonolus engine development in Python
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown

{sonolus_py-0.1.5 → sonolus_py-0.1.7}/docs/concepts/cli.md

@@ -14,3 +14,15 @@ To build the project, run the following command in the root directory of your pr
 ```bash
 sonolus-py build
 ```
+
+## Outputting the level schema
+To output the level schema of the project, run the following command in the root directory of your project:
+
+```bash
+sonolus-py schema
+```
+
+## Programmatic usage
+The same functionality can be accessed programmatically as methods of a project.
+
+See [Project][sonolus.script.project.Project] for more information.

{sonolus_py-0.1.5 → sonolus_py-0.1.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sonolus.py"
-version = "0.1.5"
+version = "0.1.7"
 description = "Sonolus engine development in Python"
 readme = "README.md"
 requires-python = ">=3.13"

{sonolus_py-0.1.5 → sonolus_py-0.1.7}/sonolus/build/cli.py

@@ -2,6 +2,7 @@ import argparse
 import contextlib
 import http.server
 import importlib
+import json
 import shutil
 import socket
 import socketserver
@@ -11,7 +12,7 @@ from time import perf_counter
 
 from sonolus.build.engine import package_engine
 from sonolus.build.level import package_level_data
-from sonolus.build.project import build_project_to_collection
+from sonolus.build.project import build_project_to_collection, get_project_schema
 from sonolus.script.project import Project
 
 
@@ -147,6 +148,14 @@ def main():
     dev_parser.add_argument("--build-dir", type=str, default="./build")
     dev_parser.add_argument("--port", type=int, default=8000)
 
+    schema_parser = subparsers.add_parser("schema")
+    schema_parser.add_argument(
+        "module",
+        type=str,
+        nargs="?",
+        help="Module path (e.g., 'module.name'). If omitted, will auto-detect if only one module exists.",
+    )
+
     args = parser.parse_args()
 
     if not args.module:
@@ -161,16 +170,18 @@ def main():
     if project is None:
         sys.exit(1)
 
-    build_dir = Path(args.build_dir)
-
     if args.command == "build":
+        build_dir = Path(args.build_dir)
         start_time = perf_counter()
         build_project(project, build_dir)
         end_time = perf_counter()
         print(f"Project built successfully to '{build_dir.resolve()}' in {end_time - start_time:.2f}s")
     elif args.command == "dev":
+        build_dir = Path(args.build_dir)
         start_time = perf_counter()
         build_collection(project, build_dir)
         end_time = perf_counter()
         print(f"Build finished in {end_time - start_time:.2f}s")
         run_server(build_dir / "site", port=args.port)
+    elif args.command == "schema":
+        print(json.dumps(get_project_schema(project), indent=2))

{sonolus_py-0.1.5 → sonolus_py-0.1.7}/sonolus/build/project.py

@@ -5,7 +5,7 @@ from sonolus.build.engine import package_engine
 from sonolus.build.level import package_level_data
 from sonolus.script.engine import Engine
 from sonolus.script.level import Level
-from sonolus.script.project import Project
+from sonolus.script.project import Project, ProjectSchema
 
 BLANK_PNG = (
     b"\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x01\x00\x00\x00\x01\x01\x00\x00\x00\x007n\xf9$"
@@ -92,3 +92,32 @@ def load_resources_files_to_collection(base_path: Path) -> Collection:
         collection.load_from_scp(path)
     collection.load_from_source(base_path)
     return collection
+
+
+def get_project_schema(project: Project) -> ProjectSchema:
+    by_archetype: dict[str, dict[str, bool]] = {}
+    for archetype in project.engine.data.play.archetypes:
+        fields = by_archetype.setdefault(archetype.name, {})
+        # If a field is exported, we should exclude it if it's imported in watch mode
+        for field in archetype._exported_keys_:
+            fields[field] = False
+        for field in archetype._imported_keys_:
+            fields[field] = True
+    for archetype in project.engine.data.watch.archetypes:
+        fields = by_archetype.setdefault(archetype.name, {})
+        for field in archetype._imported_keys_:
+            if field not in fields:
+                fields[field] = True
+    for archetype in project.engine.data.preview.archetypes:
+        fields = by_archetype.setdefault(archetype.name, {})
+        for field in archetype._imported_keys_:
+            fields[field] = True
+    return {
+        "archetypes": [
+            {
+                "name": name,
+                "fields": [*fields],
+            }
+            for name, fields in by_archetype.items()
+        ]
+    }

{sonolus_py-0.1.5 → sonolus_py-0.1.7}/sonolus/script/archetype.py

@@ -5,7 +5,7 @@ from collections.abc import Callable
 from dataclasses import dataclass
 from enum import Enum, StrEnum
 from types import FunctionType
-from typing import Annotated, Any, ClassVar, Self, get_origin
+from typing import Annotated, Any, ClassVar, Self, TypedDict, get_origin
 
 from sonolus.backend.ir import IRConst, IRInstr
 from sonolus.backend.mode import Mode
@@ -307,6 +307,11 @@ class _ArchetypeLevelData:
 type _ArchetypeData = _ArchetypeSelfData | _ArchetypeReferenceData | _ArchetypeLevelData
 
 
+class ArchetypeSchema(TypedDict):
+    name: str
+    fields: list[str]
+
+
 class _BaseArchetype:
     _is_comptime_value_ = True
 
@@ -401,6 +406,10 @@ class _BaseArchetype:
             data.extend(field.type._accept_(bound.arguments[field.name] or zeros(field.type))._to_list_())
         native_call(Op.Spawn, archetype_id, *(Num(x) for x in data))
 
+    @classmethod
+    def schema(cls) -> ArchetypeSchema:
+        return {"name": cls.name or "unnamed", "fields": list(cls._imported_fields_)}
+
     def _level_data_entries(self, level_refs: dict[Any, int] | None = None):
         if not isinstance(self._data_, _ArchetypeLevelData):
             raise RuntimeError("Entity is not level data")

{sonolus_py-0.1.5 → sonolus_py-0.1.7}/sonolus/script/array.py

@@ -60,7 +60,7 @@ class Array[T, Size](GenericValue, ArrayLike[T]):
                 raise ValueError(f"{cls.__name__} constructor should be used with {cls.size()} values, got {len(args)}")
             parameterized_cls = cls
         if ctx():
-            place = ctx().alloc(size=parameterized_cls.size())
+            place = ctx().alloc(size=parameterized_cls._size_())
             result: parameterized_cls = parameterized_cls._from_place_(place)
             result._copy_from_(parameterized_cls._with_value(values))
             return result

{sonolus_py-0.1.5 → sonolus_py-0.1.7}/sonolus/script/internal/context.py

@@ -182,10 +182,18 @@ class Context:
             return
         assert len(self.outgoing) == 0
         self.outgoing[None] = header
+        values = {}
+        # First do a pass through and copy every value
         for name, target_value in header.loop_variables.items():
             with using_ctx(self):
                 if type(target_value)._is_value_type_():
                     value = self.scope.get_value(name)
+                    values[name] = value._get_()  # _get_() will make a copy on value types
+        # Then actually set them
+        for name, target_value in header.loop_variables.items():
+            with using_ctx(self):
+                if type(target_value)._is_value_type_():
+                    value = values[name]
                     value = type(target_value)._accept_(value)
                     target_value._set_(value)
                 else:

sonolus_py-0.1.7/sonolus/script/project.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+from os import PathLike
+from pathlib import Path
+from typing import Self, TypedDict
+
+from sonolus.script.archetype import ArchetypeSchema
+from sonolus.script.engine import Engine
+from sonolus.script.level import Level
+
+
+class Project:
+    """A Sonolus.py project.
+
+    Args:
+        engine: The engine of the project.
+        levels: The levels of the project.
+        resources: The path to the resources of the project.
+    """
+
+    def __init__(
+        self,
+        engine: Engine,
+        levels: list[Level] | None = None,
+        resources: PathLike | None = None,
+    ):
+        self.engine = engine
+        self.levels = levels or []
+        self.resources = Path(resources or "resources")
+
+    def with_levels(self, levels: list[Level]) -> Self:
+        """Create a new project with the specified levels.
+
+        Args:
+            levels: The levels of the project.
+
+        Returns:
+            The new project.
+        """
+        return Project(self.engine, levels, self.resources)
+
+    def dev(self, build_dir: PathLike, port: int = 8080):
+        """Start a development server for the project.
+
+        Args:
+            build_dir: The path to the build directory.
+            port: The port of the development server.
+        """
+        from sonolus.build.cli import build_collection, run_server
+
+        build_collection(self, Path(build_dir))
+        run_server(Path(build_dir) / "site", port=port)
+
+    def build(self, build_dir: PathLike):
+        """Build the project.
+
+        Args:
+            build_dir: The path to the build directory.
+        """
+        from sonolus.build.cli import build_project
+
+        build_project(self, Path(build_dir))
+
+    def schema(self) -> ProjectSchema:
+        """Generate the schema of the project.
+
+        Returns:
+            The schema of the project.
+        """
+        from sonolus.build.project import get_project_schema
+
+        return get_project_schema(self)
+
+
+class ProjectSchema(TypedDict):
+    archetypes: list[ArchetypeSchema]

{sonolus_py-0.1.5 → sonolus_py-0.1.7}/sonolus/script/quad.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from typing import Protocol, Self
 
 from sonolus.script.record import Record
-from sonolus.script.vec import Vec2
+from sonolus.script.vec import Vec2, pnpoly
 
 
 class Quad(Record):
@@ -95,6 +95,17 @@ class Quad(Record):
         """Rotate the quad by the given angle about its center and return a new quad."""
         return self.rotate_about(angle, self.center)
 
+    def contains_point(self, point: Vec2, /) -> bool:
+        """Check if the quad contains the given point.
+
+        Args:
+            point: The point to check.
+
+        Returns:
+            True if the point is inside the quad, False otherwise.
+        """
+        return pnpoly((self.bl, self.tl, self.tr, self.br), point)
+
 
 class Rect(Record):
     """A rectangle defined by its top, right, bottom, and left edges.
@@ -225,6 +236,17 @@ class Rect(Record):
             l=self.l + shrinkage.x,
         )
 
+    def contains_point(self, point: Vec2, /) -> bool:
+        """Check if the rectangle contains the given point.
+
+        Args:
+            point: The point to check.
+
+        Returns:
+            True if the point is inside the rectangle, False otherwise.
+        """
+        return self.l <= point.x <= self.r and self.b <= point.y <= self.t
+
 
 class QuadLike(Protocol):
     """A protocol for types that can be used as quads."""

{sonolus_py-0.1.5 → sonolus_py-0.1.7}/sonolus/script/sprite.py

@@ -353,9 +353,7 @@ class StandardSprite:
     SIMULTANEOUS_CONNECTION_PURPLE = Annotated[Sprite, sprite("#SIMULTANEOUS_CONNECTION_PURPLE")]
     SIMULTANEOUS_CONNECTION_CYAN = Annotated[Sprite, sprite("#SIMULTANEOUS_CONNECTION_CYAN")]
 
-    SIMULTANEOUS_CONNECTION_NEUTRAL_SEAMLESS = Annotated[
-        Sprite, sprite("#SIMULTANEOUS_CONNECTION_NEUTRAL_SEAMLESS")
-    ]
+    SIMULTANEOUS_CONNECTION_NEUTRAL_SEAMLESS = Annotated[Sprite, sprite("#SIMULTANEOUS_CONNECTION_NEUTRAL_SEAMLESS")]
     SIMULTANEOUS_CONNECTION_RED_SEAMLESS = Annotated[Sprite, sprite("#SIMULTANEOUS_CONNECTION_RED_SEAMLESS")]
     SIMULTANEOUS_CONNECTION_GREEN_SEAMLESS = Annotated[Sprite, sprite("#SIMULTANEOUS_CONNECTION_GREEN_SEAMLESS")]
     SIMULTANEOUS_CONNECTION_BLUE_SEAMLESS = Annotated[Sprite, sprite("#SIMULTANEOUS_CONNECTION_BLUE_SEAMLESS")]

{sonolus_py-0.1.5 → sonolus_py-0.1.7}/sonolus/script/vec.py

@@ -1,6 +1,8 @@
 from math import atan2, cos, sin
 from typing import Self
 
+from sonolus.script.array import Array
+from sonolus.script.array_like import ArrayLike
 from sonolus.script.num import Num
 from sonolus.script.record import Record
 
@@ -194,3 +196,30 @@ class Vec2(Record):
             A new vector with inverted direction.
         """
         return Vec2(x=-self.x, y=-self.y)
+
+
+def pnpoly(vertices: ArrayLike[Vec2] | tuple[Vec2, ...], test: Vec2) -> bool:
+    """Check if a point is inside a polygon.
+
+    No guaranteed behavior for points on the edges or very close to the edges.
+
+    Args:
+        vertices: The vertices of the polygon.
+        test: The point to test.
+
+    Returns:
+        Whether the point is inside the polygon.
+    """
+    if isinstance(vertices, tuple):
+        vertices = Array(*vertices)
+    i = 0
+    j = len(vertices) - 1
+    c = False
+    while i < len(vertices):
+        if (vertices[i].y > test.y) != (vertices[j].y > test.y) and test.x < (vertices[j].x - vertices[i].x) * (
+            test.y - vertices[i].y
+        ) / (vertices[j].y - vertices[i].y) + vertices[i].x:
+            c = not c
+        j = i
+        i += 1
+    return c

{sonolus_py-0.1.5 → sonolus_py-0.1.7}/tests/script/conftest.py

@@ -16,6 +16,7 @@ from sonolus.script.internal.context import GlobalContextState
 from sonolus.script.internal.error import CompilationError
 from sonolus.script.internal.impl import meta_fn
 from sonolus.script.num import Num
+from sonolus.script.vec import Vec2
 
 settings.register_profile(
     "standard",
@@ -119,5 +120,7 @@ def implies(a: bool, b: bool) -> bool:
     return True
 
 
-def is_close(a: float, b: float, rel_tol: float = 1e-8, abs_tol: float = 1e-8) -> bool:
+def is_close(a: float | Vec2, b: float | Vec2, rel_tol: float = 1e-8, abs_tol: float = 1e-8) -> bool:
+    if isinstance(a, Vec2):
+        return is_close(a.x, b.x, rel_tol, abs_tol) and is_close(a.y, b.y, rel_tol, abs_tol)
     return abs(a - b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol)

{sonolus_py-0.1.5 → sonolus_py-0.1.7}/tests/script/test_flow.py

@@ -866,3 +866,16 @@ def test_for_empty():
         debug_log(4)
 
     validate_dual_run(fn)
+
+
+def test_loop_with_aug_assign():
+    def fn():
+        a = 0
+        b = 0
+        while a < 5:
+            debug_log(a + b)
+            b = a
+            a += 1
+
+    for _ in range(100):
+        validate_dual_run(fn)

sonolus_py-0.1.7/tests/script/test_quad.py

@@ -0,0 +1,289 @@
+# ruff: noqa: E741
+import itertools
+import math
+from datetime import timedelta
+
+from hypothesis import assume, given, settings
+from hypothesis import strategies as st
+
+from sonolus.script.quad import Quad, Rect
+from sonolus.script.vec import Vec2
+from tests.script.conftest import is_close, validate_dual_run
+
+floats = st.floats(min_value=-9, max_value=9, allow_nan=False, allow_infinity=False)
+nonzero_floats = floats.filter(lambda x: abs(x) > 1e-2)
+
+
+@st.composite
+def vecs(draw):
+    x = draw(floats)
+    y = draw(floats)
+    return Vec2(x, y)
+
+
+@st.composite
+def quads(draw):
+    points = [draw(vecs()) for _ in range(4)]
+    for p1, p2 in itertools.combinations(points, 2):
+        assume((p1 - p2).magnitude > 1e-2)
+    centroid = sum(points, Vec2(0, 0)) / 4
+    points = sorted(points, key=lambda p: (p - centroid).angle)
+    return Quad(*points)
+
+
+@st.composite
+def rects(draw):
+    l = draw(floats)
+    r = draw(floats)
+    if l > r:
+        l, r = r, l
+
+    b = draw(floats)
+    t = draw(floats)
+    if b > t:
+        b, t = t, b
+
+    return Rect(t=t, r=r, b=b, l=l)
+
+
+@given(
+    quad=quads(),
+    translation=vecs(),
+)
+@settings(deadline=timedelta(seconds=2))
+def test_quad_translate(quad, translation):
+    def fn():
+        return quad.translate(translation)
+
+    result = validate_dual_run(fn)
+    assert is_close(result.bl, quad.bl + translation)
+    assert is_close(result.tl, quad.tl + translation)
+    assert is_close(result.tr, quad.tr + translation)
+    assert is_close(result.br, quad.br + translation)
+
+
+@given(
+    quad=quads(),
+    factor=vecs(),
+)
+@settings(deadline=timedelta(seconds=2))
+def test_quad_scale(quad, factor):
+    def fn():
+        return quad.scale(factor)
+
+    result = validate_dual_run(fn)
+    assert is_close(result.bl, quad.bl * factor)
+    assert is_close(result.tl, quad.tl * factor)
+    assert is_close(result.tr, quad.tr * factor)
+    assert is_close(result.br, quad.br * factor)
+
+
+@given(
+    quad=quads(),
+    factor=vecs(),
+    pivot=vecs(),
+)
+@settings(deadline=timedelta(seconds=2))
+def test_quad_scale_about(quad, factor, pivot):
+    def fn():
+        return quad.scale_about(factor, pivot)
+
+    result = validate_dual_run(fn)
+    assert is_close(result.bl, (quad.bl - pivot) * factor + pivot)
+    assert is_close(result.tl, (quad.tl - pivot) * factor + pivot)
+    assert is_close(result.tr, (quad.tr - pivot) * factor + pivot)
+    assert is_close(result.br, (quad.br - pivot) * factor + pivot)
+
+
+@given(
+    quad=quads(),
+    angle=floats,
+)
+@settings(deadline=timedelta(seconds=2))
+def test_quad_rotate(quad, angle):
+    def fn():
+        return quad.rotate(angle)
+
+    result = validate_dual_run(fn)
+    assert is_close(result.bl, quad.bl.rotate(angle))
+    assert is_close(result.tl, quad.tl.rotate(angle))
+    assert is_close(result.tr, quad.tr.rotate(angle))
+    assert is_close(result.br, quad.br.rotate(angle))
+
+
+@given(
+    quad=quads(),
+    angle=floats,
+    pivot=vecs(),
+)
+@settings(deadline=timedelta(seconds=2))
+def test_quad_rotate_about(quad, angle, pivot):
+    def fn():
+        return quad.rotate_about(angle, pivot)
+
+    result = validate_dual_run(fn)
+    assert is_close(result.bl, quad.bl.rotate_about(angle, pivot))
+    assert is_close(result.tl, quad.tl.rotate_about(angle, pivot))
+    assert is_close(result.tr, quad.tr.rotate_about(angle, pivot))
+    assert is_close(result.br, quad.br.rotate_about(angle, pivot))
+
+
+@given(quad=quads())
+@settings(deadline=timedelta(seconds=2))
+def test_quad_center(quad):
+    def fn():
+        return quad.center
+
+    result = validate_dual_run(fn)
+    expected = (quad.bl + quad.tr + quad.tl + quad.br) / 4
+    assert is_close(result, expected)
+
+
+# Rect Tests
+@given(
+    rect=rects(),
+    translation=vecs(),
+)
+@settings(deadline=timedelta(seconds=2))
+def test_rect_translate(rect, translation):
+    def fn():
+        return rect.translate(translation)
+
+    result = validate_dual_run(fn)
+    assert is_close(result.t, rect.t + translation.y)
+    assert is_close(result.r, rect.r + translation.x)
+    assert is_close(result.b, rect.b + translation.y)
+    assert is_close(result.l, rect.l + translation.x)
+
+
+@given(
+    rect=rects(),
+    factor=vecs(),
+)
+@settings(deadline=timedelta(seconds=2))
+def test_rect_scale(rect, factor):
+    def fn():
+        return rect.scale(factor)
+
+    result = validate_dual_run(fn)
+    assert is_close(result.t, rect.t * factor.y)
+    assert is_close(result.r, rect.r * factor.x)
+    assert is_close(result.b, rect.b * factor.y)
+    assert is_close(result.l, rect.l * factor.x)
+
+
+@given(
+    rect=rects(),
+    factor=vecs(),
+    pivot=vecs(),
+)
+@settings(deadline=timedelta(seconds=2))
+def test_rect_scale_about(rect, factor, pivot):
+    def fn():
+        return rect.scale_about(factor, pivot)
+
+    result = validate_dual_run(fn)
+    assert is_close(result.t, (rect.t - pivot.y) * factor.y + pivot.y)
+    assert is_close(result.r, (rect.r - pivot.x) * factor.x + pivot.x)
+    assert is_close(result.b, (rect.b - pivot.y) * factor.y + pivot.y)
+    assert is_close(result.l, (rect.l - pivot.x) * factor.x + pivot.x)
+
+
+@given(
+    rect=rects(),
+    expansion=vecs(),
+)
+@settings(deadline=timedelta(seconds=2))
+def test_rect_expand(rect, expansion):
+    def fn():
+        return rect.expand(expansion)
+
+    result = validate_dual_run(fn)
+    assert is_close(result.t, rect.t + expansion.y)
+    assert is_close(result.r, rect.r + expansion.x)
+    assert is_close(result.b, rect.b - expansion.y)
+    assert is_close(result.l, rect.l - expansion.x)
+
+
+@given(
+    rect=rects(),
+    point=vecs(),
+)
+@settings(deadline=timedelta(seconds=2))
+def test_rect_contains_point(rect, point):
+    def fn():
+        return rect.contains_point(point)
+
+    result = validate_dual_run(fn)
+    expected = rect.l <= point.x <= rect.r and rect.b <= point.y <= rect.t
+    assert is_close(result, expected)
+
+
+@given(
+    center=vecs(),
+    dimensions=vecs(),
+)
+@settings(deadline=timedelta(seconds=2))
+def test_rect_from_center(center, dimensions):
+    def fn():
+        return Rect.from_center(center, dimensions)
+
+    result = validate_dual_run(fn)
+    assert is_close(result.center.x, center.x)
+    assert is_close(result.center.y, center.y)
+    assert is_close(result.w, dimensions.x)
+    assert is_close(result.h, dimensions.y)
+
+
+@given(rect=rects())
+@settings(deadline=timedelta(seconds=2))
+def test_rect_as_quad(rect):
+    def fn():
+        return rect.as_quad()
+
+    result = validate_dual_run(fn)
+    assert is_close(result.bl, rect.bl)
+    assert is_close(result.tl, rect.tl)
+    assert is_close(result.tr, rect.tr)
+    assert is_close(result.br, rect.br)
+
+
+@st.composite
+def points_with_expected_containment(draw):
+    """Generate a point and whether it should be inside a given quad."""
+    quad = draw(quads())
+
+    is_inside = draw(st.booleans())
+
+    if is_inside:
+        margin = 1.001
+        a = draw(st.floats(min_value=0, max_value=1)) + margin
+        b = draw(st.floats(min_value=0, max_value=1)) + margin
+        c = draw(st.floats(min_value=0, max_value=1)) + margin
+        d = draw(st.floats(min_value=0, max_value=1)) + margin
+        total = a + b + c + d
+        a /= total
+        b /= total
+        c /= total
+        d /= total
+        # Not totally uniform, but good enough for testing
+        point = quad.bl * a + quad.tl * b + quad.tr * c + quad.br * d
+    else:
+        diam = max((quad.tl - quad.br).magnitude, (quad.tr - quad.bl).magnitude)
+        angle = draw(st.floats(min_value=0, max_value=2 * math.pi))
+        scale = draw(st.floats(min_value=1, max_value=2))
+        point = quad.center + Vec2(math.cos(angle), math.sin(angle)) * scale * (diam + 0.001)
+
+    return quad, point, is_inside
+
+
+@given(quad_point_expected=points_with_expected_containment())
+@settings(deadline=timedelta(seconds=2))
+def test_quad_contains_point(quad_point_expected):
+    quad, point, expected = quad_point_expected
+
+    def fn():
+        return quad.contains_point(point)
+
+    result = validate_dual_run(fn)
+    assert result == expected, f"Expected point {point} to be {'inside' if expected else 'outside'} quad {quad}"