source_cell: replace #define private public with named friend grants in four tests

[Critsium-xy]

Second tranche of the #define private public cleanup, after #7940. That PR
removed the macros whose cause was the code under test reading global PARAM;
this one removes the macros whose cause is the test calling a private method,
which needs a different fix and touches no global state at all.

Which files, and why these four

Classifying every macro region in the tree by what it actually covers gives two
root causes — (a) the production code reads global PARAM itself, so the
test can only drive it by writing the private PARAM.input/PARAM.sys; and
(b) the test reaches into the class under test. (b) subdivides further, and
the cheapest sub-case is the one handled here:

the test calls a private method — no private data member is involved.

For these four files that is the only cause. None of them touches PARAM, so
there is no global-dependency work mixed in and no governance budget to balance
(unlike #7940, where the call-site cost had to be paid for by a paired cleanup).

• magnetism_test.cpp — Magnetism::judge_parallel, 2 call sites.
• atom_pseudo_test.cpp — Pseudopot_upf::read_pseudo_upf201, 2 call sites.
• pseudo_nc_test.cpp — read_pseudo_upf201, complete_default_h,
  complete_default_atom, 8 call sites.
• read_pp_test.cpp — read_pseudo_upf, read_pseudo_upf201,
  read_pseudo_vwr, read_pseudo_blps, set_pseudo_type, setqfnew, trim,
  trimend, 26 call sites.

In every case the private method is the thing the test exists to exercise — the
file headers say so (read_pp_test.cpp lists read_pseudo_upf,
set_pseudo_type, trim/trimend under "Tested Functions", and
magnetism_test.cpp lists Magnetism::judge_parallel()).

The fix

An explicit friend class <fixture>; on the class under test, which is what
AGENTS.md rule 10 names and what this codebase already does in
source_pw/module_pwdft/dftu_base.h (friend class DFTUTest;) and
source_io/module_parameter/parameter.h (friend class TestParameters;). The
whole production-side change is 15 lines:

class MagnetismTest;

class Magnetism
{
    /// @brief the unit test drives the private judge_parallel() helper directly
    friend class MagnetismTest;

public:

plus the same for Pseudopot_upf with its three fixtures. No method changed
visibility, no signature changed, no member was added.

This is a real narrowing rather than a cosmetic one. #define private public
reinterprets access control for the entire translation unit — including every
standard library header the TU pulls in, which is undefined behaviour that
surfaces at link or run time rather than as a compile error — and leaves that TU
disagreeing with the rest of the build about the layout and accessibility of
every class it sees. A friend declaration grants one named class access to one
other class, is visible in the header where the class is defined, and is
reviewable.

Friendship is not inherited and a TEST_F body lives in a class derived from
the fixture, so each fixture gains thin forwarding wrappers and the TEST_F
bodies call those. dftu_lcao_test.cpp already documents and uses exactly this
arrangement. Every wrapper forwards its arguments unmodified and returns what the
private method returns.

What is deliberately unchanged

Public members and public methods the tests already used are untouched and still
accessed directly: Pseudopot_upf::complete_default, init_pseudo_reader,
average_p, set_upf_q, set_empty_element, print_pseudo_upf and its public
data (kbeta, qfunc, qfcoef, lloc, nqf, ...), and Magnetism's
tot_mag / abs_mag / start_mag / compute_mag. Only the calls that actually
needed the macro were rerouted.

Magnetism::judge_parallel could alternatively have been made a public static —
it is a pure predicate that touches no member. That was not done: it would
enlarge the public API permanently to serve a test, where friend does not.

No #undef private is introduced anywhere, and no file whose macro this PR does
not remove is touched — the scope rule from #7921.

Result

	before	after
files with the macro (tree-wide)	67	63
occurrences	95	91
macro occurrences in these four files	4	0

Verification

Linux, cmake -B build -G Ninja -DBUILD_TESTING=ON -DENABLE_LCAO=ON -DENABLE_MPI=ON -DENABLE_OPENMP=ON:

• build: 0 errors (branch and base both BUILD_EXIT=0).
• the affected tests: MODULE_CELL_read_pp, MODULE_CELL_pseudo_nc,
  MODULE_CELL_atom_pseudo, MODULE_CELL_bcast_atom_pseudo_test,
  MODULE_CELL_magnetism — all pass, with every assertion and expected value
  unchanged.
• full unit suite: 29 of 339 fail — the failure set is identical to the base
  commit (d3722debd) built and run in a parallel worktree in the same
  environment; both comm directions are empty. The 29 are pre-existing and
  environment-related (mpirun-based *_para/*_parallel wrappers, plus
  cubic_spline, math_sphbes, dav, bpcg, PSI_init, ...).
• agent_governance_check.py: 0 errors, exit 0. The access-hack ratchet
  reports nothing (4 removed, 0 added), and the global-dependency budget is
  untouched because no PARAM/GlobalV/GlobalC reference is added or removed.
• verified via compiled objects that all four changed test files were actually
  built, rather than skipped by the local feature configuration.

The one governance warning is "Documentation sync review": no INPUT parameter and
no user-visible behaviour changed — this is a test-visibility change only — so
docs/parameters.yaml and docs/advanced/input_files/input-main.md need no
update.

What is not here

The remaining 63 files split by the same taxonomy. The next cheapest group is
tests that read a private member for which a public getter already exists and
is simply not being used — those need no production change at all. A related but
distinct case has to be handled with care: where the assertion is
EXPECT_EQ(obj.get_x(), obj.x), substituting the getter makes it a tautology, so
the assertion has to be re-anchored to the known input value instead (which also
makes the test stronger). Beyond that lie tests that read private state with no
getter (a public const observer) and tests that write private state to build
a fixture (a setter or a different construction path) — the latter is the
expensive tail and includes klist_test.cpp, charge_mixing_test.cpp and
read_input_item_test.cpp.

🤖 Generated with Claude Code

[mohanchen]

LGTM