Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-std

Source of release 0.7.4

0.7.4 / tests / file_directory / check.lucb

import c
import files
import io
import paths
import platform
import strings

pub func main(arguments: c.str[]) -> i32!:
    var directory = try files.Directory.open(arguments[1], false)
    defer directory.destroy()
    let original = try directory.metadata()
    try files.rename(arguments[1], arguments[2], false)
    assert(not (try files.exists_checked(arguments[1])))
    let moved = try files.metadata(arguments[2])
    assert(original.inode == moved.inode and original.device == moved.device)
    let data = try directory.entry_metadata("data")
    assert(data.kind == files.FileKind.regular and data.size == 4)
    var opened = try directory.open_file("data", follow_symlinks = false, nonblocking = true)
    defer opened.destroy()
    var contents: u8[4]
    try io.read_exact(&opened, contents)
    assert((str)contents == "data")
    assert((try opened.metadata()).inode == data.inode)
    var created = try directory.open_file("created", files.OpenMode.create_new_read_write, 384, false)
    try io.write_all(&created, "new".bytes)
    assert(try created.seek(0) == 0)
    var copied: u8[3]
    try io.read_exact(&created, copied)
    assert((str)copied == "new")
    try created.close()
    if not platform.windows:
        var pipe = try directory.open_file("pipe", follow_symlinks = false, nonblocking = true)
        assert((try pipe.metadata()).kind == files.FileKind.fifo)
        try pipe.close()
    var through_link = try directory.open_file("file_link")
    assert((try through_link.metadata()).inode == data.inode)
    try through_link.close()
    var link_rejected = false
    _ = directory.open_file("file_link", follow_symlinks = false) catch failure:
        assert(failure.code == files.symlink_loop)
        link_rejected = true
        var empty: files.File
        recover empty
    assert(link_rejected)
    assert((try directory.entry_metadata("link", false)).kind == files.FileKind.symlink)
    assert((try directory.entry_metadata("link")).kind == files.FileKind.directory)
    assert((try directory.entry_metadata("dangling", false)).kind == files.FileKind.symlink)
    var rejected = false
    _ = directory.open_directory("link", false) catch failure:
        assert(failure.code == files.not_directory or failure.code == files.symlink_loop)
        rejected = true
        var empty: files.Directory
        recover empty
    assert(rejected)
    let link_path = try paths.join((str)arguments[2], "link")
    defer link_path.release()
    rejected = false
    _ = files.Directory.open((c.str)link_path.value, false) catch failure:
        assert(failure.code == files.not_directory or failure.code == files.symlink_loop)
        rejected = true
        var empty: files.Directory
        recover empty
    assert(rejected)
    var child = try directory.open_directory("sub", false)
    defer child.destroy()
    var followed = try directory.open_directory("link")
    let child_info = try child.metadata()
    assert(child_info.inode == (try followed.metadata()).inode)
    try followed.close()
    try directory.close()
    var closed_rejected = false
    _ = directory.open_file("data") catch failure:
        assert(failure.code == io.closed)
        closed_rejected = true
        var empty: files.File
        recover empty
    assert(closed_rejected)
    assert((try child.entry_metadata("payload")).size == 7)
    rejected = false
    _ = directory.entry_metadata("data") catch failure:
        assert(failure.code == io.closed)
        rejected = true
        recover data
    assert(rejected)
    try child.close()
    print("ok directory-relative operations after rename")
    return 0