Merge pull request #23487 from zeertzjq/vim-8.2.1953

vim-patch:8.2.1953,9.0.{0213,0404,0543,0846,0854,1507}: assert fixes

6 files changed, 276 insertions, 53 deletions

diff --git a/src/nvim/eval.h b/src/nvim/eval.h
index e9cdb108a8..5fbfc4702c 100644
--- a/src/nvim/eval.h
+++ b/src/nvim/eval.h
@@ -229,16 +229,6 @@ typedef struct {
   Callback callback;
 } timer_T;
 
-/// Type of assert_* check being performed
-typedef enum {
-  ASSERT_EQUAL,
-  ASSERT_NOTEQUAL,
-  ASSERT_MATCH,
-  ASSERT_NOTMATCH,
-  ASSERT_INRANGE,
-  ASSERT_OTHER,
-} assert_type_T;
-
 /// types for expressions.
 typedef enum {
   EXPR_UNKNOWN = 0,
diff --git a/src/nvim/eval/typval.c b/src/nvim/eval/typval.c
index 5f0c082ada..5755178b18 100644
--- a/src/nvim/eval/typval.c
+++ b/src/nvim/eval/typval.c
@@ -56,6 +56,8 @@ static const char e_list_required_for_argument_nr[]
   = N_("E1211: List required for argument %d");
 static const char e_bool_required_for_argument_nr[]
   = N_("E1212: Bool required for argument %d");
+static const char e_float_or_number_required_for_argument_nr[]
+  = N_("E1219: Float or Number required for argument %d");
 static const char e_string_or_number_required_for_argument_nr[]
   = N_("E1220: String or Number required for argument %d");
 static const char e_string_or_list_required_for_argument_nr[]
@@ -4171,7 +4173,7 @@ int tv_check_for_float_or_nr_arg(const typval_T *const args, const int idx)
   FUNC_ATTR_NONNULL_ALL FUNC_ATTR_WARN_UNUSED_RESULT FUNC_ATTR_PURE
 {
   if (args[idx].v_type != VAR_FLOAT && args[idx].v_type != VAR_NUMBER) {
-    semsg(_(e_number_required_for_argument_nr), idx + 1);
+    semsg(_(e_float_or_number_required_for_argument_nr), idx + 1);
     return FAIL;
   }
   return OK;
diff --git a/src/nvim/testing.c b/src/nvim/testing.c
index 867a8ffd3a..430d6713ff 100644
--- a/src/nvim/testing.c
+++ b/src/nvim/testing.c
@@ -30,6 +30,16 @@
 #include "nvim/types.h"
 #include "nvim/vim.h"
 
+/// Type of assert_* check being performed
+typedef enum {
+  ASSERT_EQUAL,
+  ASSERT_NOTEQUAL,
+  ASSERT_MATCH,
+  ASSERT_NOTMATCH,
+  ASSERT_FAILS,
+  ASSERT_OTHER,
+} assert_type_T;
+
 #ifdef INCLUDE_GENERATED_DECLARATIONS
 # include "testing.c.generated.h"
 #endif
@@ -142,7 +152,7 @@ static void ga_concat_shorten_esc(garray_T *gap, const char *str)
 }
 
 /// Fill "gap" with information about an assert error.
-static void fill_assert_error(garray_T *gap, typval_T *opt_msg_tv, char *exp_str,
+static void fill_assert_error(garray_T *gap, typval_T *opt_msg_tv, const char *exp_str,
                               typval_T *exp_tv_arg, typval_T *got_tv_arg, assert_type_T atype)
 {
   char *tofree;
@@ -220,7 +230,13 @@ static void fill_assert_error(garray_T *gap, typval_T *opt_msg_tv, char *exp_str
     ga_concat_shorten_esc(gap, tofree);
     xfree(tofree);
   } else {
+    if (atype == ASSERT_FAILS) {
+      ga_concat(gap, "'");
+    }
     ga_concat_shorten_esc(gap, exp_str);
+    if (atype == ASSERT_FAILS) {
+      ga_concat(gap, "'");
+    }
   }
 
   if (atype != ASSERT_NOTEQUAL) {
@@ -504,6 +520,7 @@ void f_assert_fails(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
   const int save_trylevel = trylevel;
   const int called_emsg_before = called_emsg;
   const char *wrong_arg_msg = NULL;
+  char *tofree = NULL;
 
   if (tv_check_for_string_or_number_arg(argvars, 0) == FAIL
       || tv_check_for_opt_string_or_list_arg(argvars, 1) == FAIL
@@ -515,15 +532,19 @@ void f_assert_fails(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
     return;
   }
 
-  const char *const cmd = tv_get_string_chk(&argvars[0]);
-
   // trylevel must be zero for a ":throw" command to be considered failed
   trylevel = 0;
   suppress_errthrow = true;
   in_assert_fails = true;
   no_wait_return++;
 
+  const char *const cmd = tv_get_string_chk(&argvars[0]);
   do_cmdline_cmd(cmd);
+
+  // reset here for any errors reported below
+  trylevel = save_trylevel;
+  suppress_errthrow = false;
+
   if (called_emsg == called_emsg_before) {
     prepare_assert_error(&ga);
     ga_concat(&ga, "command did not fail: ");
@@ -534,6 +555,7 @@ void f_assert_fails(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
   } else if (argvars[1].v_type != VAR_UNKNOWN) {
     char buf[NUMBUFLEN];
     const char *expected;
+    const char *expected_str = NULL;
     bool error_found = false;
     int error_found_index = 1;
     char *actual = emsg_assert_fails_msg == NULL ? "[unknown]" : emsg_assert_fails_msg;
@@ -549,14 +571,23 @@ void f_assert_fails(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
       }
       const typval_T *tv = TV_LIST_ITEM_TV(tv_list_first(list));
       expected = tv_get_string_buf_chk(tv, buf);
+      if (expected == NULL) {
+        goto theend;
+      }
       if (!pattern_match(expected, actual, false)) {
         error_found = true;
+        expected_str = expected;
       } else if (tv_list_len(list) == 2) {
+        // make a copy, an error in pattern_match() may free it
+        tofree = actual = xstrdup(get_vim_var_str(VV_ERRMSG));
         tv = TV_LIST_ITEM_TV(tv_list_last(list));
-        actual = get_vim_var_str(VV_ERRMSG);
         expected = tv_get_string_buf_chk(tv, buf);
+        if (expected == NULL) {
+          goto theend;
+        }
         if (!pattern_match(expected, actual, false)) {
           error_found = true;
+          expected_str = expected;
         }
       }
     } else {
@@ -600,8 +631,8 @@ void f_assert_fails(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
         actual_tv.v_type = VAR_STRING;
         actual_tv.vval.v_string = actual;
       }
-      fill_assert_error(&ga, &argvars[2], NULL,
-                        &argvars[error_found_index], &actual_tv, ASSERT_OTHER);
+      fill_assert_error(&ga, &argvars[2], expected_str,
+                        &argvars[error_found_index], &actual_tv, ASSERT_FAILS);
       ga_concat(&ga, ": ");
       assert_append_cmd_or_arg(&ga, argvars, cmd);
       assert_error(&ga);
@@ -623,6 +654,7 @@ theend:
   msg_reset_scroll();
   lines_left = Rows;
   XFREE_CLEAR(emsg_assert_fails_msg);
+  xfree(tofree);
   set_vim_var_string(VV_ERRMSG, NULL, 0);
   if (wrong_arg_msg != NULL) {
     emsg(_(wrong_arg_msg));
@@ -650,16 +682,9 @@ static int assert_inrange(typval_T *argvars)
     if (factual < flower || factual > fupper) {
       garray_T ga;
       prepare_assert_error(&ga);
-      if (argvars[3].v_type != VAR_UNKNOWN) {
-        char *const tofree = encode_tv2string(&argvars[3], NULL);
-        ga_concat(&ga, tofree);
-        xfree(tofree);
-      } else {
-        char msg[80];
-        vim_snprintf(msg, sizeof(msg), "Expected range %g - %g, but got %g",
-                     flower, fupper, factual);
-        ga_concat(&ga, msg);
-      }
+      char expected_str[200];
+      vim_snprintf(expected_str, sizeof(expected_str), "range %g - %g,", flower, fupper);
+      fill_assert_error(&ga, &argvars[3], expected_str, NULL, &argvars[2], ASSERT_OTHER);
       assert_error(&ga);
       ga_clear(&ga);
       return 1;
@@ -675,13 +700,11 @@ static int assert_inrange(typval_T *argvars)
     if (actual < lower || actual > upper) {
       garray_T ga;
       prepare_assert_error(&ga);
-
-      char msg[55];
-      vim_snprintf(msg, sizeof(msg),
+      char expected_str[200];
+      vim_snprintf(expected_str, sizeof(expected_str),
                    "range %" PRIdVARNUMBER " - %" PRIdVARNUMBER ",",
                    lower, upper);  // -V576
-      fill_assert_error(&ga, &argvars[3], msg, NULL, &argvars[2],
-                        ASSERT_INRANGE);
+      fill_assert_error(&ga, &argvars[3], expected_str, NULL, &argvars[2], ASSERT_OTHER);
       assert_error(&ga);
       ga_clear(&ga);
       return 1;
diff --git a/test/old/testdir/test_assert.vim b/test/old/testdir/test_assert.vim
index 62b2e5d7ab..57d11d0e3a 100644
--- a/test/old/testdir/test_assert.vim
+++ b/test/old/testdir/test_assert.vim
@@ -1,5 +1,8 @@
 " Test that the methods used for testing work.
 
+source check.vim
+source term_util.vim
+
 func Test_assert_false()
   call assert_equal(0, assert_false(0))
   call assert_equal(0, assert_false(v:false))
@@ -228,11 +231,11 @@ func Test_assert_fail_fails()
   call remove(v:errors, 0)
 
   call assert_equal(1, assert_fails('xxx', ['E9876']))
-  call assert_match("Expected \\['E9876'\\] but got 'E492:", v:errors[0])
+  call assert_match("Expected 'E9876' but got 'E492:", v:errors[0])
   call remove(v:errors, 0)
 
   call assert_equal(1, assert_fails('xxx', ['E492:', 'E9876']))
-  call assert_match("Expected \\['E492:', 'E9876'\\] but got 'E492:", v:errors[0])
+  call assert_match("Expected 'E9876' but got 'E492:", v:errors[0])
   call remove(v:errors, 0)
 
   call assert_equal(1, assert_fails('echo', '', 'echo command'))
@@ -258,6 +261,20 @@ func Test_assert_fail_fails()
   call assert_match("E856: \"assert_fails()\" second argument", exp)
 
   try
+    call assert_equal(1, assert_fails('xxx', v:_null_list))
+  catch
+    let exp = v:exception
+  endtry
+  call assert_match("E856: \"assert_fails()\" second argument", exp)
+
+  try
+    call assert_equal(1, assert_fails('xxx', []))
+  catch
+    let exp = v:exception
+  endtry
+  call assert_match("E856: \"assert_fails()\" second argument", exp)
+
+  try
     call assert_equal(1, assert_fails('xxx', #{one: 1}))
   catch
     let exp = v:exception
@@ -265,6 +282,21 @@ func Test_assert_fail_fails()
   call assert_match("E1222: String or List required for argument 2", exp)
 
   try
+    call assert_equal(0, assert_fails('xxx', [#{one: 1}]))
+  catch
+    let exp = v:exception
+  endtry
+  call assert_match("E731: Using a Dictionary as a String", exp)
+
+  let exp = ''
+  try
+    call assert_equal(0, assert_fails('xxx', ['E492', #{one: 1}]))
+  catch
+    let exp = v:exception
+  endtry
+  call assert_match("E731: Using a Dictionary as a String", exp)
+
+  try
     call assert_equal(1, assert_fails('xxx', 'E492', '', 'burp'))
   catch
     let exp = v:exception
@@ -277,6 +309,19 @@ func Test_assert_fail_fails()
     let exp = v:exception
   endtry
   call assert_match("E1174: String required for argument 5", exp)
+
+  call assert_equal(1, assert_fails('c0', ['', '\(.\)\1']))
+  call assert_match("Expected '\\\\\\\\(.\\\\\\\\)\\\\\\\\1' but got 'E939: Positive count required: c0': c0", v:errors[0])
+  call remove(v:errors, 0)
+
+  " Test for matching the line number and the script name in an error message
+  call writefile(['', 'call Xnonexisting()'], 'Xassertfails.vim', 'D')
+  call assert_fails('source Xassertfails.vim', 'E117:', '', 10)
+  call assert_match("Expected 10 but got 2", v:errors[0])
+  call remove(v:errors, 0)
+  call assert_fails('source Xassertfails.vim', 'E117:', '', 2, 'Xabc')
+  call assert_match("Expected 'Xabc' but got .*Xassertfails.vim", v:errors[0])
+  call remove(v:errors, 0)
 endfunc
 
 func Test_assert_fails_in_try_block()
@@ -285,6 +330,23 @@ func Test_assert_fails_in_try_block()
   endtry
 endfunc
 
+" Test that assert_fails() in a timer does not cause a hit-enter prompt.
+" Requires using a terminal, in regular tests the hit-enter prompt won't be
+" triggered.
+func Test_assert_fails_in_timer()
+  CheckRunVimInTerminal
+
+  let buf = RunVimInTerminal('', {'rows': 6})
+  let cmd = ":call timer_start(0, {-> assert_fails('call', 'E471:')})"
+  call term_sendkeys(buf, cmd)
+  call WaitForAssert({-> assert_equal(cmd, term_getline(buf, 6))})
+  call term_sendkeys(buf, "\<CR>")
+  call TermWait(buf, 100)
+  call assert_match('E471: Argument required', term_getline(buf, 6))
+
+  call StopVimInTerminal(buf)
+endfunc
+
 func Test_assert_beeps()
   new
   call assert_equal(0, assert_beeps('normal h'))
@@ -301,6 +363,12 @@ func Test_assert_beeps()
   bwipe
 endfunc
 
+func Test_assert_nobeep()
+  call assert_equal(1, assert_nobeep('normal! cr'))
+  call assert_match("command did beep: normal! cr", v:errors[0])
+  call remove(v:errors, 0)
+endfunc
+
 func Test_assert_inrange()
   call assert_equal(0, assert_inrange(7, 7, 7))
   call assert_equal(0, assert_inrange(5, 7, 5))
@@ -322,21 +390,32 @@ func Test_assert_inrange()
 
   call assert_fails('call assert_inrange(1, 1)', 'E119:')
 
-  if has('float')
-    call assert_equal(0, assert_inrange(7.0, 7, 7))
-    call assert_equal(0, assert_inrange(7, 7.0, 7))
-    call assert_equal(0, assert_inrange(7, 7, 7.0))
-    call assert_equal(0, assert_inrange(5, 7, 5.0))
-    call assert_equal(0, assert_inrange(5, 7, 6.0))
-    call assert_equal(0, assert_inrange(5, 7, 7.0))
-
-    call assert_equal(1, assert_inrange(5, 7, 4.0))
-    call assert_match("Expected range 5.0 - 7.0, but got 4.0", v:errors[0])
-    call remove(v:errors, 0)
-    call assert_equal(1, assert_inrange(5, 7, 8.0))
-    call assert_match("Expected range 5.0 - 7.0, but got 8.0", v:errors[0])
-    call remove(v:errors, 0)
-  endif
+  call assert_equal(0, assert_inrange(7.0, 7, 7))
+  call assert_equal(0, assert_inrange(7, 7.0, 7))
+  call assert_equal(0, assert_inrange(7, 7, 7.0))
+  call assert_equal(0, assert_inrange(5, 7, 5.0))
+  call assert_equal(0, assert_inrange(5, 7, 6.0))
+  call assert_equal(0, assert_inrange(5, 7, 7.0))
+
+  call assert_equal(1, assert_inrange(5, 7, 4.0))
+  call assert_match("Expected range 5.0 - 7.0, but got 4.0", v:errors[0])
+  call remove(v:errors, 0)
+  call assert_equal(1, assert_inrange(5, 7, 8.0))
+  call assert_match("Expected range 5.0 - 7.0, but got 8.0", v:errors[0])
+  call remove(v:errors, 0)
+
+  " Use a custom message
+  call assert_equal(1, assert_inrange(5, 7, 8, "Higher"))
+  call assert_match("Higher: Expected range 5 - 7, but got 8", v:errors[0])
+  call remove(v:errors, 0)
+  call assert_equal(1, assert_inrange(5, 7, 8.0, "Higher"))
+  call assert_match("Higher: Expected range 5.0 - 7.0, but got 8.0", v:errors[0])
+  call remove(v:errors, 0)
+
+  " Invalid arguments
+  call assert_fails("call assert_inrange([], 2, 3)", 'E1219:')
+  call assert_fails("call assert_inrange(1, [], 3)", 'E1219:')
+  call assert_fails("call assert_inrange(1, 2, [])", 'E1219:')
 endfunc
 
 func Test_assert_with_msg()
@@ -374,6 +453,21 @@ func Test_mouse_position()
   let &mouse = save_mouse
 endfunc
 
+" Test for the test_alloc_fail() function
+func Test_test_alloc_fail()
+  throw 'Skipped: Nvim does not support test_alloc_fail()'
+  call assert_fails('call test_alloc_fail([], 1, 1)', 'E474:')
+  call assert_fails('call test_alloc_fail(10, [], 1)', 'E474:')
+  call assert_fails('call test_alloc_fail(10, 1, [])', 'E474:')
+  call assert_fails('call test_alloc_fail(999999, 1, 1)', 'E474:')
+endfunc
+
+" Test for the test_option_not_set() function
+func Test_test_option_not_set()
+  throw 'Skipped: Nvim does not support test_option_not_set()'
+  call assert_fails('call test_option_not_set("Xinvalidopt")', 'E475:')
+endfunc
+
 " Must be last.
 func Test_zz_quit_detected()
   " Verify that if a test function ends Vim the test script detects this.
diff --git a/test/old/testdir/test_options.vim b/test/old/testdir/test_options.vim
index 8fc86a99e3..cf8bf1903f 100644
--- a/test/old/testdir/test_options.vim
+++ b/test/old/testdir/test_options.vim
@@ -894,8 +894,6 @@ endfunc
 func Test_shortmess_F2()
   e file1
   e file2
-  " Accommodate Nvim default.
-  set shortmess-=F
   call assert_match('file1', execute('bn', ''))
   call assert_match('file2', execute('bn', ''))
   set shortmess+=F
@@ -913,12 +911,12 @@ func Test_shortmess_F2()
   " call assert_false(test_getvalue('need_fileinfo'))
   call assert_true(empty(execute('bn', '')))
   " call assert_false(test_getvalue('need_fileinfo'))
-  " Accommodate Nvim default.
-  set shortmess-=F
+  set shortmess-=F  " Accommodate Nvim default.
   call assert_match('file1', execute('bn', ''))
   call assert_match('file2', execute('bn', ''))
   bwipe
   bwipe
+  " call assert_fails('call test_getvalue("abc")', 'E475:')
 endfunc
 
 func Test_local_scrolloff()
diff --git a/test/old/testdir/test_vimscript.vim b/test/old/testdir/test_vimscript.vim
index 1c5310e883..c8085cc396 100644
--- a/test/old/testdir/test_vimscript.vim
+++ b/test/old/testdir/test_vimscript.vim
@@ -7035,6 +7035,122 @@ func Test_unlet_env()
     call assert_equal('', $TESTVAR)
 endfunc
 
+func Test_refcount()
+    throw 'Skipped: Nvim does not support test_refcount()'
+    " Immediate values
+    call assert_equal(-1, test_refcount(1))
+    call assert_equal(-1, test_refcount('s'))
+    call assert_equal(-1, test_refcount(v:true))
+    call assert_equal(0, test_refcount([]))
+    call assert_equal(0, test_refcount({}))
+    call assert_equal(0, test_refcount(0zff))
+    call assert_equal(0, test_refcount({-> line('.')}))
+    call assert_equal(-1, test_refcount(0.1))
+    if has('job')
+        call assert_equal(0, test_refcount(job_start([&shell, &shellcmdflag, 'echo .'])))
+    endif
+
+    " No refcount types
+    let x = 1
+    call assert_equal(-1, test_refcount(x))
+    let x = 's'
+    call assert_equal(-1, test_refcount(x))
+    let x = v:true
+    call assert_equal(-1, test_refcount(x))
+    let x = 0.1
+    call assert_equal(-1, test_refcount(x))
+
+    " Check refcount
+    let x = []
+    call assert_equal(1, test_refcount(x))
+
+    let x = {}
+    call assert_equal(1, x->test_refcount())
+
+    let x = 0zff
+    call assert_equal(1, test_refcount(x))
+
+    let X = {-> line('.')}
+    call assert_equal(1, test_refcount(X))
+    let Y = X
+    call assert_equal(2, test_refcount(X))
+
+    if has('job')
+        let job = job_start([&shell, &shellcmdflag, 'echo .'])
+        call assert_equal(1, test_refcount(job))
+        call assert_equal(1, test_refcount(job_getchannel(job)))
+        call assert_equal(1, test_refcount(job))
+    endif
+
+    " Function arguments, copying and unassigning
+    func ExprCheck(x, i)
+        let i = a:i + 1
+        call assert_equal(i, test_refcount(a:x))
+        let Y = a:x
+        call assert_equal(i + 1, test_refcount(a:x))
+        call assert_equal(test_refcount(a:x), test_refcount(Y))
+        let Y = 0
+        call assert_equal(i, test_refcount(a:x))
+    endfunc
+    call ExprCheck([], 0)
+    call ExprCheck({}, 0)
+    call ExprCheck(0zff, 0)
+    call ExprCheck({-> line('.')}, 0)
+    if has('job')
+	call ExprCheck(job, 1)
+	call ExprCheck(job_getchannel(job), 1)
+	call job_stop(job)
+    endif
+    delfunc ExprCheck
+
+    " Regarding function
+    func Func(x) abort
+        call assert_equal(2, test_refcount(function('Func')))
+        call assert_equal(0, test_refcount(funcref('Func')))
+    endfunc
+    call assert_equal(1, test_refcount(function('Func')))
+    call assert_equal(0, test_refcount(function('Func', [1])))
+    call assert_equal(0, test_refcount(funcref('Func')))
+    call assert_equal(0, test_refcount(funcref('Func', [1])))
+    let X = function('Func')
+    let Y = X
+    call assert_equal(1, test_refcount(X))
+    let X = function('Func', [1])
+    let Y = X
+    call assert_equal(2, test_refcount(X))
+    let X = funcref('Func')
+    let Y = X
+    call assert_equal(2, test_refcount(X))
+    let X = funcref('Func', [1])
+    let Y = X
+    call assert_equal(2, test_refcount(X))
+    unlet X
+    unlet Y
+    call Func(1)
+    delfunc Func
+
+    " Function with dict
+    func DictFunc() dict
+        call assert_equal(3, test_refcount(self))
+    endfunc
+    let d = {'Func': function('DictFunc')}
+    call assert_equal(1, test_refcount(d))
+    call assert_equal(0, test_refcount(d.Func))
+    call d.Func()
+    unlet d
+    delfunc DictFunc
+
+    if has('channel')
+      call assert_equal(-1, test_refcount(test_null_job()))
+      call assert_equal(-1, test_refcount(test_null_channel()))
+    endif
+    call assert_equal(-1, test_refcount(test_null_function()))
+    call assert_equal(-1, test_refcount(test_null_partial()))
+    call assert_equal(-1, test_refcount(test_null_blob()))
+    call assert_equal(-1, test_refcount(test_null_list()))
+    call assert_equal(-1, test_refcount(test_null_dict()))
+endfunc
+
 " Test for missing :endif, :endfor, :endwhile and :endtry           {{{1
 func Test_missing_end()
   call writefile(['if 2 > 1', 'echo ">"'], 'Xscript')