AnachronautandClaude Opus 5
78e9eef472
SBFS version two adds directories out of space each entry had already set aside: two of the four reserved bytes become a parent, and one of the seven spare flag bits says an entry is a directory. The entry is still thirty two bytes, so it still divides two hundred and fifty six and still never straddles a block, and nothing in the block layer knows anything happened. A directory is an entry with no blocks. That is what keeps the flat array of entries the whole allocation map, which is the property the format is built on: with files laid down contiguously, every block is inside some entry's range or it is not, and an entry with no range is in nobody's way. There is still no allocation table to consult and none to keep right. THE PARENT IS AN INDEX PLUS ONE, so zero means the root. A version one disk has zeroes in those bytes, and "in the root" is exactly where every file on a flat disk is - so a version one image is already a valid version two image, with nothing to convert and no tool to convert it with. A disk is at the lowest version that describes what is on it. format makes a version one disk and mkdir is what raises it, so everything built here stays readable by a reader that has never heard of a directory right up until it really does have one. That is what lets this land before the machine knows anything: the whole existing suite passes untouched. The tool gains mkdir and rmdir, and list, put, get and delete take paths. list also now reports entries used against entries available, because a disk has two ceilings and the entry one is the one nobody notices until it bites. rmdir refuses a directory with anything in it, and that is not politeness: parents are entry indices, a freed index gets handed out again, and the children of a removed directory would reappear inside whatever took its place. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01E2JrLzFvuFX9fgi1LDRjrW
165 lines
7.1 KiB
Bash
Executable File
165 lines
7.1 KiB
Bash
Executable File
#!/usr/bin/env bash
|
|
# Checks SplitDisk against the SBFS format.
|
|
#
|
|
# The tool and the SplitBit side are two implementations of one written specification,
|
|
# and nothing but that document keeps them the same. This checks the host half on its
|
|
# own: that a file put onto a disk comes back off it byte for byte, that the sizes which
|
|
# exercise the block and tail arithmetic all survive, and that the things the format
|
|
# says cannot happen are refused rather than half done.
|
|
#
|
|
# Written by Anachronaut
|
|
|
|
set -u
|
|
ROOT="$(cd "$(dirname "$0")/.." && pwd)"
|
|
TOOL="$ROOT/SplitDisk"
|
|
WORK="$ROOT/Tests/build/disk"
|
|
|
|
PASS=0
|
|
FAIL=0
|
|
FAILED_NAMES=()
|
|
|
|
GREEN=$'\033[32m'; RED=$'\033[31m'; RESET=$'\033[0m'
|
|
[ -t 1 ] || { GREEN=""; RED=""; RESET=""; }
|
|
|
|
check() {
|
|
local name="$1"; shift
|
|
if "$@" >/dev/null 2>&1; then
|
|
PASS=$((PASS + 1)); printf " [%sok %s] %s\n" "$GREEN" "$RESET" "$name"
|
|
else
|
|
FAIL=$((FAIL + 1)); FAILED_NAMES+=("$name")
|
|
printf " [%sFAIL%s] %s\n" "$RED" "$RESET" "$name"
|
|
fi
|
|
}
|
|
|
|
# The opposite: the command is supposed to fail, and passing would be the bug.
|
|
refuses() {
|
|
local name="$1"; shift
|
|
if "$@" >/dev/null 2>&1; then
|
|
FAIL=$((FAIL + 1)); FAILED_NAMES+=("$name")
|
|
printf " [%sFAIL%s] %s (it was allowed)\n" "$RED" "$RESET" "$name"
|
|
else
|
|
PASS=$((PASS + 1)); printf " [%sok %s] %s\n" "$GREEN" "$RESET" "$name"
|
|
fi
|
|
}
|
|
|
|
if [ ! -x "$TOOL" ]; then
|
|
echo "SplitDisk is not built."
|
|
exit 1
|
|
fi
|
|
|
|
rm -rf "$WORK"; mkdir -p "$WORK"
|
|
cd "$WORK" || exit 1
|
|
|
|
echo "Checking SplitDisk against the SBFS format."
|
|
|
|
check "format a disk" "$TOOL" format work.img 64 2
|
|
refuses "refuse a disk with no room" "$TOOL" format tiny.img 2 4
|
|
refuses "refuse an unformatted disk" "$TOOL" list /dev/null
|
|
|
|
# The sizes that exercise every corner of blocks-plus-tail: nothing at all, less than a
|
|
# block, exactly a block, a part block, and an exact multiple.
|
|
: > empty.bin
|
|
printf 'x' > one.bin
|
|
head -c 256 /dev/urandom > exact.bin
|
|
head -c 700 /dev/urandom > part.bin
|
|
head -c 768 /dev/urandom > whole.bin
|
|
|
|
for f in empty.bin one.bin exact.bin part.bin whole.bin; do
|
|
check "put $f" "$TOOL" put work.img "$f"
|
|
done
|
|
|
|
roundTrip() {
|
|
"$TOOL" get work.img "$1" "got_$1" >/dev/null 2>&1 || return 1
|
|
cmp -s "$1" "got_$1"
|
|
}
|
|
for f in empty.bin one.bin exact.bin part.bin whole.bin; do
|
|
check "$f comes back byte for byte" roundTrip "$f"
|
|
done
|
|
|
|
refuses "refuse a name of 29 characters" "$TOOL" put work.img part.bin 16bitSegmentedSieveModern.asm
|
|
refuses "refuse a duplicate name" "$TOOL" put work.img one.bin
|
|
refuses "refuse a file that is not there" "$TOOL" get work.img nosuch.bin out.bin
|
|
check "delete" "$TOOL" delete work.img one.bin
|
|
refuses "the deleted file is gone" "$TOOL" get work.img one.bin out.bin
|
|
check "the name can be used again" "$TOOL" put work.img one.bin
|
|
|
|
# Contiguous files mean a disk can have room without having room in one piece. That is a
|
|
# consequence of the format rather than a bug, so it is checked rather than worked around.
|
|
"$TOOL" format frag.img 16 1 >/dev/null 2>&1
|
|
head -c 1024 /dev/urandom > a.bin; cp a.bin b.bin; cp a.bin c.bin
|
|
"$TOOL" put frag.img a.bin >/dev/null 2>&1
|
|
"$TOOL" put frag.img b.bin >/dev/null 2>&1
|
|
"$TOOL" put frag.img c.bin >/dev/null 2>&1
|
|
"$TOOL" delete frag.img a.bin >/dev/null 2>&1
|
|
"$TOOL" delete frag.img c.bin >/dev/null 2>&1
|
|
head -c 2048 /dev/urandom > big.bin
|
|
refuses "refuse a file with no run long enough" "$TOOL" put frag.img big.bin
|
|
head -c 512 /dev/urandom > fits.bin
|
|
check "but one that fits the gap goes on" "$TOOL" put frag.img fits.bin
|
|
|
|
# ---- Directories ----
|
|
#
|
|
# Version two, which adds a parent to each entry and a flag bit saying an entry is a
|
|
# directory. Both come out of bytes the entry had already set aside, so nothing moved and
|
|
# a version one disk needs no converting: zero in those bytes means the root, which is
|
|
# exactly where every file on a flat disk is.
|
|
#
|
|
# The version is therefore a statement about what is ON a disk rather than about what made
|
|
# it, and these check that it is only raised when it becomes true.
|
|
"$TOOL" format tree.img 64 2 >/dev/null 2>&1
|
|
printf 'a file in the root' > root.txt
|
|
check "a fresh disk is flat" "$TOOL" put tree.img root.txt
|
|
version() { "$TOOL" list "$1" 2>/dev/null | head -1 | grep -q "version $2"; }
|
|
check "and says it is version 1" version tree.img 1
|
|
check "make a directory" "$TOOL" mkdir tree.img /Apps
|
|
check "which raises it to version 2" version tree.img 2
|
|
check "make one inside it" "$TOOL" mkdir tree.img /Apps/Source
|
|
check "put a file down a path" "$TOOL" put tree.img root.txt /Apps/Source/deep.txt
|
|
|
|
# The point of the whole exercise: a name means something different in each place, so the
|
|
# same one can be used twice without either being in the other's way.
|
|
check "the same name in two places" "$TOOL" put tree.img root.txt /Apps/root.txt
|
|
roundTripAt() {
|
|
"$TOOL" get tree.img "$1" got_deep.txt >/dev/null 2>&1 || return 1
|
|
cmp -s root.txt got_deep.txt
|
|
}
|
|
check "it comes back byte for byte" roundTripAt /Apps/Source/deep.txt
|
|
check ". and .. walk the path" roundTripAt /Apps/./Source/../root.txt
|
|
check ".. from the root is the root" roundTripAt /Apps/../../root.txt
|
|
|
|
# Each of these is a way the tree could be made to contradict itself, and each is refused
|
|
# rather than half done.
|
|
refuses "no file where a directory goes" "$TOOL" put tree.img root.txt /root.txt/x.txt
|
|
refuses "no putting into thin air" "$TOOL" put tree.img root.txt /Nowhere/x.txt
|
|
refuses "no duplicate in one directory" "$TOOL" mkdir tree.img /Apps
|
|
refuses "no getting a directory" "$TOOL" get tree.img /Apps out.bin
|
|
refuses "delete will not take a directory" "$TOOL" delete tree.img /Apps
|
|
refuses "rmdir will not take a file" "$TOOL" rmdir tree.img /root.txt
|
|
refuses "nor the root" "$TOOL" rmdir tree.img /
|
|
|
|
# THE REFUSAL THAT MATTERS MOST. Parents are entry indices and a freed index is handed out
|
|
# again, so removing a directory with things still in it would let the next file created
|
|
# adopt them. Emptying it first is the only safe order.
|
|
refuses "no removing an occupied one" "$TOOL" rmdir tree.img /Apps/Source
|
|
check "empty it first" "$TOOL" delete tree.img /Apps/Source/deep.txt
|
|
check "then it goes" "$TOOL" rmdir tree.img /Apps/Source
|
|
|
|
# A path is names with separators between them, and a name is still twenty two characters.
|
|
refuses "refuse a 23 character component" "$TOOL" mkdir tree.img /Apps/abcdefghijklmnopqrstuvw
|
|
refuses "refuse a path naming nothing" "$TOOL" mkdir tree.img /Apps/
|
|
|
|
# A directory costs an entry and no blocks at all, which is what keeps the flat array of
|
|
# entries the whole allocation map. If a directory ever took a block, this would drop.
|
|
blocksFree() { "$TOOL" list "$1" 2>/dev/null | tail -1 | sed 's/.*used, //; s/ blocks free.*//'; }
|
|
before=$(blocksFree tree.img)
|
|
"$TOOL" mkdir tree.img /Empty >/dev/null 2>&1
|
|
check "a directory costs no blocks" [ "$before" = "$(blocksFree tree.img)" ]
|
|
|
|
echo
|
|
if [ "$FAIL" -eq 0 ]; then
|
|
echo "All $PASS disk tool checks passed."
|
|
exit 0
|
|
fi
|
|
echo "$PASS passed, $FAIL failed: ${FAILED_NAMES[*]}"
|
|
exit 1
|