dymokomi/luce-browser-foundation
Source of release 0.6.0
0.6.0 / src / ak / tests_memory_stream.lucb
#==============================================================================================
#
# tests_memory_stream - FixedMemoryStream, AllocatingMemoryStream, InputBufferedSeekable
#
# DESCRIPTION:
# Port of Tests/AK/TestMemoryStream.cpp (the fixed_memory_tell benchmark runs as a
# test), plus cases for Stream::discard, read_value/write_value and
# OutputBufferedSeekable, which the donor does not test.
#
#==============================================================================================
func test_ms_sv_equals(view: StringView, text: str) -> bool:
if view.m_length != text.length:
return false
if view.m_length == 0:
return true
let characters = view.m_characters else return false
return u8[]((u8*)characters, view.m_length) == text.bytes
func test_allocating_stream() -> AllocatingMemoryStream:
var stream: AllocatingMemoryStream = ---
allocating_memory_stream_construct(&stream)
return stream
func test_fixed_stream(bytes: const u8[]) -> FixedMemoryStream:
var stream: FixedMemoryStream = ---
fixed_memory_stream_construct(&stream, bytes)
return stream
func test_fixed_stream_mode(bytes: u8[], mode: FixedMemoryStreamMode) -> FixedMemoryStream:
var stream: FixedMemoryStream = ---
fixed_memory_stream_construct_fixed_memory_stream_mode(&stream, bytes, mode)
return stream
# mark: AllocatingMemoryStream ==================================================================
test "memory_stream: allocating_memory_stream_empty":
var stream = test_allocating_stream()
assert(allocating_memory_stream_used_buffer_size(&stream) == 0)
var array: u8[32]
let read_bytes = stream_read_some(stream.stream(), array) else trap("read failed")
assert(read_bytes.length == 0)
let offset = allocating_memory_stream_offset_of(&stream, "test".bytes) else trap("offset_of failed")
assert(offset == none)
test "memory_stream: allocating_memory_stream_offset_of":
var stream = test_allocating_stream()
stream_write_until_depleted_span_u8(stream.stream(), "Well Hello Friends! :^)".bytes) else trap("write failed")
assert((allocating_memory_stream_offset_of(&stream, " ".bytes) else trap("x")) == 4)
assert((allocating_memory_stream_offset_of(&stream, "W".bytes) else trap("x")) == 0)
assert((allocating_memory_stream_offset_of(&stream, ")".bytes) else trap("x")) == 22)
assert((allocating_memory_stream_offset_of(&stream, "-".bytes) else trap("x")) == none)
stream_discard(stream.stream(), 1) else trap("discard failed")
assert((allocating_memory_stream_offset_of(&stream, "W".bytes) else trap("x")) == none)
assert((allocating_memory_stream_offset_of(&stream, "e".bytes) else trap("x")) == 0)
test "memory_stream: allocating_memory_stream_offset_of_oob":
var stream = test_allocating_stream()
# First, fill exactly one chunk (in groups of 16 bytes).
for i in 0..<(allocating_memory_stream_chunk_size // 16):
_ = i
stream_write_until_depleted_span_u8(stream.stream(), "AAAAAAAAAAAAAAAA".bytes) else trap("write failed")
# Then discard it all.
stream_discard(stream.stream(), allocating_memory_stream_chunk_size) else trap("discard failed")
stream_write_until_depleted_span_u8(stream.stream(), "Well Hello Friends! :^)".bytes) else trap("write failed")
assert((allocating_memory_stream_offset_of(&stream, "A".bytes) else trap("x")) == none)
test "memory_stream: allocating_memory_stream_offset_of_after_chunk_reorder":
var stream = test_allocating_stream()
for i in 0..<(allocating_memory_stream_chunk_size // 16):
_ = i
stream_write_until_depleted_span_u8(stream.stream(), "AAAAAAAAAAAAAAAA".bytes) else trap("write failed")
# Append a few additional bytes to create a second chunk.
stream_write_until_depleted_span_u8(stream.stream(), "BCDEFGHIJKLMNOPQ".bytes) else trap("write failed")
stream_discard(stream.stream(), allocating_memory_stream_chunk_size) else trap("discard failed")
assert((allocating_memory_stream_offset_of(&stream, "A".bytes) else trap("x")) == none)
assert((allocating_memory_stream_offset_of(&stream, "B".bytes) else trap("x")) == 0)
assert((allocating_memory_stream_offset_of(&stream, "Q".bytes) else trap("x")) == 15)
test "memory_stream: allocating_memory_stream_offset_of_with_write_offset_multiple_of_chunk_size":
var stream = test_allocating_stream()
for i in 0..<((allocating_memory_stream_chunk_size // 16) - 1):
_ = i
stream_write_until_depleted_span_u8(stream.stream(), "AAAAAAAAAAAAAAAA".bytes) else trap("write failed")
stream_write_until_depleted_span_u8(stream.stream(), "BCDEFGHIJKLMNOPQ".bytes) else trap("write failed")
# Read a few bytes from the beginning to ensure that we are trying to slice into the zero-sized block.
stream_discard(stream.stream(), 32) else trap("discard failed")
assert((allocating_memory_stream_offset_of(&stream, "B".bytes) else trap("x")) == allocating_memory_stream_chunk_size - 32 - 16)
assert((allocating_memory_stream_offset_of(&stream, "Q".bytes) else trap("x")) == allocating_memory_stream_chunk_size - 32 - 1)
test "memory_stream: allocating stream read, peek and read_until_eof":
var stream = test_allocating_stream()
for i in 0..<300:
_ = i
stream_write_until_depleted_span_u8(stream.stream(), "0123456789abcdef".bytes) else trap("write failed")
assert(allocating_memory_stream_used_buffer_size(&stream) == 4800)
var peeked: u8[20]
allocating_memory_stream_peek_some(&stream, peeked)
assert(peeked[0..<16] == "0123456789abcdef".bytes)
assert(allocating_memory_stream_peek_some_contiguous(&stream).length == 4096)
var chunk: u8[10]
let read = stream_read_some(stream.stream(), chunk) else trap("read failed")
assert(read == "0123456789".bytes)
let rest = stream_read_until_eof(stream.stream(), 4096) else trap("read_until_eof failed")
assert(byte_buffer_size(&rest) == 4790)
assert(byte_buffer_at_const(&rest, 4789) == 'f')
assert(stream_is_eof(stream.stream()))
# mark: FixedMemoryStream =======================================================================
test "memory_stream: fixed_memory_read_write":
let some_words = "These are some words"
var empty = byte_buffer_create_uninitialized(some_words.length) else trap("create failed")
var stream = test_fixed_stream_mode(byte_buffer_bytes(&empty), FixedMemoryStreamMode.read_write)
_ = stream_write_some(stream.stream(), some_words.bytes) else trap("write failed")
assert((seekable_stream_tell(stream.seekable_stream()) else trap("tell failed")) == some_words.length)
assert(stream_is_eof(stream.stream()))
_ = seekable_stream_seek(stream.seekable_stream(), 0, SeekMode.set_position) else trap("seek failed")
let contents = stream_read_until_eof(stream.stream(), 4096) else trap("read_until_eof failed")
assert(byte_buffer_bytes_const(&contents) == some_words.bytes)
test "memory_stream: fixed_memory_close":
var empty = byte_buffer_create_uninitialized(64) else trap("create failed")
var stream = test_fixed_stream_mode(byte_buffer_bytes(&empty), FixedMemoryStreamMode.read_write)
assert(stream_is_open(stream.stream()))
stream_close(stream.stream())
assert(stream_is_open(stream.stream()))
test "memory_stream: fixed_memory_read_only":
let some_words = "These are some words"
var stream = test_fixed_stream(some_words.bytes)
let contents = stream_read_until_eof(stream.stream(), 4096) else trap("read_until_eof failed")
assert(byte_buffer_bytes_const(&contents) == some_words.bytes)
_ = seekable_stream_seek(stream.seekable_stream(), 0, SeekMode.set_position) else trap("seek failed")
var failed = false
_ = stream_write_some(stream.stream(), some_words.bytes) catch:
failed = true
recover 0
assert(failed)
assert(ak_pending_error.m_code == ebadf)
assert((seekable_stream_tell(stream.seekable_stream()) else trap("tell failed")) == 0)
assert(not stream_is_eof(stream.stream()))
test "memory_stream: fixed_memory_seeking_around":
with memory.heap:
var stream_buffer = byte_buffer_create_zeroed(8702) else trap("create failed")
var stream = test_fixed_stream(byte_buffer_bytes(&stream_buffer))
var buffer = byte_buffer_create_uninitialized(16) else trap("create failed")
_ = seekable_stream_seek(stream.seekable_stream(), 500, SeekMode.set_position) else trap("seek failed")
assert((seekable_stream_tell(stream.seekable_stream()) else trap("tell failed")) == 500)
stream_read_until_filled(stream.stream(), byte_buffer_bytes(&buffer)) else trap("read failed")
_ = seekable_stream_seek(stream.seekable_stream(), 234, SeekMode.from_current_position) else trap("seek failed")
assert((seekable_stream_tell(stream.seekable_stream()) else trap("tell failed")) == 750)
stream_read_until_filled(stream.stream(), byte_buffer_bytes(&buffer)) else trap("read failed")
_ = seekable_stream_seek(stream.seekable_stream(), -105, SeekMode.from_end_position) else trap("seek failed")
assert((seekable_stream_tell(stream.seekable_stream()) else trap("tell failed")) == 8597)
stream_read_until_filled(stream.stream(), byte_buffer_bytes(&buffer)) else trap("read failed")
assert((seekable_stream_size(stream.seekable_stream()) else trap("size failed")) == 8702)
assert((seekable_stream_tell(stream.seekable_stream()) else trap("tell failed")) == 8613)
test "memory_stream: fixed_memory_tell":
with memory.heap:
var stream_buffer = byte_buffer_create_zeroed(10240) else trap("create failed")
var stream = test_fixed_stream(byte_buffer_bytes(&stream_buffer))
var expected_fixed_memory_offset: usize = 0
var one_byte: u8[1]
for i in 0..<4000:
_ = i
stream_read_until_filled(stream.stream(), one_byte) else trap("read failed")
expected_fixed_memory_offset += 1
assert(expected_fixed_memory_offset == (seekable_stream_tell(stream.seekable_stream()) else trap("tell failed")))
for i in 0..<4000:
_ = i
let seek_fixed_memory_offset = seekable_stream_seek(stream.seekable_stream(), -1, SeekMode.from_current_position) else trap("seek failed")
expected_fixed_memory_offset -= 1
assert(seek_fixed_memory_offset == (seekable_stream_tell(stream.seekable_stream()) else trap("tell failed")))
assert(expected_fixed_memory_offset == seek_fixed_memory_offset)
test "memory_stream: fixed_memory_truncate":
var stream_buffer = byte_buffer_create_zeroed(64) else trap("create failed")
var stream = test_fixed_stream(byte_buffer_bytes(&stream_buffer))
var failed = false
seekable_stream_truncate(stream.seekable_stream(), 999) catch:
failed = true
recover ()
assert(failed)
test "memory_stream: fixed_memory_read_in_place":
let some_words = "These are some words"
var readonly_stream = test_fixed_stream(some_words.bytes)
# Trying to read mutable values from a read-only stream should fail.
var failed = false
_ = fixed_memory_stream_read_in_place_usize[u8](&readonly_stream, 1) catch:
failed = true
recover empty_span[u8]()
assert(failed)
assert(fixed_memory_stream_offset(&readonly_stream) == 0)
# Reading const values should succeed.
let characters = fixed_memory_stream_read_in_place_const_usize[u8](&readonly_stream, 20) else trap("read failed")
assert(characters == some_words.bytes)
assert(stream_is_eof(readonly_stream.stream()))
var copy: u8[20]
memory.copy(copy, some_words.bytes, 20)
var mutable_stream = test_fixed_stream_mode(copy, FixedMemoryStreamMode.read_write)
# Trying to read mutable values from a mutable stream should succeed.
let one = fixed_memory_stream_read_in_place[u8](&mutable_stream) else trap("read failed")
assert(*one == 'T')
assert(fixed_memory_stream_offset(&mutable_stream) == 1)
_ = seekable_stream_seek(mutable_stream.seekable_stream(), 0, SeekMode.set_position) else trap("seek failed")
let characters_again = fixed_memory_stream_read_in_place_const_usize[u8](&mutable_stream, 20) else trap("read failed")
assert(characters_again == some_words.bytes)
assert(stream_is_eof(mutable_stream.stream()))
test "memory_stream: read_value, write_value and discard":
var storage: u8[16]
var stream = test_fixed_stream_mode(storage, FixedMemoryStreamMode.read_write)
stream_write_value[u32](stream.stream(), 0x04030201) else trap("write failed")
stream_write_value[u16](stream.stream(), 0xbeef) else trap("write failed")
assert(storage[0] == 1 and storage[3] == 4 and storage[4] == 0xef)
_ = seekable_stream_seek(stream.seekable_stream(), 0, SeekMode.set_position) else trap("seek failed")
assert((stream_read_value[u32](stream.stream()) else trap("read failed")) == 0x04030201)
stream_discard(stream.stream(), 1) else trap("discard failed")
assert((stream_read_value[u8](stream.stream()) else trap("read failed")) == 0xbe)
var allocating = test_allocating_stream()
stream_write_until_depleted_span_u8(allocating.stream(), "abc".bytes) else trap("write failed")
var failed = false
stream_discard(allocating.stream(), 4) catch:
failed = true
recover ()
assert(failed)
# mark: Buffered streams ========================================================================
test "memory_stream: buffered_memory_stream_read_line":
var array: u8[32]
# First line: 8 bytes, second line: 24 bytes
memory.set(array, 'A')
array[7] = '\n'
array[31] = '\n'
var memory_stream = test_fixed_stream_mode(array, FixedMemoryStreamMode.read_only)
# Buffer for buffered seekable is larger than the stream, so stream goes EOF immediately on read
let buffered_stream = input_buffered_seekable_create(&memory_stream, 64) else trap("create failed")
# Buffer is only 16 bytes, first read succeeds, second fails
var buffer = byte_buffer_create_zeroed(16) else trap("create failed")
let read_bytes = input_buffered_seekable_read_line(buffered_stream, byte_buffer_bytes(&buffer)) else trap("read_line failed")
assert(test_ms_sv_equals(read_bytes, "AAAAAAA"))
var failed = false
_ = input_buffered_seekable_read_line(buffered_stream, byte_buffer_bytes(&buffer)) catch:
failed = true
recover StringView()
assert(failed)
assert(ak_pending_error.m_code == emsgsize())
func test_line_with_resize(buffer_size: usize, newlines: bool):
var array: u8[24]
# The first line is 8 A's, the second line is 14 A's, two bytes are newline characters.
memory.set(array, 'A')
if newlines:
array[8] = '\n'
array[23] = '\n'
var memory_stream = test_fixed_stream_mode(array, FixedMemoryStreamMode.read_only)
let buffered_stream = input_buffered_seekable_create(&memory_stream, buffer_size) else trap("create failed")
let initial_buffer_size: usize = 4
var buffer = byte_buffer_create_zeroed(initial_buffer_size) else trap("create failed")
var read_bytes = input_buffered_seekable_read_line_with_resize(buffered_stream, &buffer) else trap("read failed")
if newlines:
# The first line, which is 8 A's, should be read in.
assert(test_ms_sv_equals(read_bytes, "AAAAAAAA"))
read_bytes = input_buffered_seekable_read_line_with_resize(buffered_stream, &buffer) else trap("read failed")
# The second line, which is 14 A's, should be read in.
assert(test_ms_sv_equals(read_bytes, "AAAAAAAAAAAAAA"))
# A resize should have happened because the user supplied buffer was too small.
assert(byte_buffer_size(&buffer) > initial_buffer_size)
else:
# All the contents of the buffer should have been read in.
assert(read_bytes.m_length == 24)
# Reading from the stream again should return an empty StringView.
read_bytes = input_buffered_seekable_read_line_with_resize(buffered_stream, &buffer) else trap("read failed")
assert(read_bytes.m_length == 0)
test "memory_stream: buffered_memory_stream_read_line_with_resizing":
test_line_with_resize(64, true)
test_line_with_resize(6, true)
test_line_with_resize(64, false)
test_line_with_resize(6, false)
test "memory_stream: input buffered seek and output buffered writes":
let some_words = "These are some words"
var input_stream = test_fixed_stream(some_words.bytes)
let buffered = input_buffered_seekable_create(&input_stream, 8) else trap("create failed")
var head: u8[4]
let read = stream_read_some(buffered.stream(), head) else trap("read failed")
assert(read == "Thes".bytes)
assert(input_buffered_seekable_buffer_size(buffered) == 8)
# Seek forward within the buffered bytes, then past them.
assert((seekable_stream_seek(buffered.seekable_stream(), 2, SeekMode.from_current_position) else trap("seek failed")) == 6)
assert((seekable_stream_seek(buffered.seekable_stream(), 4, SeekMode.from_current_position) else trap("seek failed")) == 10)
let next = stream_read_some(buffered.stream(), head) else trap("read failed")
assert(next == "some".bytes)
assert(input_buffered_seekable_can_read_line(buffered) else trap("can_read_line failed"))
var storage: u8[32]
var output_stream = test_fixed_stream_mode(storage, FixedMemoryStreamMode.read_write)
let output = output_buffered_seekable_create(&output_stream, 8) else trap("create failed")
assert((stream_write_some(output.stream(), "abc".bytes) else trap("write failed")) == 3)
assert(storage[0] == 0)
assert((seekable_stream_tell(output.seekable_stream()) else trap("tell failed")) == 3)
stream_write_until_depleted_span_u8(output.stream(), "defghijk".bytes) else trap("write failed")
output_buffered_seekable_flush_buffer(output) else trap("flush failed")
assert(storage[0..<11] == "abcdefghijk".bytes)
stream_close(output.stream())