151 lines
3.3 KiB
Plaintext
151 lines
3.3 KiB
Plaintext
io :: import "@std/io"
|
|
process :: import "@std/process"
|
|
|
|
@hide read_ok func(_ ?@mut anyopaque, _ io.Handle, buffer []mut u8) usize ! io.ReadError {
|
|
if buffer.len == 0 {
|
|
return 0
|
|
}
|
|
buffer[0] = 'o'
|
|
if buffer.len == 1 {
|
|
return 1
|
|
}
|
|
buffer[1] = 'k'
|
|
return 2
|
|
}
|
|
|
|
@hide read_too_much func(_ ?@mut anyopaque, _ io.Handle, buffer []mut u8) usize ! io.ReadError {
|
|
return buffer.len + 1
|
|
}
|
|
|
|
@hide read_eof func(_ ?@mut anyopaque, _ io.Handle, _ []mut u8) usize ! io.ReadError {
|
|
return 0
|
|
}
|
|
|
|
@hide write_short func(_ ?@mut anyopaque, _ io.Handle, bytes []u8) usize ! io.WriteError {
|
|
if bytes.len > 2 {
|
|
return 2
|
|
}
|
|
return bytes.len
|
|
}
|
|
|
|
@hide write_none func(_ ?@mut anyopaque, _ io.Handle, _ []u8) usize ! io.WriteError {
|
|
return 0
|
|
}
|
|
|
|
@hide write_too_much func(_ ?@mut anyopaque, _ io.Handle, bytes []u8) usize ! io.WriteError {
|
|
return bytes.len + 1
|
|
}
|
|
|
|
ok_reader func() io.Reader {
|
|
return io.Reader {
|
|
context = null,
|
|
handle = io.Handle {file_desc = 0},
|
|
read = read_ok,
|
|
}
|
|
}
|
|
|
|
bad_reader func() io.Reader {
|
|
return io.Reader {
|
|
context = null,
|
|
handle = io.Handle {file_desc = 0},
|
|
read = read_too_much,
|
|
}
|
|
}
|
|
|
|
eof_reader func() io.Reader {
|
|
return io.Reader {
|
|
context = null,
|
|
handle = io.Handle {file_desc = 0},
|
|
read = read_eof,
|
|
}
|
|
}
|
|
|
|
short_writer func() io.Writer {
|
|
return io.Writer {
|
|
context = null,
|
|
handle = io.Handle {file_desc = 0},
|
|
write = write_short,
|
|
}
|
|
}
|
|
|
|
none_writer func() io.Writer {
|
|
return io.Writer {
|
|
context = null,
|
|
handle = io.Handle {file_desc = 0},
|
|
write = write_none,
|
|
}
|
|
}
|
|
|
|
bad_writer func() io.Writer {
|
|
return io.Writer {
|
|
context = null,
|
|
handle = io.Handle {file_desc = 0},
|
|
write = write_too_much,
|
|
}
|
|
}
|
|
|
|
rejects_bad_read func() bool {
|
|
buffer [1]mut u8 := [0]
|
|
_ = io.read(bad_reader(), buffer[..]) catch |err| {
|
|
return err == .read_failed
|
|
}
|
|
return false
|
|
}
|
|
|
|
rejects_no_progress func() bool {
|
|
io.print(none_writer(), "{s}", {"x",}) catch |err| {
|
|
return err == .no_progress
|
|
}
|
|
return false
|
|
}
|
|
|
|
rejects_bad_write func() bool {
|
|
_ = io.write(bad_writer(), "x") catch |err| {
|
|
return err == .write_failed
|
|
}
|
|
return false
|
|
}
|
|
|
|
main func(init process.Init) i32 {
|
|
system io.Io :: init.io
|
|
buffer [2]mut u8 := [0, 0]
|
|
count usize :: io.read(ok_reader(), buffer[..]) catch 0
|
|
if count != 2 or buffer[0] != 'o' or buffer[1] != 'k' {
|
|
return 1
|
|
}
|
|
eof usize :: io.read(eof_reader(), buffer[..]) catch 1
|
|
empty_read usize :: io.read(bad_reader(), buffer[0..0]) catch 1
|
|
empty_write usize :: io.write(bad_writer(), "") catch 1
|
|
if eof != 0 or empty_read != 0 or empty_write != 0 {
|
|
return 5
|
|
}
|
|
io.print(short_writer(), "{s}{d}", {"partial", 37}) catch |_| {
|
|
return 2
|
|
}
|
|
if !rejects_bad_read() or !rejects_no_progress() or !rejects_bad_write() {
|
|
return 3
|
|
}
|
|
io.print(io.stdout(system), "io-ok {d} {{bro}}\n", {37,}) catch |_| {
|
|
return 4
|
|
}
|
|
io.print(io.stdout(system), "bounds={d}/{d} {d}/{d} {d}/{d} {d}/{d} {d}/{d} {d}/{d} {d}/{d} {d}/{d} {d}/{d} {d}/{d} {d}/{d} {d}/{d} {d}/{d} {d}/{d}\n", {
|
|
minval!(i8), maxval!(u8),
|
|
minval!(i16), maxval!(u16),
|
|
minval!(i32), maxval!(u32),
|
|
minval!(i64), maxval!(u64),
|
|
minval!(isize), maxval!(usize),
|
|
minval!(c_char), maxval!(c_char),
|
|
minval!(c_schar), maxval!(c_uchar),
|
|
minval!(c_short), maxval!(c_ushort),
|
|
minval!(c_int), maxval!(c_uint),
|
|
minval!(c_long), maxval!(c_ulong),
|
|
minval!(c_longlong), maxval!(c_ulonglong),
|
|
0, 0,
|
|
1, 1,
|
|
-1, 1,
|
|
}) catch |_| {
|
|
return 6
|
|
}
|
|
return 0
|
|
}
|