Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-foundation

Source of release 0.6.1

0.6.1 / 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())