path: root/test/unit/os/fs_spec.lua

local luv = require('luv')
local bit = require('bit')

local helpers = require('test.unit.helpers')(after_each)
local itp = helpers.gen_itp(it)

local cimport = helpers.cimport
local cppimport = helpers.cppimport
local internalize = helpers.internalize
local ok = helpers.ok
local eq = helpers.eq
local neq = helpers.neq
local ffi = helpers.ffi
local cstr = helpers.cstr
local to_cstr = helpers.to_cstr
local OK = helpers.OK
local FAIL = helpers.FAIL
local NULL = helpers.NULL
local mkdir = helpers.mkdir
local endswith = helpers.endswith

local NODE_NORMAL = 0
local NODE_WRITABLE = 1

local fs = cimport('./src/nvim/os/os.h', './src/nvim/path.h')
cppimport('sys/stat.h')
cppimport('fcntl.h')
cimport('uv.h')

local s = ''
for i = 0, 255 do
  s = s .. (i == 0 and '\0' or ('%c'):format(i))
end
local fcontents = s:rep(16)

local directory = nil
local absolute_executable = nil
local executable_name = nil

local function set_bit(number, to_set)
  return bit.bor(number, to_set)
end

local function unset_bit(number, to_unset)
  return bit.band(number, (bit.bnot(to_unset)))
end

local function assert_file_exists(filepath)
  neq(nil, luv.fs_stat(filepath))
end

local function assert_file_does_not_exist(filepath)
  eq(nil, luv.fs_stat(filepath))
end

local function os_setperm(filename, perm)
  return fs.os_setperm((to_cstr(filename)), perm)
end

local function os_getperm(filename)
  local perm = fs.os_getperm((to_cstr(filename)))
  return tonumber(perm)
end

describe('fs.c', function()
  local function os_isdir(name)
    return fs.os_isdir(to_cstr(name))
  end

  before_each(function()
    mkdir('unit-test-directory');

    io.open('unit-test-directory/test.file', 'w'):close()

    io.open('unit-test-directory/test_2.file', 'w'):close()
    luv.fs_symlink('test.file', 'unit-test-directory/test_link.file')

    luv.fs_symlink('non_existing_file.file', 'unit-test-directory/test_broken_link.file')
    -- The tests are invoked with an absolute path to `busted` executable.
    absolute_executable = arg[0]
    -- Split the absolute_executable path into a directory and filename.
    directory, executable_name = string.match(absolute_executable, '^(.*)/(.*)$')
  end)

  after_each(function()
    os.remove('unit-test-directory/test.file')
    os.remove('unit-test-directory/test_2.file')
    os.remove('unit-test-directory/test_link.file')
    os.remove('unit-test-directory/test_hlink.file')
    os.remove('unit-test-directory/test_broken_link.file')
    luv.fs_rmdir('unit-test-directory')
  end)

  describe('os_dirname', function()
    itp('returns OK and writes current directory to the buffer', function()
      local length = string.len(luv.cwd()) + 1
      local buf = cstr(length, '')
      eq(OK, fs.os_dirname(buf, length))
      eq(luv.cwd(), ffi.string(buf))
    end)

    itp('returns FAIL if the buffer is too small', function()
      local length = string.len(luv.cwd()) + 1
      local buf = cstr(length - 1, '')
      eq(FAIL, fs.os_dirname(buf, length - 1))
    end)
  end)

  describe('os_chdir', function()
    itp('fails with path="~"', function()
      eq(false, os_isdir('~'), 'sanity check: no literal "~" directory')
      local length = 4096
      local expected_cwd = cstr(length, '')
      local cwd = cstr(length, '')
      eq(OK, fs.os_dirname(expected_cwd, length))

      -- os_chdir returns 0 for success, not OK (1).
      neq(0, fs.os_chdir('~'))    -- fail
      neq(0, fs.os_chdir('~/'))   -- fail

      eq(OK, fs.os_dirname(cwd, length))
      -- CWD did not change.
      eq(ffi.string(expected_cwd), ffi.string(cwd))
    end)
  end)

  describe('os_isdir', function()
    itp('returns false if an empty string is given', function()
      eq(false, (os_isdir('')))
    end)

    itp('returns false if a nonexisting directory is given', function()
      eq(false, (os_isdir('non-existing-directory')))
    end)

    itp('returns false if a nonexisting absolute directory is given', function()
      eq(false, (os_isdir('/non-existing-directory')))
    end)

    itp('returns false if an existing file is given', function()
      eq(false, (os_isdir('unit-test-directory/test.file')))
    end)

    itp('returns true if the current directory is given', function()
      eq(true, (os_isdir('.')))
    end)

    itp('returns true if the parent directory is given', function()
      eq(true, (os_isdir('..')))
    end)

    itp('returns true if an arbitrary directory is given', function()
      eq(true, (os_isdir('unit-test-directory')))
    end)

    itp('returns true if an absolute directory is given', function()
      eq(true, (os_isdir(directory)))
    end)
  end)

  describe('os_can_exe', function()
    local function os_can_exe(name)
      local buf = ffi.new('char *[1]')
      buf[0] = NULL
      local ce_ret = fs.os_can_exe(to_cstr(name), buf, true)

      -- When os_can_exe returns true, it must set the path.
      -- When it returns false, the path must be NULL.
      if ce_ret then
        neq(NULL, buf[0])
        return internalize(buf[0])
      else
        eq(NULL, buf[0])
        return nil
      end
    end

    local function cant_exe(name)
      eq(nil, os_can_exe(name))
    end

    local function exe(name)
      return os_can_exe(name)
    end

    itp('returns false when given a directory', function()
      cant_exe('./unit-test-directory')
    end)

    itp('returns false when given a regular file without executable bit set', function()
      cant_exe('unit-test-directory/test.file')
    end)

    itp('returns false when the given file does not exists', function()
      cant_exe('does-not-exist.file')
    end)

    itp('returns the absolute path when given an executable inside $PATH', function()
      local fullpath = exe('ls')
      eq(1, fs.path_is_absolute(to_cstr(fullpath)))
    end)

    itp('returns the absolute path when given an executable relative to the current dir', function()
      local old_dir = luv.cwd()

      luv.chdir(directory)

      -- Rely on currentdir to resolve symlinks, if any. Testing against
      -- the absolute path taken from arg[0] may result in failure where
      -- the path has a symlink in it.
      local canonical = luv.cwd() .. '/' .. executable_name
      local expected = exe(canonical)
      local relative_executable = './' .. executable_name
      local res = exe(relative_executable)

      -- Don't test yet; we need to chdir back first.
      luv.chdir(old_dir)
      eq(expected, res)
    end)
  end)

  describe('file permissions', function()
    local function os_fchown(filename, user_id, group_id)
      local fd = ffi.C.open(filename, 0)
      local res = fs.os_fchown(fd, user_id, group_id)
      ffi.C.close(fd)
      return res
    end

    local function os_file_is_readable(filename)
      return fs.os_file_is_readable((to_cstr(filename)))
    end

    local function os_file_is_writable(filename)
      return fs.os_file_is_writable((to_cstr(filename)))
    end

    local function bit_set(number, check_bit)
      return 0 ~= (bit.band(number, check_bit))
    end

    describe('os_getperm', function()
      itp('returns UV_ENOENT when the given file does not exist', function()
        eq(ffi.C.UV_ENOENT, (os_getperm('non-existing-file')))
      end)

      itp('returns a perm > 0 when given an existing file', function()
        assert.is_true((os_getperm('unit-test-directory')) > 0)
      end)

      itp('returns S_IRUSR when the file is readable', function()
        local perm = os_getperm('unit-test-directory')
        assert.is_true((bit_set(perm, ffi.C.kS_IRUSR)))
      end)
    end)

    describe('os_setperm', function()
      itp('can set and unset the executable bit of a file', function()
        local perm = os_getperm('unit-test-directory/test.file')
        perm = unset_bit(perm, ffi.C.kS_IXUSR)
        eq(OK, (os_setperm('unit-test-directory/test.file', perm)))
        perm = os_getperm('unit-test-directory/test.file')
        assert.is_false((bit_set(perm, ffi.C.kS_IXUSR)))
        perm = set_bit(perm, ffi.C.kS_IXUSR)
        eq(OK, os_setperm('unit-test-directory/test.file', perm))
        perm = os_getperm('unit-test-directory/test.file')
        assert.is_true((bit_set(perm, ffi.C.kS_IXUSR)))
      end)

      itp('fails if given file does not exist', function()
        local perm = ffi.C.kS_IXUSR
        eq(FAIL, (os_setperm('non-existing-file', perm)))
      end)
    end)

    describe('os_fchown', function()
      local filename = 'unit-test-directory/test.file'
      itp('does not change owner and group if respective IDs are equal to -1', function()
        local uid = luv.fs_stat(filename).uid
        local gid = luv.fs_stat(filename).gid
        eq(0, os_fchown(filename, -1, -1))
        eq(uid, luv.fs_stat(filename).uid)
        return eq(gid, luv.fs_stat(filename).gid)
      end)

      -- Some systems may not have `id` utility.
      if (os.execute('id -G > /dev/null 2>&1') ~= 0) then
        pending('skipped (missing `id` utility)', function() end)
      else
        itp('owner of a file may change the group of the file to any group of which that owner is a member', function()
          local file_gid = luv.fs_stat(filename).gid

          -- Gets ID of any group of which current user is a member except the
          -- group that owns the file.
          local id_fd = io.popen('id -G')
          local new_gid = id_fd:read('*n')
          if (new_gid == file_gid) then
            new_gid = id_fd:read('*n')
          end
          id_fd:close()

          -- User can be a member of only one group.
          -- In that case we can not perform this test.
          if new_gid then
            eq(0, (os_fchown(filename, -1, new_gid)))
            eq(new_gid, luv.fs_stat(filename).gid)
          end
        end)
      end

      if (ffi.os == 'Windows' or ffi.C.geteuid() == 0) then
        pending('skipped (uv_fs_chown is no-op on Windows)', function() end)
      else
        itp('returns nonzero if process has not enough permissions', function()
          -- chown to root
          neq(0, os_fchown(filename, 0, 0))
        end)
      end
    end)


    describe('os_file_is_readable', function()
      itp('returns false if the file is not readable', function()
        local perm = os_getperm('unit-test-directory/test.file')
        perm = unset_bit(perm, ffi.C.kS_IRUSR)
        perm = unset_bit(perm, ffi.C.kS_IRGRP)
        perm = unset_bit(perm, ffi.C.kS_IROTH)
        eq(OK, (os_setperm('unit-test-directory/test.file', perm)))
        eq(false, os_file_is_readable('unit-test-directory/test.file'))
      end)

      itp('returns false if the file does not exist', function()
        eq(false, os_file_is_readable(
          'unit-test-directory/what_are_you_smoking.gif'))
      end)

      itp('returns true if the file is readable', function()
        eq(true, os_file_is_readable(
          'unit-test-directory/test.file'))
      end)
    end)

    describe('os_file_is_writable', function()
      itp('returns 0 if the file is readonly', function()
        local perm = os_getperm('unit-test-directory/test.file')
        perm = unset_bit(perm, ffi.C.kS_IWUSR)
        perm = unset_bit(perm, ffi.C.kS_IWGRP)
        perm = unset_bit(perm, ffi.C.kS_IWOTH)
        eq(OK, (os_setperm('unit-test-directory/test.file', perm)))
        eq(0, os_file_is_writable('unit-test-directory/test.file'))
      end)

      itp('returns 1 if the file is writable', function()
        eq(1, os_file_is_writable('unit-test-directory/test.file'))
      end)

      itp('returns 2 when given a folder with rights to write into', function()
        eq(2, os_file_is_writable('unit-test-directory'))
      end)
    end)
  end)

  describe('file operations', function()
    local function os_path_exists(filename)
      return fs.os_path_exists((to_cstr(filename)))
    end
    local function os_rename(path, new_path)
      return fs.os_rename((to_cstr(path)), (to_cstr(new_path)))
    end
    local function os_remove(path)
      return fs.os_remove((to_cstr(path)))
    end
    local function os_open(path, flags, mode)
      return fs.os_open((to_cstr(path)), flags, mode)
    end
    local function os_close(fd)
      return fs.os_close(fd)
    end
    -- For some reason if length of NUL-bytes-string is the same as `char[?]`
    -- size luajit crashes. Though it does not do so in this test suite, better
    -- be cautios and allocate more elements then needed. I only did this to
    -- strings.
    local function os_read(fd, size)
      local buf = nil
      if size == nil then
        size = 0
      else
        buf = ffi.new('char[?]', size + 1, ('\0'):rep(size))
      end
      local eof = ffi.new('bool[?]', 1, {true})
      local ret2 = fs.os_read(fd, eof, buf, size, false)
      local ret1 = eof[0]
      local ret3 = ''
      if buf ~= nil then
        ret3 = ffi.string(buf, size)
      end
      return ret1, ret2, ret3
    end
    local function os_readv(fd, sizes)
      local bufs = {}
      for i, size in ipairs(sizes) do
        bufs[i] = {
          iov_base=ffi.new('char[?]', size + 1, ('\0'):rep(size)),
          iov_len=size,
        }
      end
      local iov = ffi.new('struct iovec[?]', #sizes, bufs)
      local eof = ffi.new('bool[?]', 1, {true})
      local ret2 = fs.os_readv(fd, eof, iov, #sizes, false)
      local ret1 = eof[0]
      local ret3 = {}
      for i = 1,#sizes do
        -- Warning: iov may not be used.
        ret3[i] = ffi.string(bufs[i].iov_base, bufs[i].iov_len)
      end
      return ret1, ret2, ret3
    end
    local function os_write(fd, data)
      return fs.os_write(fd, data, data and #data or 0, false)
    end

    describe('os_path_exists', function()
      itp('returns false when given a non-existing file', function()
        eq(false, (os_path_exists('non-existing-file')))
      end)

      itp('returns true when given an existing file', function()
        eq(true, (os_path_exists('unit-test-directory/test.file')))
      end)

      itp('returns false when given a broken symlink', function()
        eq(false, (os_path_exists('unit-test-directory/test_broken_link.file')))
      end)

      itp('returns true when given a directory', function()
        eq(true, (os_path_exists('unit-test-directory')))
      end)
    end)

    describe('os_rename', function()
      local test = 'unit-test-directory/test.file'
      local not_exist = 'unit-test-directory/not_exist.file'

      itp('can rename file if destination file does not exist', function()
        eq(OK, (os_rename(test, not_exist)))
        eq(false, (os_path_exists(test)))
        eq(true, (os_path_exists(not_exist)))
        eq(OK, (os_rename(not_exist, test)))  -- restore test file
      end)

      itp('fail if source file does not exist', function()
        eq(FAIL, (os_rename(not_exist, test)))
      end)

      itp('can overwrite destination file if it exists', function()
        local other = 'unit-test-directory/other.file'
        local file = io.open(other, 'w')
        file:write('other')
        file:flush()
        file:close()

        eq(OK, (os_rename(other, test)))
        eq(false, (os_path_exists(other)))
        eq(true, (os_path_exists(test)))
        file = io.open(test, 'r')
        eq('other', (file:read('*all')))
        file:close()
      end)
    end)

    describe('os_remove', function()
      before_each(function()
        io.open('unit-test-directory/test_remove.file', 'w'):close()
      end)

      after_each(function()
        os.remove('unit-test-directory/test_remove.file')
      end)

      itp('returns non-zero when given a non-existing file', function()
        neq(0, (os_remove('non-existing-file')))
      end)

      itp('removes the given file and returns 0', function()
        local f = 'unit-test-directory/test_remove.file'
        assert_file_exists(f)
        eq(0, (os_remove(f)))
        assert_file_does_not_exist(f)
      end)
    end)

    describe('os_dup', function()
      itp('returns new file descriptor', function()
        local dup0 = fs.os_dup(0)
        local dup1 = fs.os_dup(1)
        local dup2 = fs.os_dup(2)
        local tbl = {[0]=true, [1]=true, [2]=true,
                     [tonumber(dup0)]=true, [tonumber(dup1)]=true,
                     [tonumber(dup2)]=true}
        local i = 0
        for _, _ in pairs(tbl) do
          i = i + 1
        end
        eq(i, 6)  -- All fds must be unique
      end)
    end)

    describe('os_open', function()
      local new_file = 'test_new_file'
      local existing_file = 'unit-test-directory/test_existing.file'

      before_each(function()
        (io.open(existing_file, 'w')):close()
      end)

      after_each(function()
        os.remove(existing_file)
        os.remove(new_file)
      end)

      itp('returns UV_ENOENT for O_RDWR on a non-existing file', function()
        eq(ffi.C.UV_ENOENT, (os_open('non-existing-file', ffi.C.kO_RDWR, 0)))
      end)

      itp('returns non-negative for O_CREAT on a non-existing file which then can be closed', function()
        assert_file_does_not_exist(new_file)
        local fd = os_open(new_file, ffi.C.kO_CREAT, 0)
        assert.is_true(0 <= fd)
        eq(0, os_close(fd))
      end)

      itp('returns non-negative for O_CREAT on a existing file which then can be closed', function()
        assert_file_exists(existing_file)
        local fd = os_open(existing_file, ffi.C.kO_CREAT, 0)
        assert.is_true(0 <= fd)
        eq(0, os_close(fd))
      end)

      itp('returns UV_EEXIST for O_CREAT|O_EXCL on a existing file', function()
        assert_file_exists(existing_file)
        eq(ffi.C.UV_EEXIST, (os_open(existing_file, (bit.bor(ffi.C.kO_CREAT, ffi.C.kO_EXCL)), 0)))
      end)

      itp('sets `rwx` permissions for O_CREAT 700 which then can be closed', function()
        assert_file_does_not_exist(new_file)
        --create the file
        local fd = os_open(new_file, ffi.C.kO_CREAT, tonumber("700", 8))
        --verify permissions
        eq(33216, luv.fs_stat(new_file).mode)
        eq(0, os_close(fd))
      end)

      itp('sets `rw` permissions for O_CREAT 600 which then can be closed', function()
        assert_file_does_not_exist(new_file)
        --create the file
        local fd = os_open(new_file, ffi.C.kO_CREAT, tonumber("600", 8))
        --verify permissions
        eq(33152, luv.fs_stat(new_file).mode)
        eq(0, os_close(fd))
      end)

      itp('returns a non-negative file descriptor for an existing file which then can be closed', function()
        local fd = os_open(existing_file, ffi.C.kO_RDWR, 0)
        assert.is_true(0 <= fd)
        eq(0, os_close(fd))
      end)
    end)

    describe('os_close', function()
      itp('returns EBADF for negative file descriptors', function()
        eq(ffi.C.UV_EBADF, os_close(-1))
        eq(ffi.C.UV_EBADF, os_close(-1000))
      end)
    end)

    describe('os_read', function()
      local file = 'test-unit-os-fs_spec-os_read.dat'

      before_each(function()
        local f = io.open(file, 'w')
        f:write(fcontents)
        f:close()
      end)

      after_each(function()
        os.remove(file)
      end)

      itp('can read zero bytes from a file', function()
        local fd = os_open(file, ffi.C.kO_RDONLY, 0)
        ok(fd >= 0)
        eq({false, 0, ''}, {os_read(fd, nil)})
        eq({false, 0, ''}, {os_read(fd, 0)})
        eq(0, os_close(fd))
      end)

      itp('can read from a file multiple times', function()
        local fd = os_open(file, ffi.C.kO_RDONLY, 0)
        ok(fd >= 0)
        eq({false, 2, '\000\001'}, {os_read(fd, 2)})
        eq({false, 2, '\002\003'}, {os_read(fd, 2)})
        eq(0, os_close(fd))
      end)

      itp('can read the whole file at once and then report eof', function()
        local fd = os_open(file, ffi.C.kO_RDONLY, 0)
        ok(fd >= 0)
        eq({false, #fcontents, fcontents}, {os_read(fd, #fcontents)})
        eq({true, 0, ('\0'):rep(#fcontents)}, {os_read(fd, #fcontents)})
        eq(0, os_close(fd))
      end)

      itp('can read the whole file in two calls, one partially', function()
        local fd = os_open(file, ffi.C.kO_RDONLY, 0)
        ok(fd >= 0)
        eq({false, #fcontents * 3/4, fcontents:sub(1, #fcontents * 3/4)},
           {os_read(fd, #fcontents * 3/4)})
        eq({true,
            (#fcontents * 1/4),
            fcontents:sub(#fcontents * 3/4 + 1) .. ('\0'):rep(#fcontents * 2/4)},
           {os_read(fd, #fcontents * 3/4)})
        eq(0, os_close(fd))
      end)
    end)

    describe('os_readv', function()
      -- Function may be absent
      if not pcall(function() return fs.os_readv end) then
        return
      end
      local file = 'test-unit-os-fs_spec-os_readv.dat'

      before_each(function()
        local f = io.open(file, 'w')
        f:write(fcontents)
        f:close()
      end)

      after_each(function()
        os.remove(file)
      end)

      itp('can read zero bytes from a file', function()
        local fd = os_open(file, ffi.C.kO_RDONLY, 0)
        ok(fd >= 0)
        eq({false, 0, {}}, {os_readv(fd, {})})
        eq({false, 0, {'', '', ''}}, {os_readv(fd, {0, 0, 0})})
        eq(0, os_close(fd))
      end)

      itp('can read from a file multiple times to a differently-sized buffers', function()
        local fd = os_open(file, ffi.C.kO_RDONLY, 0)
        ok(fd >= 0)
        eq({false, 2, {'\000\001'}}, {os_readv(fd, {2})})
        eq({false, 5, {'\002\003', '\004\005\006'}}, {os_readv(fd, {2, 3})})
        eq(0, os_close(fd))
      end)

      itp('can read the whole file at once and then report eof', function()
        local fd = os_open(file, ffi.C.kO_RDONLY, 0)
        ok(fd >= 0)
        eq({false,
            #fcontents,
            {fcontents:sub(1, #fcontents * 1/4),
             fcontents:sub(#fcontents * 1/4 + 1, #fcontents * 3/4),
             fcontents:sub(#fcontents * 3/4 + 1, #fcontents * 15/16),
             fcontents:sub(#fcontents * 15/16 + 1, #fcontents)}},
           {os_readv(fd, {#fcontents * 1/4,
                          #fcontents * 2/4,
                          #fcontents * 3/16,
                          #fcontents * 1/16})})
        eq({true, 0, {'\0'}}, {os_readv(fd, {1})})
        eq(0, os_close(fd))
      end)

      itp('can read the whole file in two calls, one partially', function()
        local fd = os_open(file, ffi.C.kO_RDONLY, 0)
        ok(fd >= 0)
        eq({false, #fcontents * 3/4, {fcontents:sub(1, #fcontents * 3/4)}},
           {os_readv(fd, {#fcontents * 3/4})})
        eq({true,
            (#fcontents * 1/4),
            {fcontents:sub(#fcontents * 3/4 + 1) .. ('\0'):rep(#fcontents * 2/4)}},
           {os_readv(fd, {#fcontents * 3/4})})
        eq(0, os_close(fd))
      end)
    end)

    describe('os_write', function()
      -- Function may be absent
      local file = 'test-unit-os-fs_spec-os_write.dat'

      before_each(function()
        local f = io.open(file, 'w')
        f:write(fcontents)
        f:close()
      end)

      after_each(function()
        os.remove(file)
      end)

      itp('can write zero bytes to a file', function()
        local fd = os_open(file, ffi.C.kO_WRONLY, 0)
        ok(fd >= 0)
        eq(0, os_write(fd, ''))
        eq(0, os_write(fd, nil))
        eq(fcontents, io.open(file, 'r'):read('*a'))
        eq(0, os_close(fd))
      end)

      itp('can write some data to a file', function()
        local fd = os_open(file, ffi.C.kO_WRONLY, 0)
        ok(fd >= 0)
        eq(3, os_write(fd, 'abc'))
        eq(4, os_write(fd, ' def'))
        eq('abc def' .. fcontents:sub(8), io.open(file, 'r'):read('*a'))
        eq(0, os_close(fd))
      end)
    end)

    describe('os_nodetype', function()
      before_each(function()
        os.remove('non-existing-file')
      end)

      itp('returns NODE_NORMAL for non-existing file', function()
        eq(NODE_NORMAL, fs.os_nodetype(to_cstr('non-existing-file')))
      end)

      itp('returns NODE_WRITABLE for /dev/stderr', function()
        eq(NODE_WRITABLE, fs.os_nodetype(to_cstr('/dev/stderr')))
      end)
    end)
  end)

  describe('folder operations', function()
    local function os_mkdir(path, mode)
      return fs.os_mkdir(to_cstr(path), mode)
    end

    local function os_rmdir(path)
      return fs.os_rmdir(to_cstr(path))
    end

    local function os_mkdir_recurse(path, mode)
      local failed_str = ffi.new('char *[1]', {nil})
      local created_str = ffi.new('char *[1]', {nil})
      local ret = fs.os_mkdir_recurse(path, mode, failed_str, created_str)
      local failed_dir = failed_str[0]
      if failed_dir ~= nil then
        failed_dir = ffi.string(failed_dir)
      end
      local created_dir = created_str[0]
      if created_dir ~= nil then
        created_dir = ffi.string(created_dir)
      end
      return ret, failed_dir, created_dir
    end

    describe('os_mkdir', function()
      itp('returns non-zero when given an already existing directory', function()
        local mode = ffi.C.kS_IRUSR + ffi.C.kS_IWUSR + ffi.C.kS_IXUSR
        neq(0, (os_mkdir('unit-test-directory', mode)))
      end)

      itp('creates a directory and returns 0', function()
        local mode = ffi.C.kS_IRUSR + ffi.C.kS_IWUSR + ffi.C.kS_IXUSR
        eq(false, (os_isdir('unit-test-directory/new-dir')))
        eq(0, (os_mkdir('unit-test-directory/new-dir', mode)))
        eq(true, (os_isdir('unit-test-directory/new-dir')))
        luv.fs_rmdir('unit-test-directory/new-dir')
      end)
    end)

    describe('os_mkdir_recurse', function()
      itp('returns zero when given an already existing directory', function()
        local mode = ffi.C.kS_IRUSR + ffi.C.kS_IWUSR + ffi.C.kS_IXUSR
        local ret, failed_dir, created_dir = os_mkdir_recurse('unit-test-directory', mode)
        eq(0, ret)
        eq(nil, failed_dir)
        eq(nil, created_dir)
      end)

      itp('fails to create a directory where there is a file', function()
        local mode = ffi.C.kS_IRUSR + ffi.C.kS_IWUSR + ffi.C.kS_IXUSR
        local ret, failed_dir, created_dir = os_mkdir_recurse(
            'unit-test-directory/test.file', mode)
        neq(0, ret)
        eq('unit-test-directory/test.file', failed_dir)
        eq(nil, created_dir)
      end)

      itp('fails to create a directory where there is a file in path', function()
        local mode = ffi.C.kS_IRUSR + ffi.C.kS_IWUSR + ffi.C.kS_IXUSR
        local ret, failed_dir, created_dir = os_mkdir_recurse(
            'unit-test-directory/test.file/test', mode)
        neq(0, ret)
        eq('unit-test-directory/test.file', failed_dir)
        eq(nil, created_dir)
      end)

      itp('succeeds to create a directory', function()
        local mode = ffi.C.kS_IRUSR + ffi.C.kS_IWUSR + ffi.C.kS_IXUSR
        local ret, failed_dir, created_dir = os_mkdir_recurse(
            'unit-test-directory/new-dir-recurse', mode)
        eq(0, ret)
        eq(nil, failed_dir)
        ok(endswith(created_dir, 'unit-test-directory/new-dir-recurse'))
        eq(true, os_isdir('unit-test-directory/new-dir-recurse'))
        luv.fs_rmdir('unit-test-directory/new-dir-recurse')
        eq(false, os_isdir('unit-test-directory/new-dir-recurse'))
      end)

      itp('succeeds to create a directory ending with ///', function()
        local mode = ffi.C.kS_IRUSR + ffi.C.kS_IWUSR + ffi.C.kS_IXUSR
        local ret, failed_dir, created_dir = os_mkdir_recurse(
            'unit-test-directory/new-dir-recurse///', mode)
        eq(0, ret)
        eq(nil, failed_dir)
        ok(endswith(created_dir, 'unit-test-directory/new-dir-recurse'))
        eq(true, os_isdir('unit-test-directory/new-dir-recurse'))
        luv.fs_rmdir('unit-test-directory/new-dir-recurse')
        eq(false, os_isdir('unit-test-directory/new-dir-recurse'))
      end)

      itp('succeeds to create a directory ending with /', function()
        local mode = ffi.C.kS_IRUSR + ffi.C.kS_IWUSR + ffi.C.kS_IXUSR
        local ret, failed_dir, created_dir = os_mkdir_recurse(
            'unit-test-directory/new-dir-recurse/', mode)
        eq(0, ret)
        eq(nil, failed_dir)
        ok(endswith(created_dir, 'unit-test-directory/new-dir-recurse'))
        eq(true, os_isdir('unit-test-directory/new-dir-recurse'))
        luv.fs_rmdir('unit-test-directory/new-dir-recurse')
        eq(false, os_isdir('unit-test-directory/new-dir-recurse'))
      end)

      itp('succeeds to create a directory tree', function()
        local mode = ffi.C.kS_IRUSR + ffi.C.kS_IWUSR + ffi.C.kS_IXUSR
        local ret, failed_dir, created_dir = os_mkdir_recurse(
            'unit-test-directory/new-dir-recurse/1/2/3', mode)
        eq(0, ret)
        eq(nil, failed_dir)
        ok(endswith(created_dir, 'unit-test-directory/new-dir-recurse'))
        eq(true, os_isdir('unit-test-directory/new-dir-recurse'))
        eq(true, os_isdir('unit-test-directory/new-dir-recurse/1'))
        eq(true, os_isdir('unit-test-directory/new-dir-recurse/1/2'))
        eq(true, os_isdir('unit-test-directory/new-dir-recurse/1/2/3'))
        luv.fs_rmdir('unit-test-directory/new-dir-recurse/1/2/3')
        luv.fs_rmdir('unit-test-directory/new-dir-recurse/1/2')
        luv.fs_rmdir('unit-test-directory/new-dir-recurse/1')
        luv.fs_rmdir('unit-test-directory/new-dir-recurse')
        eq(false, os_isdir('unit-test-directory/new-dir-recurse'))
      end)
    end)

    describe('os_rmdir', function()
      itp('returns non_zero when given a non-existing directory', function()
        neq(0, (os_rmdir('non-existing-directory')))
      end)

      itp('removes the given directory and returns 0', function()
        mkdir('unit-test-directory/new-dir')
        eq(0, os_rmdir('unit-test-directory/new-dir'))
        eq(false, (os_isdir('unit-test-directory/new-dir')))
      end)
    end)
  end)

  describe('FileInfo', function()
    local function file_info_new()
      local info = ffi.new('FileInfo[1]')
      info[0].stat.st_ino = 0
      info[0].stat.st_dev = 0
      return info
    end

    -- Returns true if the FileInfo object has non-empty fields.
    local function has_fileinfo(info)
      return info[0].stat.st_ino > 0 and info[0].stat.st_dev > 0
    end

    local function file_id_new()
      local info = ffi.new('FileID[1]')
      info[0].inode = 0
      info[0].device_id = 0
      return info
    end

    describe('os_fileinfo', function()
      itp('returns false if path=NULL', function()
        local info = file_info_new()
        assert.is_false((fs.os_fileinfo(nil, info)))
      end)

      itp('returns false if given a non-existing file', function()
        local info = file_info_new()
        assert.is_false((fs.os_fileinfo('/non-existent', info)))
      end)

      itp('returns true if given an existing file and fills FileInfo', function()
        local info = file_info_new()
        local path = 'unit-test-directory/test.file'
        assert.is_true((fs.os_fileinfo(path, info)))
        assert.is_true((has_fileinfo(info)))
      end)

      itp('returns the FileInfo of the linked file, not the link', function()
        local info = file_info_new()
        local path = 'unit-test-directory/test_link.file'
        assert.is_true((fs.os_fileinfo(path, info)))
        assert.is_true((has_fileinfo(info)))
        local mode = tonumber(info[0].stat.st_mode)
        return eq(ffi.C.kS_IFREG, (bit.band(mode, ffi.C.kS_IFMT)))
      end)
    end)

    describe('os_fileinfo_link', function()
      itp('returns false for non-existing file', function()
        local info = file_info_new()
        assert.is_false((fs.os_fileinfo_link('/non-existent', info)))
      end)

      itp('returns true and fills FileInfo for existing file', function()
        local info = file_info_new()
        local path = 'unit-test-directory/test.file'
        assert.is_true((fs.os_fileinfo_link(path, info)))
        assert.is_true((has_fileinfo(info)))
      end)

      itp('returns FileInfo of the link, not its target', function()
        local info = file_info_new()
        local link = 'unit-test-directory/test_link.file'
        assert.is_true((fs.os_fileinfo_link(link, info)))
        assert.is_true((has_fileinfo(info)))
        local mode = tonumber(info[0].stat.st_mode)
        eq(ffi.C.kS_IFLNK, (bit.band(mode, ffi.C.kS_IFMT)))
      end)
    end)

    describe('os_fileinfo_fd', function()
      itp('returns false if given an invalid file descriptor', function()
        local info = file_info_new()
        assert.is_false((fs.os_fileinfo_fd(-1, info)))
      end)

      itp('returns true if given a file descriptor and fills FileInfo', function()
        local info = file_info_new()
        local path = 'unit-test-directory/test.file'
        local fd = ffi.C.open(path, 0)
        assert.is_true((fs.os_fileinfo_fd(fd, info)))
        assert.is_true((has_fileinfo(info)))
        ffi.C.close(fd)
      end)
    end)

    describe('os_fileinfo_id_equal', function()
      itp('returns false if file infos represent different files', function()
        local file_info_1 = file_info_new()
        local file_info_2 = file_info_new()
        local path_1 = 'unit-test-directory/test.file'
        local path_2 = 'unit-test-directory/test_2.file'
        assert.is_true((fs.os_fileinfo(path_1, file_info_1)))
        assert.is_true((fs.os_fileinfo(path_2, file_info_2)))
        assert.is_false((fs.os_fileinfo_id_equal(file_info_1, file_info_2)))
      end)

      itp('returns true if file infos represent the same file', function()
        local file_info_1 = file_info_new()
        local file_info_2 = file_info_new()
        local path = 'unit-test-directory/test.file'
        assert.is_true((fs.os_fileinfo(path, file_info_1)))
        assert.is_true((fs.os_fileinfo(path, file_info_2)))
        assert.is_true((fs.os_fileinfo_id_equal(file_info_1, file_info_2)))
      end)

      itp('returns true if file infos represent the same file (symlink)', function()
        local file_info_1 = file_info_new()
        local file_info_2 = file_info_new()
        local path_1 = 'unit-test-directory/test.file'
        local path_2 = 'unit-test-directory/test_link.file'
        assert.is_true((fs.os_fileinfo(path_1, file_info_1)))
        assert.is_true((fs.os_fileinfo(path_2, file_info_2)))
        assert.is_true((fs.os_fileinfo_id_equal(file_info_1, file_info_2)))
      end)
    end)

    describe('os_fileinfo_id', function()
      itp('extracts ino/dev from FileInfo into file_id', function()
        local info = file_info_new()
        local file_id = file_id_new()
        local path = 'unit-test-directory/test.file'
        assert.is_true((fs.os_fileinfo(path, info)))
        fs.os_fileinfo_id(info, file_id)
        eq(info[0].stat.st_ino, file_id[0].inode)
        eq(info[0].stat.st_dev, file_id[0].device_id)
      end)
    end)

    describe('os_fileinfo_inode', function()
      itp('returns the inode from FileInfo', function()
        local info = file_info_new()
        local path = 'unit-test-directory/test.file'
        assert.is_true((fs.os_fileinfo(path, info)))
        local inode = fs.os_fileinfo_inode(info)
        eq(info[0].stat.st_ino, inode)
      end)
    end)

    describe('os_fileinfo_size', function()
      itp('returns the correct size of a file', function()
        local path = 'unit-test-directory/test.file'
        local file = io.open(path, 'w')
        file:write('some bytes to get filesize != 0')
        file:flush()
        file:close()
        local size = luv.fs_stat(path).size
        local info = file_info_new()
        assert.is_true(fs.os_fileinfo(path, info))
        eq(size, fs.os_fileinfo_size(info))
      end)
    end)

    describe('os_fileinfo_hardlinks', function()
      itp('returns the correct number of hardlinks', function()
        local path = 'unit-test-directory/test.file'
        local path_link = 'unit-test-directory/test_hlink.file'
        local info = file_info_new()
        assert.is_true(fs.os_fileinfo(path, info))
        eq(1, fs.os_fileinfo_hardlinks(info))
        luv.fs_link(path, path_link)
        assert.is_true(fs.os_fileinfo(path, info))
        eq(2, fs.os_fileinfo_hardlinks(info))
      end)
    end)

    describe('os_fileinfo_blocksize', function()
      itp('returns the correct blocksize of a file', function()
        local path = 'unit-test-directory/test.file'
        local blksize = luv.fs_stat(path).blksize
        local info = file_info_new()
        assert.is_true(fs.os_fileinfo(path, info))
        if blksize then
          eq(blksize, fs.os_fileinfo_blocksize(info))
        else
          -- luafs doesn't support blksize on windows
          -- libuv on windows returns a constant value as blocksize
          -- checking for this constant value should be enough
          eq(2048, fs.os_fileinfo_blocksize(info))
        end
      end)
    end)

    describe('os_fileid', function()
      itp('returns false if given an non-existing file', function()
        local file_id = file_id_new()
        assert.is_false((fs.os_fileid('/non-existent', file_id)))
      end)

      itp('returns true if given an existing file and fills file_id', function()
        local file_id = file_id_new()
        local path = 'unit-test-directory/test.file'
        assert.is_true((fs.os_fileid(path, file_id)))
        assert.is_true(0 < file_id[0].inode)
        assert.is_true(0 < file_id[0].device_id)
      end)
    end)

    describe('os_fileid_equal', function()
      itp('returns true if two FileIDs are equal', function()
        local file_id = file_id_new()
        local path = 'unit-test-directory/test.file'
        assert.is_true((fs.os_fileid(path, file_id)))
        assert.is_true((fs.os_fileid_equal(file_id, file_id)))
      end)

      itp('returns false if two FileIDs are not equal', function()
        local file_id_1 = file_id_new()
        local file_id_2 = file_id_new()
        local path_1 = 'unit-test-directory/test.file'
        local path_2 = 'unit-test-directory/test_2.file'
        assert.is_true((fs.os_fileid(path_1, file_id_1)))
        assert.is_true((fs.os_fileid(path_2, file_id_2)))
        assert.is_false((fs.os_fileid_equal(file_id_1, file_id_2)))
      end)
    end)

    describe('os_fileid_equal_fileinfo', function()
      itp('returns true if file_id and FileInfo represent the same file', function()
        local file_id = file_id_new()
        local info = file_info_new()
        local path = 'unit-test-directory/test.file'
        assert.is_true((fs.os_fileid(path, file_id)))
        assert.is_true((fs.os_fileinfo(path, info)))
        assert.is_true((fs.os_fileid_equal_fileinfo(file_id, info)))
      end)

      itp('returns false if file_id and FileInfo represent different files', function()
        local file_id = file_id_new()
        local info = file_info_new()
        local path_1 = 'unit-test-directory/test.file'
        local path_2 = 'unit-test-directory/test_2.file'
        assert.is_true((fs.os_fileid(path_1, file_id)))
        assert.is_true((fs.os_fileinfo(path_2, info)))
        assert.is_false((fs.os_fileid_equal_fileinfo(file_id, info)))
      end)
    end)
  end)
end)