fix: 2 more Windows test-portability gaps from tonight's CI-red survey

Python UnicodeEncodeError: instance_deform_cache_test.py and
large_scene_generated_test.py (backs the _generated/_500/_1000 CTest
names) printed "!=" as unicode "≠" and ">=" as "≥" in PASS messages.
Windows' default console codepage (cp1252) can't encode those
characters, crashing the test harness itself rather than the product
under test. Replaced with plain ASCII.

Write-protection test assumption: mc3togltf_no_partial_output
(STAB-0546b) and mc3tomcb_error_handling (STAB-0538) simulated an
unwritable output directory via os.chmod(dir, ...) with POSIX mode
bits. On Windows, os.chmod() can only toggle FILE_ATTRIBUTE_READONLY,
which Windows ignores for directories, so it never actually blocked
writes there -- the CLI succeeded (exit 0) where the test expected
rejection. Replaced with a directory-permission-independent mechanism:
point the output path at a parent directory that is simply never
created, which fails identically ("no such file or directory") on
every platform and exercises the same downstream "does a write
failure leave partial output" code path without depending on any OS
permission model.

Verified via a MinGW+Wine repro of both fixes: built mc3togltf.exe/
mc3tomcb.exe for Windows and ran the actual Python test scripts against
them through Wine (via a small wrapper script, since this sandbox has
no binfmt_misc handler for .exe) -- all 4 sub-cases (STAB-0546a/b,
STAB-0537/0538) pass. Also reconfirmed the full mc3togltf_*/mc3tomcb_*
suite on Linux (77/80, same 3 already-known Blender/numpy failures,
zero regressions).

Author: robertvokac

NEXT.md

@@ -333,6 +333,34 @@ known (not new) failures, not yet fixed:
   any of tonight's work), a CI-runner apt-package gap unrelated to anything
   fixed this session.
 
+User asked to keep going on the remaining 4 items. Fixed 2 more:
+- **Python `UnicodeEncodeError`**: 2 files (`instance_deform_cache_test.py`,
+  `large_scene_generated_test.py` — the latter backs all 3 `_generated`/
+  `_500`/`_1000` CTest names) printed `≠`/`≥` in PASS messages; Windows'
+  default console codepage (cp1252) can't encode those. Replaced with
+  `!=`/`>=`. Verified unchanged behavior on Linux (still 100% pass);
+  correctness of the fix itself doesn't depend on Windows-specific
+  verification since removing non-ASCII output is unconditionally safe on
+  any codepage.
+- **Windows write-protection test assumption**: `mc3togltf_no_partial_output`
+  (STAB-0546b) and `mc3tomcb_error_handling` (STAB-0538) simulated an
+  unwritable output directory via `os.chmod(dir, ...)` with POSIX mode
+  bits — on Windows, `os.chmod()` can only toggle `FILE_ATTRIBUTE_READONLY`,
+  which Windows ignores for directories, so it never actually blocked
+  writes there. Replaced with a directory-permission-independent
+  mechanism: point the output path at a parent directory that's simply
+  never created. This fails identically on every platform (the exporter's
+  file-open-for-write call gets "no such file or directory") and tests the
+  exact same downstream code path ("does a write failure leave partial
+  output or a non-zero exit"), without relying on OS permission-model
+  differences at all. Verified via the same MinGW+Wine repro technique as
+  the `mc3_roundtrip` fix above — built `mc3togltf.exe`/`mc3tomcb.exe` for
+  Windows and ran both Python test scripts against them through Wine (via
+  a small wrapper script, since this sandbox has no binfmt_misc handler
+  for `.exe`): both STAB-0546a/b and STAB-0537/0538 cases pass. Also
+  reconfirmed the full `mc3togltf_*`/`mc3tomcb_*` suite on Linux (77/80,
+  same 3 already-known Blender/`numpy` failures, zero regressions).
+
 ## Known release blockers and decisions
 
 | Area | Live state |

mc3togltf/test/instance_deform_cache_test.py

@@ -77,19 +77,19 @@ def run(cmd):
             f"Undeformed block (mesh {block_a_mesh}) and wide-deformed block "
             f"(mesh {wide_a_mesh}) must NOT share a mesh"
         )
-        print(f"No-deform mesh ({block_a_mesh}) ≠ wide-deform mesh ({wide_a_mesh}) — PASS")
+        print(f"No-deform mesh ({block_a_mesh}) != wide-deform mesh ({wide_a_mesh}) — PASS")
 
         assert wide_a_mesh != tall_mesh, (
             f"Wide-deformed block (mesh {wide_a_mesh}) and tall-deformed block "
             f"(mesh {tall_mesh}) must NOT share a mesh"
         )
-        print(f"Wide-deform mesh ({wide_a_mesh}) ≠ tall-deform mesh ({tall_mesh}) — PASS")
+        print(f"Wide-deform mesh ({wide_a_mesh}) != tall-deform mesh ({tall_mesh}) — PASS")
 
         assert block_a_mesh != tall_mesh, (
             f"Undeformed block (mesh {block_a_mesh}) and tall-deformed block "
             f"(mesh {tall_mesh}) must NOT share a mesh"
         )
-        print(f"No-deform mesh ({block_a_mesh}) ≠ tall-deform mesh ({tall_mesh}) — PASS")
+        print(f"No-deform mesh ({block_a_mesh}) != tall-deform mesh ({tall_mesh}) — PASS")
 
         # Total unique meshes: 3 (undeformed, wide, tall)
         assert len(meshes) == 3, (

mc3togltf/test/large_scene_generated_test.py

@@ -116,7 +116,7 @@ def run(cmd):
         assert len(nodes) >= total, (
             f"Expected at least {total} glTF nodes, got {len(nodes)}"
         )
-        print(f"Node count: {len(nodes)} (expected ≥ {total}) — PASS")
+        print(f"Node count: {len(nodes)} (expected >= {total}) — PASS")
 
         # ----------------------------------------------------------------
         # Mesh reuse: 3 unique mesh geometries for 200 nodes.
@@ -127,7 +127,7 @@ def run(cmd):
             f"got {len(meshes)} — geometry reuse is not working"
         )
         assert len(nodes) >= len(meshes) * 10, (
-            f"Expected nodes ({len(nodes)}) ≥ 10× meshes ({len(meshes)})"
+            f"Expected nodes ({len(nodes)}) >= 10x meshes ({len(meshes)})"
         )
         print(f"Unique meshes: {len(meshes)} vs {len(nodes)} nodes — PASS")
 

mc3togltf/test/no_partial_output_test.py

@@ -9,14 +9,16 @@
 
   1. Malformed input XML (Mc3Document::loadFromFile() throws before
      exportDocument() is even called).
-  2. A write-protected output directory (WriteGltfSceneToFile() fails at
-     the file-open step; verified empirically to create zero bytes on
-     disk, not a truncated/partial file).
+  2. An unwritable output path -- its parent directory is never created,
+     so WriteGltfSceneToFile() fails at the file-open step; verified
+     empirically to create zero bytes on disk, not a truncated/partial
+     file. (Not a chmod'd read-only directory: Windows' os.chmod() can
+     only toggle FILE_ATTRIBUTE_READONLY, which Windows ignores for
+     directories, so that wouldn't actually block writes there.)
 
 Usage: no_partial_output_test.py <mc3togltf> <fixture.mc3.xml>
 """
 import os
-import stat
 import subprocess
 import sys
 import tempfile
@@ -52,23 +54,17 @@ def run(cmd):
         )
         print(f"PASS (STAB-0546a): malformed input rejected -- exit {r.returncode}, no output file")
 
-    # STAB-0546b: write-protected output directory.
+    # STAB-0546b: unwritable output path (parent directory never created).
     with tempfile.TemporaryDirectory() as tmpdir:
-        readonly_dir = os.path.join(tmpdir, "readonly")
-        os.mkdir(readonly_dir)
-        os.chmod(readonly_dir, stat.S_IRUSR | stat.S_IXUSR)  # r-x, no write
-        try:
-            out_glb = os.path.join(readonly_dir, "out.glb")
-            r = run([mc3togltf, fixture, out_glb])
-            assert r.returncode != 0, (
-                f"expected a non-zero exit for a write-protected output path, got 0.\n"
-                f"stdout={r.stdout}\nstderr={r.stderr}"
-            )
-            assert r.stderr.strip(), "expected an error message on stderr for a write-protected output path"
-            assert not os.path.exists(out_glb), (
-                "expected no output file for a write-protected output path, but one was created "
-                "(even a zero-length/partial file)"
-            )
-            print(f"PASS (STAB-0546b): write-protected output rejected -- exit {r.returncode}, no output file")
-        finally:
-            os.chmod(readonly_dir, stat.S_IRWXU)  # restore so TemporaryDirectory cleanup can remove it
+        out_glb = os.path.join(tmpdir, "does_not_exist", "out.glb")
+        r = run([mc3togltf, fixture, out_glb])
+        assert r.returncode != 0, (
+            f"expected a non-zero exit for an unwritable output path, got 0.\n"
+            f"stdout={r.stdout}\nstderr={r.stderr}"
+        )
+        assert r.stderr.strip(), "expected an error message on stderr for an unwritable output path"
+        assert not os.path.exists(out_glb), (
+            "expected no output file for an unwritable output path, but one was created "
+            "(even a zero-length/partial file)"
+        )
+        print(f"PASS (STAB-0546b): unwritable output path rejected -- exit {r.returncode}, no output file")

mc3tomcb/test/mc3tomcb_error_test.py

@@ -7,16 +7,19 @@
 
   STAB-0537: a missing input file (Mc3Document::loadFromFile() throws
              tinyxml2's XML_ERROR_FILE_NOT_FOUND).
-  STAB-0538: a write-protected output directory (Mcb::saveToFile() /
+  STAB-0538: an unwritable output path (Mcb::saveToFile() /
              Mc3Document::saveToFile() throw "Cannot open for writing").
-             Uses a fresh temp dir with its write bit stripped (chmod
-             0o555) rather than a hardcoded root-owned path, so this
-             test doesn't depend on the runner's privilege level.
+             Uses a fresh temp dir with a never-created subdirectory
+             component in the output path, rather than a hardcoded
+             root-owned path or a chmod'd read-only directory -- the
+             former depends on the runner's privilege level, and the
+             latter doesn't work on Windows (os.chmod() there can only
+             toggle FILE_ATTRIBUTE_READONLY, which Windows ignores for
+             directories, so it wouldn't actually block writes).
 
 Usage: mc3tomcb_error_test.py <mc3tomcb-exe> <fixture.mc3.xml>
 """
 import os
-import stat
 import subprocess
 import sys
 import tempfile
@@ -41,23 +44,17 @@ def main():
         assert not os.path.exists(out_mcb), "expected no output file for a missing input file"
         print(f"PASS (STAB-0537): missing input rejected -- exit {r.returncode}, stderr: {r.stderr.strip()[:80]}")
 
-    # STAB-0538: write-protected output directory.
+    # STAB-0538: unwritable output path (parent directory never created).
     with tempfile.TemporaryDirectory() as tmpdir:
-        readonly_dir = os.path.join(tmpdir, "readonly")
-        os.mkdir(readonly_dir)
-        os.chmod(readonly_dir, stat.S_IRUSR | stat.S_IXUSR)  # r-x, no write
-        try:
-            out_mcb = os.path.join(readonly_dir, "out.mcb")
-            r = subprocess.run([exe, fixture, out_mcb], capture_output=True, text=True)
-            assert r.returncode != 0, (
-                f"expected a non-zero exit for a write-protected output path, got 0.\n"
-                f"stdout={r.stdout}\nstderr={r.stderr}"
-            )
-            assert r.stderr.strip(), "expected an error message on stderr for a write-protected output path"
-            assert not os.path.exists(out_mcb), "expected no output file for a write-protected output path"
-            print(f"PASS (STAB-0538): write-protected output rejected -- exit {r.returncode}, stderr: {r.stderr.strip()[:80]}")
-        finally:
-            os.chmod(readonly_dir, stat.S_IRWXU)  # restore so TemporaryDirectory cleanup can remove it
+        out_mcb = os.path.join(tmpdir, "does_not_exist", "out.mcb")
+        r = subprocess.run([exe, fixture, out_mcb], capture_output=True, text=True)
+        assert r.returncode != 0, (
+            f"expected a non-zero exit for an unwritable output path, got 0.\n"
+            f"stdout={r.stdout}\nstderr={r.stderr}"
+        )
+        assert r.stderr.strip(), "expected an error message on stderr for an unwritable output path"
+        assert not os.path.exists(out_mcb), "expected no output file for an unwritable output path"
+        print(f"PASS (STAB-0538): unwritable output path rejected -- exit {r.returncode}, stderr: {r.stderr.strip()[:80]}")
 
 
 if __name__ == "__main__":