Merge #6038 from justinmk/win32-executable

win: executable()

5 files changed, 185 insertions, 14 deletions

diff --git a/test/functional/eval/executable_spec.lua b/test/functional/eval/executable_spec.lua
new file mode 100644
index 0000000000..c931b47221
--- /dev/null
+++ b/test/functional/eval/executable_spec.lua
@@ -0,0 +1,156 @@
+local helpers = require('test.functional.helpers')(after_each)
+local eq, clear, call, iswin, write_file =
+  helpers.eq, helpers.clear, helpers.call, helpers.iswin, helpers.write_file
+
+describe('executable()', function()
+  before_each(clear)
+
+  it('returns 1 for commands in $PATH', function()
+    local exe = iswin() and 'ping' or 'ls'
+    eq(1, call('executable', exe))
+  end)
+
+  it('returns 0 for non-existent files', function()
+    eq(0, call('executable', 'no_such_file_exists_209ufq23f'))
+  end)
+
+  it('sibling to nvim binary', function()
+    -- Some executable in build/bin/, *not* in $PATH nor CWD.
+    local sibling_exe = 'printargs-test'
+    -- Windows: siblings are in Nvim's "pseudo-$PATH".
+    local expected = iswin() and 1 or 0
+    if iswin() then
+      -- $PATH on AppVeyor CI might be oversized, redefine it to a minimal one.
+      clear({env={PATH=[[C:\Windows\system32;C:\Windows]]}})
+      eq('arg1=lemon;arg2=sky;arg3=tree;',
+         call('system', sibling_exe..' lemon sky tree'))
+    end
+    local is_executable = call('executable', sibling_exe)
+    if iswin() and is_executable ~= expected then
+      pending('XXX: sometimes fails on AppVeyor')
+    end
+  end)
+
+  describe('exec-bit', function()
+    setup(function()
+      clear()
+      write_file('Xtest_not_executable', 'non-executable file')
+      write_file('Xtest_executable', 'executable file (exec-bit set)')
+      if not iswin() then  -- N/A for Windows.
+        call('system', {'chmod', '-x', 'Xtest_not_executable'})
+        call('system', {'chmod', '+x', 'Xtest_executable'})
+      end
+    end)
+
+    teardown(function()
+      os.remove('Xtest_not_executable')
+      os.remove('Xtest_executable')
+    end)
+
+    it('not set', function()
+      local expected = iswin() and 1 or 0
+      eq(expected, call('executable', 'Xtest_not_executable'))
+      eq(expected, call('executable', './Xtest_not_executable'))
+    end)
+
+    it('set, unqualified and not in $PATH', function()
+      local expected = iswin() and 1 or 0
+      eq(expected, call('executable', 'Xtest_executable'))
+    end)
+
+    it('set, qualified as a path', function()
+      eq(1, call('executable', './Xtest_executable'))
+    end)
+  end)
+end)
+
+describe('executable() (Windows)', function()
+  if not iswin() then return end  -- N/A for Unix.
+
+  local exts = {'bat', 'exe', 'com', 'cmd'}
+  setup(function()
+    for _, ext in ipairs(exts) do
+      write_file('test_executable_'..ext..'.'..ext, '')
+    end
+    write_file('test_executable_zzz.zzz', '')
+  end)
+
+  teardown(function()
+    for _, ext in ipairs(exts) do
+      os.remove('test_executable_'..ext..'.'..ext)
+    end
+    os.remove('test_executable_zzz.zzz')
+  end)
+
+  it('tries default extensions on a filename if $PATHEXT is empty', function()
+    -- Empty $PATHEXT defaults to ".com;.exe;.bat;.cmd".
+    clear({env={PATHEXT=''}})
+    for _,ext in ipairs(exts) do
+      eq(1, call('executable', 'test_executable_'..ext))
+    end
+    eq(0, call('executable', 'test_executable_zzz'))
+  end)
+
+  it('tries default extensions on a filepath if $PATHEXT is empty', function()
+    -- Empty $PATHEXT defaults to ".com;.exe;.bat;.cmd".
+    clear({env={PATHEXT=''}})
+    for _,ext in ipairs(exts) do
+      eq(1, call('executable', '.\\test_executable_'..ext))
+    end
+    eq(0, call('executable', '.\\test_executable_zzz'))
+  end)
+
+  it('full path with extension', function()
+    -- Some executable we can expect in the test env.
+    local exe = 'printargs-test'
+    local exedir = helpers.eval("fnamemodify(v:progpath, ':h')")
+    local exepath = exedir..'/'..exe..'.exe'
+    eq(1, call('executable', exepath))
+    eq('arg1=lemon;arg2=sky;arg3=tree;',
+       call('system', exepath..' lemon sky tree'))
+  end)
+
+  it('full path without extension', function()
+    -- Some executable we can expect in the test env.
+    local exe = 'printargs-test'
+    local exedir = helpers.eval("fnamemodify(v:progpath, ':h')")
+    local exepath = exedir..'/'..exe
+    eq('arg1=lemon;arg2=sky;arg3=tree;',
+       call('system', exepath..' lemon sky tree'))
+     eq(1, call('executable', exepath))
+  end)
+
+  it('respects $PATHEXT when trying extensions on a filename', function()
+    clear({env={PATHEXT='.zzz'}})
+    for _,ext in ipairs(exts) do
+      eq(0, call('executable', 'test_executable_'..ext))
+    end
+    eq(1, call('executable', 'test_executable_zzz'))
+  end)
+
+  it('respects $PATHEXT when trying extensions on a filepath', function()
+    clear({env={PATHEXT='.zzz'}})
+    for _,ext in ipairs(exts) do
+      eq(0, call('executable', '.\\test_executable_'..ext))
+    end
+    eq(1, call('executable', '.\\test_executable_zzz'))
+  end)
+
+  it('returns 1 for any existing filename', function()
+    clear({env={PATHEXT=''}})
+    for _,ext in ipairs(exts) do
+      eq(1, call('executable', 'test_executable_'..ext..'.'..ext))
+    end
+    eq(1, call('executable', 'test_executable_zzz.zzz'))
+  end)
+
+  it('returns 1 for any existing path (backslashes)', function()
+    clear({env={PATHEXT=''}})
+    for _,ext in ipairs(exts) do
+      eq(1, call('executable', '.\\test_executable_'..ext..'.'..ext))
+      eq(1, call('executable', './test_executable_'..ext..'.'..ext))
+    end
+    eq(1, call('executable', '.\\test_executable_zzz.zzz'))
+    eq(1, call('executable', './test_executable_zzz.zzz'))
+  end)
+end)
diff --git a/test/functional/helpers.lua b/test/functional/helpers.lua
index 880cb6546c..ca59c0dd2e 100644
--- a/test/functional/helpers.lua
+++ b/test/functional/helpers.lua
@@ -290,7 +290,9 @@ local function clear(...)
         'NVIM_LOG_FILE',
         'NVIM_RPLUGIN_MANIFEST',
       }) do
-        env_tbl[k] = os.getenv(k)
+        if not env_tbl[k] then
+          env_tbl[k] = os.getenv(k)
+        end
       end
       env = {}
       for k, v in pairs(env_tbl) do
diff --git a/test/functional/options/defaults_spec.lua b/test/functional/options/defaults_spec.lua
index caeca5e4e2..f3328886b5 100644
--- a/test/functional/options/defaults_spec.lua
+++ b/test/functional/options/defaults_spec.lua
@@ -96,6 +96,10 @@ describe('startup defaults', function()
       eq(meths.get_option('runtimepath'), meths.get_option('packpath'))
     end)
   end)
+
+  it('v:progpath is set to the absolute path', function()
+    eq(eval("fnamemodify(v:progpath, ':p')"), eval('v:progpath'))
+  end)
 end)
 
 describe('XDG-based defaults', function()
diff --git a/test/unit/os/env_spec.lua b/test/unit/os/env_spec.lua
index 64bbaaa8c2..3c2cc164c9 100644
--- a/test/unit/os/env_spec.lua
+++ b/test/unit/os/env_spec.lua
@@ -14,15 +14,15 @@ local cimp = cimport('./src/nvim/os/os.h')
 
 describe('env function', function()
   local function os_setenv(name, value, override)
-    return cimp.os_setenv((to_cstr(name)), (to_cstr(value)), override)
+    return cimp.os_setenv(to_cstr(name), to_cstr(value), override)
   end
 
   local function os_unsetenv(name, _, _)
-    return cimp.os_unsetenv((to_cstr(name)))
+    return cimp.os_unsetenv(to_cstr(name))
   end
 
   local function os_getenv(name)
-    local rval = cimp.os_getenv((to_cstr(name)))
+    local rval = cimp.os_getenv(to_cstr(name))
     if rval ~= NULL then
       return ffi.string(rval)
     else
@@ -52,6 +52,20 @@ describe('env function', function()
     end)
   end)
 
+  describe('os_setenv_append_path', function()
+    it('appends /foo/bar to $PATH', function()
+      local original_path = os.getenv('PATH')
+      eq(true, cimp.os_setenv_append_path(to_cstr('/foo/bar/baz')))
+      eq(original_path..':/foo/bar', os.getenv('PATH'))
+    end)
+
+    it('returns false if `fname` is not absolute', function()
+      local original_path = os.getenv('PATH')
+      eq(false, cimp.os_setenv_append_path(to_cstr('foo/bar/baz')))
+      eq(original_path, os.getenv('PATH'))
+    end)
+  end)
+
   describe('os_getenv', function()
     it('reads an env variable', function()
       local name = 'NEOVIM_UNIT_TEST_GETENV_1N'
diff --git a/test/unit/os/fs_spec.lua b/test/unit/os/fs_spec.lua
index 5d889d6e33..516fb5a7d1 100644
--- a/test/unit/os/fs_spec.lua
+++ b/test/unit/os/fs_spec.lua
@@ -23,7 +23,7 @@ cimport('./src/nvim/os/shell.h')
 cimport('./src/nvim/option_defs.h')
 cimport('./src/nvim/main.h')
 cimport('./src/nvim/fileio.h')
-local fs = cimport('./src/nvim/os/os.h')
+local fs = cimport('./src/nvim/os/os.h', './src/nvim/path.h')
 cppimport('sys/stat.h')
 cppimport('fcntl.h')
 cppimport('uv-errno.h')
@@ -77,11 +77,9 @@ describe('fs function', function()
     lfs.link('test.file', 'unit-test-directory/test_link.file', true)
 
     lfs.link('non_existing_file.file', 'unit-test-directory/test_broken_link.file', true)
-    -- Since the tests are executed, they are called by an executable. We use
-    -- that executable for several asserts.
+    -- The tests are invoked with an absolute path to `busted` executable.
     absolute_executable = arg[0]
-    -- Split absolute_executable into a directory and the actual file name for
-    -- later usage.
+    -- Split the absolute_executable path into a directory and filename.
     directory, executable_name = string.match(absolute_executable, '^(.*)/(.*)$')
   end)
 
@@ -194,11 +192,8 @@ describe('fs function', function()
     end)
 
     it('returns the absolute path when given an executable inside $PATH', function()
-      -- Since executable_name does not start with "./", the path will be
-      -- selected from $PATH. Make sure the ends match, ignore the directories.
-      local _, busted = string.match(absolute_executable, '^(.*)/(.*)$')
-      local _, name = string.match(exe(executable_name), '^(.*)/(.*)$')
-      eq(busted, name)
+      local fullpath = exe('ls')
+      eq(1, fs.path_is_absolute_path(to_cstr(fullpath)))
     end)
 
     it('returns the absolute path when given an executable relative to the current dir', function()