Remove extra test folder need entirely. nanobind version is tested automatically when needed.

Signed-off-by: Aleksandr Motsjonov <soswow@gmail.com>

Author: soswow

src/cmake/testing.cmake

@@ -233,9 +233,6 @@ macro (oiio_add_all_tests)
             python-imageinput python-imagebufalgo
             IMAGEDIR oiio-images
             )
-        if (OIIO_BUILD_PYTHON_NANOBIND)
-            oiio_add_tests (python-roi-nanobind python-typedesc-nanobind)
-        endif ()
     endif ()
 
     oiio_add_tests (oiiotool-color

testsuite/common/pythonbinding_loaders.py

@@ -7,6 +7,7 @@
 from __future__ import annotations
 
 import importlib
+import importlib.util
 import pathlib
 import sys
 
@@ -25,3 +26,37 @@ def load_nanobind_oiio_package(build_root: pathlib.Path):
 
     sys.path.insert(0, str(package_root))
     return importlib.import_module("OpenImageIO")
+
+
+def load_python_test_run(test_name: str, script_path: pathlib.Path):
+    """Load ``run(oiio)`` from a canonical Python testsuite module by path.
+
+    The nanobind migration runners are executed as standalone scripts by
+    ``runtest.py``, so they cannot rely on package-relative imports. This
+    helper locates the original pybind11 test module under ``testsuite`` and
+    returns its exported ``run`` function.
+    """
+    testsuite_root = None
+    for parent in [script_path.resolve().parent] + list(script_path.resolve().parents):
+        if parent.name == "testsuite":
+            testsuite_root = parent
+            break
+    if testsuite_root is None:
+        raise RuntimeError(f"Could not determine testsuite root from {script_path}")
+
+    test_src_dir = testsuite_root / test_name / "src"
+    test_modules = sorted(test_src_dir.glob("*.py"))
+    if len(test_modules) != 1:
+        raise RuntimeError(
+            f"Expected exactly one Python test module in {test_src_dir}, "
+            f"found {len(test_modules)}"
+        )
+    test_module = test_modules[0]
+    spec = importlib.util.spec_from_file_location(f"oiio_{test_name}_module",
+                                                  test_module)
+    if spec is None or spec.loader is None:
+        raise RuntimeError(f"Could not load Python test module from {test_module}")
+
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module.run

testsuite/common/run_nanobind_python_test.py

@@ -0,0 +1,34 @@
+#!/usr/bin/env python
+
+# Copyright Contributors to the OpenImageIO project.
+# SPDX-License-Identifier: Apache-2.0
+# https://github.com/AcademySoftwareFoundation/OpenImageIO
+
+from __future__ import annotations
+
+import pathlib
+import sys
+
+from pythonbinding_loaders import load_nanobind_oiio_package, load_python_test_run
+
+
+def main() -> int:
+    if len(sys.argv) != 3:
+        raise SystemExit(
+            "Usage: run_nanobind_python_test.py <canonical-test-name> <build-root>"
+        )
+
+    test_name = sys.argv[1]
+    build_root = pathlib.Path(sys.argv[2]).resolve()
+    run = load_python_test_run(test_name, pathlib.Path(__file__))
+    oiio = load_nanobind_oiio_package(build_root)
+
+    try:
+        run(oiio)
+    except Exception as detail:
+        print("Unknown exception:", detail)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

testsuite/python-roi-nanobind/run.py

@@ -82,6 +82,13 @@ def make_relpath (path: str, start: str=os.curdir) -> str:
 test_source_dir = os.getenv('OIIO_TESTSUITE_SRC',
                             os.path.join(OIIO_TESTSUITE_ROOT, mytest))
 
+# Python tests listed here also run against the staged nanobind package when
+# it exists in the current build tree.
+nanobind_python_tests = {
+    "python-roi",
+    "python-typedesc",
+}
+
 def oiio_app (app: str) -> str:
     if (platform.system () != 'Windows' or options.devenv_config == ""):
         cmd = os.path.join(OIIO_BUILD_ROOT, "bin", app) + " "
@@ -101,6 +108,7 @@ def oiio_app (app: str) -> str:
 
 command = ""
 outputs = [ "out.txt" ]    # default
+ref_name_overrides = {}
 
 # The image comparison thresholds are tricky to remember. Here's the key:
 # A test fails if more than `failpercent` of pixel values differ by more
@@ -354,16 +362,18 @@ def oiiotool (args: str, silent: bool=False, concat: bool=True, failureok: bool=
 # the identical name, and if that fails, it will look for alternatives of
 # the form "basename-*.ext" (or ANY match in the ref directory, if anymatch
 # is True).
-def checkref (name: str, refdirlist: list[str]) -> tuple[bool, str]:
+def checkref (name: str, refdirlist: list[str], refname: str|None=None) -> tuple[bool, str]:
     # Break the output into prefix+extension
-    (prefix, extension) = os.path.splitext(name)
+    if refname is None:
+        refname = name
+    (prefix, extension) = os.path.splitext(refname)
     ok = 0
     for ref in refdirlist :
         # We will first compare name to ref/name, and if that fails, we will
         # compare it to everything else that matches ref/prefix-*.extension.
         # That allows us to have multiple matching variants for different
         # platforms, etc.
-        defaulttest = os.path.join(ref,name)
+        defaulttest = os.path.join(ref,refname)
         if anymatch :
             pattern = "*.*"
         else :
@@ -437,7 +447,8 @@ def runtest (command: str, outputs: list[str], failureok: int=0) -> int :
             if os.path.exists('crlf.txt') :
                 os.remove('crlf.txt')
 
-        (ok, testfile) = checkref (out, refdirlist)
+        refname = ref_name_overrides.get(out, out)
+        (ok, testfile) = checkref (out, refdirlist, refname=refname)
 
         if ok :
             if extension in image_extensions :
@@ -477,13 +488,42 @@ def runtest (command: str, outputs: list[str], failureok: int=0) -> int :
 
 
 #
-# Read the individual run.py file for this test, which will define 
+# Read the individual run.py file for this test, which will define
 # command and outputs.
 #
 with open(os.path.join(test_source_dir,"run.py")) as f:
     code = compile(f.read(), "run.py", 'exec')
     exec (code)
 
+# For tests that have a nanobind port, run the same canonical Python test
+# body a second time against the staged nanobind package from the current
+# build tree. Keep the output separate so failures still indicate which
+# backend mismatched the shared reference output.
+nanobind_package = os.path.join(
+    OIIO_BUILD_ROOT, "lib", "python", "nanobind", "OpenImageIO", "__init__.py"
+)
+if mytest in nanobind_python_tests and os.path.exists(nanobind_package):
+    nanobind_runner = make_relpath(
+        os.path.join(OIIO_TESTSUITE_ROOT, "common", "run_nanobind_python_test.py"),
+        tmpdir,
+    )
+    command += " ; " + (
+        pythonbin
+        + " "
+        + nanobind_runner
+        + " "
+        + mytest
+        + " "
+        + OIIO_BUILD_ROOT
+        + " > out-nanobind.txt"
+    )
+    # Example of final command for `python-roi` would be:
+    # python src/test_roi.py > out.txt ; \
+    # python ../../../testsuite/common/run_nanobind_python_test.py \
+    #   python-roi ../.. > out-nanobind.txt
+    outputs.append("out-nanobind.txt")
+    ref_name_overrides["out-nanobind.txt"] = "out.txt"
+
 # Allow a little more slop for slight pixel differences when in DEBUG
 # mode or when running on remote CI machines.
 if (os.getenv('CI') or os.getenv('DEBUG')) :