[arahlin]

qpoint had no tests. This adds a pytest suite — 448 of them — and the CI to run it, in six commits.

Based on fast-pix-exact (#34), and through it on fix-map-modes (#33).

No library behaviour changes here; src/qp_selftest.c is new C source but it is test
scaffolding. Faults the tests turned up were each fixed below as their own commit, on
master or on one of those two PRs — the tests for all of them are here, this being
where the suite lives:

• Fix the map mode handling in init_dest and init_source #33, the map mode handling in init_dest/init_source, whose update=True path
  had no coverage at all and turned out to reinterpret the maps it was only meant to swap:
  TestUpdateDest, TestUpdateSource, TestVpolIsChecked and
  TestPolAndVpolDefaultToNone in test_qmap.py.
• Make fast_pix exact, and turn it on by default #34, fast_pix, whose polarization angle lost 2e-10 near the poles and is now
  bit-identical to the angle path: TestFastPix in test_qpoint.py, which asserts that
  over the whole sky and inside each cap, and that the option is on by default. Eleven of
  its sixteen cases fail against the previous arithmetic, five of them only inside a cap.

	tests
tests/test_qpoint.py	229	coordinate conversions, the parameter API, broadcasting, IERS Bulletin A, pixelization, galactic rotation
tests/test_qmap.py	185	mapmaking: flags, weights, gain, pair differencing, partial maps, derivative map modes, missing-pixel policy, threading, init_* map modes
tests/test_tools.py	8	the standalone refraction function
tests/test_astropy.py	11	azel2radec/radec2azel against astropy, sidereal time against its clock, the galactic rotation against ERFA
tests/test_selftest.py	2	one binding over src/qp_selftest.c
tests/test_benchmarks.py	13	timings, opt-in

Four of these pin behaviour that is easy to "fix" into something wrong:

• Derivative map modes. Row count determines the mode and the mode determines which
  rows map2tod1 reads; the authority is the kernel, not qp_num_maps. The test perturbs
  every row of every valid row count and requires the TOD to change.
• Threading. tod2map merges thread-local maps in arrival order, so only the hit
  counts come back identical. The rest is checked to a tolerance well inside the ~1e-15
  observed.
• The solvers leave proj alone. None writes to a proj it does not hand back, which
  is what lets them read it in place; a write added on one of those paths would corrupt the
  caller's array silently.
• IERS Bulletin A. The loader test uses three distinct constants, so a rotated column
  is visible rather than plausible.

Against astropy

test_astropy.py is the only external reference. The two agree to 14 mas once qpoint has
the same IERS data, which QPoint(update_iers=True) arranges for itself. The rates still
have to be on — rate_dut1/rate_wobble default to never, and the inverse transforms
need the _inv variants or radec2azel silently loses polar motion, a quarter of an
arcsecond. Without any of it the two disagree by 6 arcsec, which is also pinned. Nothing
touches the network: astropy's auto-download is switched off for the duration, and the
fixture is autouse because update_iers reads the table during construction.

Two transforms had no outside reference and now do. Sidereal time is checked against
astropy's, gmst and lmst both, longitude entering at lmst and nowhere else.

The galactic rotation is checked against erfa.icrs2g, which it matches exactly both
directions, rather than against astropy's Galactic, which it misses by 25 mas. That gap
is a convention difference — qpoint and ERFA use the Hipparcos angles straight from ICRS,
astropy reads the same three numbers as FK5 and takes the frame bias back on — and is
asserted separately so it stays on the record. A gal2radec round trip would catch none of
it, turning by the wrong angle and back still returning where it started.

The C constructors, exercised from C

qp_init_det, qp_init_detarr, qp_init_point, qp_init_map*, qp_copy_pixhash and
qp_copy_memory are public C API the Python package never calls — _libqpoint.py builds
those structs itself through its ctypes mirrors — so nothing a pytest can reach touches
them. src/qp_selftest.c drives them as an external C consumer would, and one binding runs
the lot: 59 numbered checks that each constructor fills the struct it claims to, that
copy=0 aliases and copy=1 copies, that a pixel hash survives being copied and still
refuses an absent pixel, that qp_copy_memory duplicates the Bulletin A table rather than
aliasing it, and that qp_reshape_map repoints every row when the row count changes. A
failure comes back as the number and text of the first check that failed.

Two constraints if you extend it: qp_init_map_pixhash wants the pixel list exactly as
long as the map, so the hash checks build a partial map; and the bulletin stores float,
so its test values are chosen to survive the narrowing.

Coverage

Measured by hand — coverage for the Python, gcov over a temporary -O0 --coverage
build for the C. All 400 pass under gcc with instrumentation.

qpoint			C library
tools.py, _version.py	100%		qp_selftest.c	100%
_libqpoint.py	93%		qp_pixhash.c	97%
qpoint_class.py	90%		qp_iers_bulletin_a.c	90%
qmap_class.py	87%		qp_pixel.c	90%
total	90%		qpoint.c	88%
			qp_error.c	85%
			qp_params.c	91%
			qp_map.c	74%
			quaternion.c	56%

The self-test is most of what moved in the C: qp_pixhash.c went 58% → 97% and
qp_iers_bulletin_a.c 79% → 90%, those being the files whose copy helpers are reachable
only through qp_copy_memory.

Nothing needed a gcov --exclude. qp_map.c read 47% before this suite, largely
because twenty-odd C-level constructors never ran. The two real cases were separated
instead: the ones the ctypes layer cannot reach are reached from C by the self-test, and
the five for which no declaration ever existed — qp_init_map_1d,
qp_init_map_from_arrays_1d and the three qp_init_detarr_*_from_array_1d — were deleted
on master, along with the four bulk setters, which is most of what moved qp_params.c.

quaternion.c's 56% is the remaining honest gap: declared, reachable public API with no
caller in the tree — the full 3×3 Quaternion_to_matrix, only _col3 being used, and the
QuaternionSlerp pair. An external C consumer can call those, so they count.

CI

.github/workflows/tests.yaml runs on ubuntu-latest and macos-latest against Python
3.9, 3.11 and 3.13. Optional dependencies are declared with markers and their tests skip
where absent, neither astropy nor healpy shipping wheels for 3.9:

test = ["pytest", "astropy>=6", "healpy>=1.17; python_version >= '3.10'"]

Every run prints the build it is testing, because it cannot be read off the result: the
threading tests pass on a serial build too, one thread trivially agreeing with itself, so a
build that quietly lost its parallelism would look exactly like one that kept it. There is
nothing in the C library to ask, so conftest.py reads the linkage of the built extension,
and on Linux under CI the suite fails if the build turns out serial. macOS is serial on
purpose: Apple clang ships no OpenMP runtime, and linking LLVM's collides with the one
healpy bundles.

Running it

pip install -e ".[test]"
pytest                  # ~1 s
pytest --benchmark      # adds the timing table

The benchmarks measure rather than assert, and a shared runner is too noisy for the numbers
to mean much. They are still collected without the flag, and each asserts the shape of its
result so one cannot quietly end up timing a no-op.

One detail in conftest.py that should not be undone: the timed call runs on a worker
thread. On the main thread, whose stack address is a deterministic function of the command
line, a tight loop's spilled temporaries can alias the heap buffers it streams — moving a
measurement by 3x, reproducibly enough to read as a result rather than as noise.

🤖 Generated with Claude Code