[tannevaled]

wave 28 — Kernel#sleep with a fiber scheduler, File.open's mode contract, IO::Buffer.map

core/file + core/io + core/kernel: 3925 → 4015 passing examples (+90), measured per file. No spec file lost a single example. core/file/mkfifo_spec.rb is still at 0, untouched.

spec file	before	after
core/kernel/sleep_spec.rb	0	15
core/io/buffer/map_spec.rb	0	14
core/file/open_spec.rb	55	78
core/io/buffer/initialize_spec.rb	5	13
core/file/new_spec.rb	18	25
core/file/truncate_spec.rb	18	23
core/file/flock_spec.rb	0	3 (2 of 5 need ruby_exe, skipped)
core/file/size_spec.rb	20	22
core/io/buffer/{shared,internal,null}_spec.rb	2 / 1 / 10	4 / 3 / 12
core/io/buffer/{empty,free,mapped,private,resize,transfer,valid}_spec.rb	—	+1 each

Per directory: core/file 628 → 668, core/io 1319 → 1354, core/kernel 1978 → 1993.

What was read, per method

Every change was made against the MRI C source and then byte-compared with ruby 4.0.5 on this host — stdout and error messages, raw bytes.

Kernel#sleep — process.c rb_f_sleep, scheduler.c rb_fiber_scheduler_current / _current_for_threadptr / rb_fiber_scheduler_kernel_sleepv, cont.c fiber_switch + rb_fiber_start (the th->blocking counter), time.c time_timespec, thread_sync.c rb_mutex_sleep.

core/kernel/sleep_spec.rb scored 0 not because fourteen examples failed but because ONE hung the process, and a timeout costs the whole file: Fiber.new(blocking: false) { sleep }.resume never returned, since nothing consulted Fiber.scheduler. rb_f_sleep asks rb_fiber_scheduler_current before looking at its arguments and forwards them verbatim — so sleep with no argument calls #kernel_sleep with no argument, not with nil.

The same read fixed, each byte-compared: sleep(Rational(1,999)) and sleep(obj_with_divmod) were TypeError; sleep(Float::NAN) returned 0 instead of raising RangeError; sleep(Float::INFINITY) and sleep(1e20) HUNG instead of raising; sleep(2**70) was a TypeError instead of a RangeError; sleep(1, 2) slept instead of raising ArgumentError. The result is now time(0) - beg — second boundaries crossed, not a rounded duration.

File.open / File.new — io.c rb_io_modestr_fmode, rb_io_oflags_fmode, rb_io_fmode_oflags, rb_io_extract_modeenc, validate_enc_binmode, rb_file_initialize, rb_io_s_open, rb_io_s_new; file.c rb_file_open_generic.

File.open reduced every mode to one of six fopen-style strings, so the O_CREAT/O_TRUNC/O_EXCL half was lost. It is now driven by the open(2) flag set: "wx" refuses an existing file, File::WRONLY on a missing path is ENOENT, the permission argument reaches the creation, :flags merges and re-derives the fmode, :perm/:mode report "specified twice", "rx"/"ax" are "invalid access mode" (rb_io_modestr_fmode checks modestr[0] itself), File::RDONLY|File::APPEND is READ-ONLY because O_APPEND is not an access bit, and :newline with binmode is "newline decorator with binary mode". A first argument that converts with #to_int — and fewer than three positional arguments — is a DESCRIPTOR, as rb_file_initialize has it. The block form closes through the Ruby-level #close.

File#flock — file.c rb_file_flock. MRI does not block inside flock(2): without LOCK_NB it waits 0.1 s with rb_thread_wait_for and calls again, which is what keeps the wait interruptible, and is exactly what this VM's cooperative threads reproduce. A lock cannot be emulated (it belongs to an open file description), so a real descriptor is opened on demand and released on LOCK_UN or close, behind a platform seam that reports ENOTSUP on windows and wasm.

File#size / IO#truncate — file.c rb_file_size, io.c rb_io_truncate. Both are operations on the descriptor: the truncate reaches the file at once rather than at the next flush, and the size is read afresh (and still answers after the path is unlinked).

IO::Buffer.map / IO::Buffer.new — io_buffer.c io_buffer_map, rb_io_buffer_map, io_buffer_map_file, io_buffer_extract_size/_offset/_flags, rb_io_buffer_initialize, io_buffer_initialize, io_flags_for_size; include/ruby/io/buffer.h. A mapping does not have to be faked: this VM's file streams already ARE their bytes in memory, so a shared mapping is that byte slice and a private one is the copy MAP_PRIVATE would take. IO::Buffer.new's flags are now recorded rather than derived, which is what rippled into eleven other buffer spec files.

Two assertions corrected against the reference, not worked around

Measuring said the assertions were the thing that was wrong; both were re-measured on MRI 4.0.5 before changing anything.

• io_modeenc_internal_test.go asserted that when BOTH the block and #close raise, the block's exception escapes. MRI answers with the one from #close — for File.open, for IO.open, and for a bare begin/raise/ensure/raise alike, because an ensure's exception supersedes the one it was unwinding. The VM now does the same.
• io_buffer_internal_test.go asserted IO::Buffer.new(4, READONLY) is a read-only buffer. READONLY alone names no way to obtain the memory, so MRI raises AllocationError; INTERNAL|READONLY is the buffer that was meant. Both are now asserted.

Judged unreachable from these files, with the reason

• shared open_directory, 2 examples (open_spec, new_spec) — the harness fabricates the failure. Real mspec's tmp("") returns the temp DIRECTORY; scripts/conformance/rubyspec/spec_helper.rb rewrites an empty basename to "file" and uniquifies it, so the spec opens a path that was never created. The VM opens a directory correctly (File.open(dir).class == File, and File.open(dir, "w") is EISDIR, both byte-compared).
• accepts options as a keyword argument, 3 examples (open_spec, new_spec, write_spec) — they require File.open(f, 'w', 0755, {flags: ...}) with a BRACED hash to be a fourth POSITIONAL argument. This VM has no keyword/positional distinction at the native-method boundary (splitIOOpts takes any trailing Hash as options); the fix is in the compiler/VM, not in these files.
• IO.write :open_args and friends, 7 examples (write_spec) — @filename is nil in them. it_behaves_like in the shim creates a CHILD context, so the shared block's before(:each) does not apply to the enclosing describe's own examples; real mspec splices the shared block into the current context. spec_helper.rb is out of scope here. Each of those calls behaves correctly when run directly.
• shared io_copy_stream_to_io, 8 examples (copy_stream_spec) — Tempfile.new(name, mode: File::RDONLY). MRI's Tempfile ORs File::RDWR|File::CREAT|File::EXCL into the mode it was given; the pure-Ruby Tempfile in internal/vm/prelude.rb passes the mode through, so with File::RDONLY the file is never created and the open is ENOENT. One line, but prelude.rb is frozen into a generated prelude_frozen_gen.go and is not one of this branch's files. This is the single cheapest 8 examples left in core/io.
• File.open with a block | propagates {,non-}StandardErrors produced by close, 2 examples — the fixture stores the exception in an instance variable on the File. IOObj has no instance-variable storage: ivarTable (object_model.go) has no *IOObj case, so f.instance_variable_set(:@x, 1) silently does nothing. Five additive lines in object_model.go, which is not one of this branch's files. The rest of the fixture — that #close is invoked and that its exception propagates — now passes.
• core/file/mkfifo_spec.rb, and File.open on a FIFO — File.mkfifo was not implemented and deliberately still is not. It was left alone, but the open path was hardened first: openFileSpec no longer truncates or probes for writability anything that is not a regular file, because probing a fifo means opening it for writing, which BLOCKS until a reader appears.
• File#flock blocking/subprocess examples, 2 of 5 — they need ruby_exe, which the shim skips.
• IO::Buffer.map sharing across processes, 2 examples — guarded by Process.respond_to?(:fork), which is false here.
• IO::Buffer#initialize | creates a new zero-filled buffer with default size, 1 example — needs IO::Buffer#each, which does not exist yet.

Gates

• CGO_ENABLED=0 go build ./..., GOOS=wasip1 GOARCH=wasm, and GOOS=windows GOARCH=amd64 all build.
• CGO_ENABLED=0 GOWORK=off go test ./... — full suite green, no crash.
• gofmt -l internal/vm/ empty.
• Coverage checked per function, not on the rounded total: every function this wave added or touched is at 100%. Moving File.open off the mode string had left flagsToMode at 0% and vmodeString at 27% — IO.sysopen/IO#reopen/IO.popen still reach them and now exercise them. Three branches this wave wrote turned out unreachable and were removed rather than left untested (raiseOpenErrno's EISDIR/EEXIST arms, timeIntervalFormat's -Inf, ioFlushClose).
• runtime.GOOS / GOARCH guards on the flock and permission assertions; the windows and wasm seams stay thin.

🤖 Generated with Claude Code