module main import builtin.linux_bare.old..checks.forkedtest const ( sample_text_file1 = '' ) fn check_fork_minimal() { child := sys_fork() ec := 100 if child == 0 { println('child') sys_exit(ec) } siginfo := [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ] e := sys_waitid(.p_pid, child, intptr(siginfo.data), .wexited, 0) assert e == .enoerror // println(i64_tos(buffer0,80,siginfo[Sig_index.si_code],16)) assert siginfo[Sig_index.si_code] == int(Wi_si_code.cld_exited) assert siginfo[Sig_index.si_pid] == child assert siginfo[Sig_index.si_status] == ec assert siginfo[Sig_index.si_signo] == int(Signo.sigchld) assert siginfo[Sig_index.si_uid] == sys_getuid() } fn check_read_write_pipe() { // Checks the following system calls: // sys_pipe // sys_write // sys_read // sys_close // buffer0 := []u8{len: (128)} buffer := byteptr(buffer0.data) fd := [-1, -1] assert fd[0] == -1 assert fd[1] == -1 a := sys_pipe(intptr(&fd[0])) assert a == .enoerror assert fd[0] != -1 assert fd[1] != -1 test_data := 'test_data' b := test_data.len + 1 c1, e1 := sys_write(fd[1], test_data.str, u64(b)) assert e1 == .enoerror assert c1 == b c2, e2 := sys_read(fd[0], buffer, u64(b)) assert e2 == .enoerror assert c2 == b assert buffer[b - 1] == 0 for i in 0 .. b { assert test_data[i] == buffer[i] } assert sys_close(fd[0]) == .enoerror assert sys_close(fd[1]) == .enoerror assert sys_close(-1) == .ebadf } fn check_read_file() { /* Checks the following system calls: sys_read sys_write sys_close sys_open */ buffer0 := []u8{len: (128)} buffer := byteptr(buffer0.data) test_file := 'sample_text1.txt' sample_text := 'Do not change this text.\n' fd, ec := sys_open(test_file.str, .o_rdonly, 0) assert fd > 0 assert ec == .enoerror n := sample_text.len c, e := sys_read(fd, buffer, u64(n * 2)) assert e == .enoerror assert c == n for i in 0 .. n { assert sample_text[i] == buffer[i] } assert sys_close(fd) == .enoerror } fn check_open_file_fail() { fd1, ec1 := sys_open('./nofilehere'.str, .o_rdonly, 0) assert fd1 == -1 assert ec1 == .enoent } /* fn check_print() { println ("checking print and println") a := sys_pipe(intptr(fd)) assert a != -1 assert fd[0] != -1 assert fd[1] != -1 //sys_dup2 println ("print and println passed") } */ fn check_munmap_fail() { ec := sys_munmap(-16384, 8192) assert ec == .einval } fn check_mmap_one_page() { mp := int(Mm_prot.prot_read) | int(Mm_prot.prot_write) mf := int(Map_flags.map_private) | int(Map_flags.map_anonymous) mut a, e := sys_mmap(0, u64(Linux_mem.page_size), Mm_prot(mp), Map_flags(mf), -1, 0) assert e == .enoerror assert a != byteptr(-1) for i in 0 .. int(Linux_mem.page_size) { b := i & 0xFF a[i] = b assert a[i] == b } ec := sys_munmap(a, u64(Linux_mem.page_size)) assert ec == .enoerror } fn check_mm_pages() { for i in 0 .. int(Linux_mem.page_size) - 4 { assert u32(1) == mm_pages(u64(i)) } for i in int(Linux_mem.page_size) - 3 .. (int(Linux_mem.page_size) * 2) - 4 { assert u32(2) == mm_pages(u64(i)) } for i in (int(Linux_mem.page_size) * 2) - 3 .. (int(Linux_mem.page_size) * 3) - 4 { assert u32(3) == mm_pages(u64(i)) } } // pub fn mm_alloc(size u64) (voidptr, Errno) fn check_mm_alloc() { for i in 1 .. 2000 { size := u64(i * 1000) pages := mm_pages(size) mut a, e := mm_alloc(size) assert e == .enoerror ap := intptr(a - 4) assert *ap == int(pages) assert e == .enoerror assert !isnil(a) if (i % 111) == 0 { for j in 0 .. int(size) { b := j & 0xFF a[j] = b assert b == int(a[j]) } } mfa := mm_free(a) assert mfa == .enoerror } } fn check_int_array_ro() { a := [100, 110, 120, 130] assert a.len == 4 assert a[0] == 100 assert a[1] == 110 assert a[2] == 120 assert a[3] == 130 } fn check_int_array_rw() { mut a := [-10, -11, -12, -13] assert a.len == 4 assert a[0] == -10 assert a[1] == -11 assert a[2] == -12 assert a[3] == -13 for i in 0 .. a.len { b := -a[i] * 10 a[i] = b assert a[i] == b } assert a[3] == 130 } fn check_int64_array_ro() { a := [i64(1000), 1100, 1200, 1300, 1400] assert a.len == 5 assert a[0] == 1000 assert a[1] == 1100 assert a[2] == 1200 assert a[3] == 1300 assert a[4] == 1400 } fn check_voidptr_array_ro() { a := [ voidptr(10000), voidptr(11000), voidptr(12000), voidptr(13000), voidptr(14000), voidptr(15000), ] assert a.len == 6 assert a[0] == voidptr(10000) assert a[1] == voidptr(11000) assert a[2] == voidptr(12000) assert a[3] == voidptr(13000) assert a[4] == voidptr(14000) assert a[5] == voidptr(15000) } fn check_voidptr_array_rw() { mut a := [ voidptr(-1), voidptr(-1), voidptr(-1), voidptr(-1), voidptr(-1), voidptr(-1), ] assert a.len == 6 assert a[0] == voidptr(-1) assert a[1] == voidptr(-1) assert a[2] == voidptr(-1) assert a[3] == voidptr(-1) assert a[4] == voidptr(-1) assert a[5] == voidptr(-1) a[0] = voidptr(100000) assert a[0] == voidptr(100000) a[1] = voidptr(110000) assert a[1] == voidptr(110000) a[2] = voidptr(120000) assert a[2] == voidptr(120000) a[3] = voidptr(130000) assert a[3] == voidptr(130000) a[4] = voidptr(140000) assert a[4] == voidptr(140000) a[5] = voidptr(150000) assert a[5] == voidptr(150000) } fn main() { mut fails := 0 fails += forkedtest.normal_run(check_fork_minimal, 'check_fork_minimal') fails += forkedtest.normal_run(check_munmap_fail, 'check_munmap_fail') fails += forkedtest.normal_run(check_mmap_one_page, 'check_mmap_one_page') fails += forkedtest.normal_run(check_mm_pages, 'check_mm_pages') fails += forkedtest.normal_run(check_mm_alloc, 'check_mm_alloc') fails += forkedtest.normal_run(check_read_write_pipe, 'check_read_write_pipe') fails += forkedtest.normal_run(check_read_file, 'check_read_file') // check_print() fails += forkedtest.normal_run(check_open_file_fail, 'check_open_file_fail') fails += forkedtest.normal_run(check_int_array_ro, 'check_int_array_ro') fails += forkedtest.normal_run(check_int_array_rw, 'check_int_array_rw') fails += forkedtest.normal_run(check_int64_array_ro, 'check_int64_array_ro') fails += forkedtest.normal_run(check_voidptr_array_ro, 'check_voidptr_array_ro') fails += forkedtest.normal_run(check_voidptr_array_rw, 'check_voidptr_array_rw') assert fails == 0 sys_exit(0) }