Function cross_module_chain_three_works

tests/integration/platform_stdlib.rs:821–879

()

kmain: () {
    heap_set_region(KHEAP_BASE, KHEAP_END)

    ptr: u8* = 0 as u8*
    first := memory_allocator.allocate(5, 64)
    match first {
        Ok(value) -> { ptr = value }
        Err(error) -> { fail(1) }
    }
    if (ptr as u64) % 64 != 0 { fail(2) }
    ptr[0] = 17
    ptr[4] = 93

    grown: u8* = 0 as u8*
    resized := memory_allocator.reallocate(ptr, 5, 19, 64)
    match resized {
        Ok(value) -> { grown = value }
        Err(error) -> { fail(3) }
    }
    if (grown as u64) % 64 != 0 { fail(4) }
    if grown[0] != 17 or grown[4] != 93 { fail(5) }

    failed := memory_allocator.reallocate(grown, 19, 1099511627776, 64)
    match failed {
        Ok(value) -> { fail(9) }
        Err(error) -> {}
    }
    if grown[0] != 17 or grown[4] != 93 { fail(10) }
    memory_allocator.deallocate(grown, 19, 64)

    zero: u8* = 0 as u8*
    empty := memory_allocator.allocate(0, 128)
    match empty {
        Ok(value) -> { zero = value }
        Err(error) -> { fail(11) }
    }
    if zero == null or (zero as u64) % 128 != 0 { fail(12) }
    memory_allocator.deallocate(zero, 0, 128)

    invalid := memory_allocator.allocate(8, 3)
    match invalid {
        Ok(value) -> { fail(6) }
        Err(error) -> {
            match error {
                InvalidAlignment -> {}
                OutOfMemory -> { fail(7) }
                SizeOverflow -> { fail(8) }
            }
        }
    }

    max: u64 = 0
    max -= 1
    overflow := memory_allocator.allocate(max, 8)
    match overflow {
        Ok(value) -> { fail(13) }
        Err(error) -> {
            match error {
                SizeOverflow -> {}