`FileStandardInfo.AllocationSize` turned out to be the wrong question. Measured
against `fsutil` and `compact` on a real Windows 10 volume:
- it returns the cluster-rounded logical length for ordinary files, including
1 GiB files extended by `SetEndOfFile` (NTFS does hand over the whole tail,
and free space moves accordingly) and sub-cluster files living in `$MFT`;
- it reported the full 8 MiB for a file `compact` accounts as 1,572,864 stored
bytes, i.e. it is blind to NTFS compression, which is the one way Windows
really does hide size on disk;
- `FSCTL_QUERY_ALLOCATED_RANGES` reported that same compressed file as fully
allocated, so "which clusters exist" is not "what do they weigh".
`GetCompressedFileSizeW` answers 1,572,864, matching `compact` byte for byte.
It takes the path we already hold instead of a handle, so it is one query per
file rather than a `CreateFileW` pair, and it keeps answering while another
process holds the file open exclusively — the normal state of a cache file.
That also removes the `ALLOCATION_PROBE_MIN` cutoff: it existed to avoid a
handle per small file, and small files on a compressed volume need the honest
number just as much.
Guard the zero answer behind `FILE_ATTRIBUTE_COMPRESSED`/`SPARSE_FILE` (free
from the `Metadata` we already have) so a deleted-but-still-open file cannot
zero out a total the user is about to act on, and read `GetLastError` to tell
failure from a genuine 4 GiB-minus-one length.
Tests: each platform now gets the fixture that provokes its own divergence —
POSIX holes for `st_blocks`, and a `compact`-compressed file for the Windows
path. The old Windows sparse fixture proved nothing: extending a file does not
hole out on NTFS, and `FSCTL_SET_SPARSE` is refused outright on this volume
(`ERROR_INVALID_FUNCTION`), as is `FSCTL_SET_COMPRESSION`
(`ERROR_ACCESS_DENIED`) even for a file we created ourselves.
Real Windows 10 hardware turned up two failures the macOS and cross-compile
checks could not see:
- squid-core::fs reported every file's logical length as its allocated size,
because `allocated_bytes` returned 0 on non-Unix and `on_disk()` then fell
back to logical. NTFS only answers the allocation question through a handle,
so ask `GetFileInformationByHandleEx(FileStandardInfo)` for files big enough
to distort a total. Files below the cutoff keep counting as their length,
which is also what keeps MFT-resident entries — they report an allocation of
0 — from shrinking a cache cleanup down to nothing.
- the "a plain user can still uninstall into /Applications" safety test hard
coded a Unix path, so on Windows it asserted that a folder the policy never
looked at was refused. The fixture now comes from the policy's own shared
install folder, `/Applications` on Unix and the machine-wide program-data
folders on Windows.
Also added:
- `a_written_file_reports_what_the_volume_gave_it`, the cross-platform
invariant the missing backend silently violated.
- the sparse-file test now marks its file sparse via `fsutil` on Windows and
skips when the volume will not cooperate, instead of pretending a hole
exists.
- `scripts/win-sync.sh`, `scripts/win-check.ps1` and `scripts/win-hwcheck.ps1`
for iterating against a LAN Windows host over SSH without git credentials.