Problem: Assert functions don't return anything.
Solution: Return non-zero when the assertion fails.
-*eval.txt* For Vim version 8.0. Last change: 2018 Apr 20
+*eval.txt* For Vim version 8.0. Last change: 2018 Apr 28
VIM REFERENCE MANUAL by Bram Moolenaar
: ... handle error
< "errmsg" also works, for backwards compatibility.
- *v:errors* *errors-variable*
+ *v:errors* *errors-variable* *assert-return*
v:errors Errors found by assert functions, such as |assert_true()|.
This is a list of strings.
The assert functions append an item when an assert fails.
+ The return value indicates this: a one is returned if an item
+ was added to v:errors, otherwise zero is returned.
To remove old results make it empty: >
:let v:errors = []
< If v:errors is set to anything but a list it is made an empty
arglistid([{winnr} [, {tabnr}]]) Number argument list id
argv({nr}) String {nr} entry of the argument list
argv() List the argument list
-assert_beeps({cmd}) none assert {cmd} causes a beep
+assert_beeps({cmd}) Number assert {cmd} causes a beep
assert_equal({exp}, {act} [, {msg}])
- none assert {exp} is equal to {act}
+ Number assert {exp} is equal to {act}
assert_equalfile({fname-one}, {fname-two})
- none assert file contents is equal
+ Number assert file contents is equal
assert_exception({error} [, {msg}])
- none assert {error} is in v:exception
-assert_fails({cmd} [, {error}]) none assert {cmd} fails
+ Number assert {error} is in v:exception
+assert_fails({cmd} [, {error}]) Number assert {cmd} fails
assert_false({actual} [, {msg}])
- none assert {actual} is false
+ Number assert {actual} is false
assert_inrange({lower}, {upper}, {actual} [, {msg}])
- none assert {actual} is inside the range
+ Number assert {actual} is inside the range
assert_match({pat}, {text} [, {msg}])
- none assert {pat} matches {text}
+ Number assert {pat} matches {text}
assert_notequal({exp}, {act} [, {msg}])
- none assert {exp} is not equal {act}
+ Number assert {exp} is not equal {act}
assert_notmatch({pat}, {text} [, {msg}])
- none assert {pat} not matches {text}
-assert_report({msg}) none report a test failure
-assert_true({actual} [, {msg}]) none assert {actual} is true
+ Number assert {pat} not matches {text}
+assert_report({msg}) Number report a test failure
+assert_true({actual} [, {msg}]) Number assert {actual} is true
asin({expr}) Float arc sine of {expr}
atan({expr}) Float arc tangent of {expr}
atan2({expr1}, {expr2}) Float arc tangent of {expr1} / {expr2}
assert_beeps({cmd}) *assert_beeps()*
Run {cmd} and add an error message to |v:errors| if it does
NOT produce a beep or visual bell.
- Also see |assert_fails()|.
+ Also see |assert_fails()| and |assert-return|.
*assert_equal()*
assert_equal({expected}, {actual} [, {msg}])
When {expected} and {actual} are not equal an error message is
- added to |v:errors|.
+ added to |v:errors| and 1 is returned. Otherwise zero is
+ returned |assert-return|.
There is no automatic conversion, the String "4" is different
from the Number 4. And the number 4 is different from the
Float 4.0. The value of 'ignorecase' is not used here, case
assert_equalfile({fname-one}, {fname-two})
When the files {fname-one} and {fname-two} do not contain
exactly the same text an error message is added to |v:errors|.
+ Also see |assert-return|.
When {fname-one} or {fname-two} does not exist the error will
mention that.
Mainly useful with |terminal-diff|.
assert_exception({error} [, {msg}]) *assert_exception()*
When v:exception does not contain the string {error} an error
- message is added to |v:errors|.
+ message is added to |v:errors|. Also see |assert-return|.
This can be used to assert that a command throws an exception.
Using the error number, followed by a colon, avoids problems
with translations: >
assert_fails({cmd} [, {error}]) *assert_fails()*
Run {cmd} and add an error message to |v:errors| if it does
- NOT produce an error.
+ NOT produce an error. Also see |assert-return|.
When {error} is given it must match in |v:errmsg|.
Note that beeping is not considered an error, and some failing
commands only beep. Use |assert_beeps()| for those.
assert_false({actual} [, {msg}]) *assert_false()*
When {actual} is not false an error message is added to
- |v:errors|, like with |assert_equal()|.
+ |v:errors|, like with |assert_equal()|.
+ Also see |assert-return|.
A value is false when it is zero. When {actual} is not a
number the assert fails.
When {msg} is omitted an error in the form
assert_inrange({lower}, {upper}, {actual} [, {msg}]) *assert_inrange()*
This asserts number values. When {actual} is lower than
{lower} or higher than {upper} an error message is added to
- |v:errors|.
+ |v:errors|. Also see |assert-return|.
When {msg} is omitted an error in the form
"Expected range {lower} - {upper}, but got {actual}" is
produced.
*assert_match()*
assert_match({pattern}, {actual} [, {msg}])
When {pattern} does not match {actual} an error message is
- added to |v:errors|.
+ added to |v:errors|. Also see |assert-return|.
{pattern} is used as with |=~|: The matching is always done
like 'magic' was set and 'cpoptions' is empty, no matter what
assert_notequal({expected}, {actual} [, {msg}])
The opposite of `assert_equal()`: add an error message to
|v:errors| when {expected} and {actual} are equal.
+ Also see |assert-return|.
*assert_notmatch()*
assert_notmatch({pattern}, {actual} [, {msg}])
The opposite of `assert_match()`: add an error message to
|v:errors| when {pattern} matches {actual}.
+ Also see |assert-return|.
assert_report({msg}) *assert_report()*
Report a test failure directly, using {msg}.
+ Always returns one.
assert_true({actual} [, {msg}]) *assert_true()*
When {actual} is not true an error message is added to
|v:errors|, like with |assert_equal()|.
+ Also see |assert-return|.
A value is TRUE when it is a non-zero number. When {actual}
is not a number the assert fails.
When {msg} is omitted an error in the form "Expected True but
<
{only available when compiled with the |+job| feature}
-job_info({job}) *job_info()*
+job_info([{job}]) *job_info()*
Returns a Dictionary with information about {job}:
"status" what |job_status()| returns
"channel" what |job_getchannel()| returns
+ "cmd" List of command arguments used to start the job
"process" process ID
"tty_in" terminal input name, empty when none
"tty_out" terminal output name, empty when none
"exit_cb" function to be called on exit
"stoponexit" |job-stoponexit|
+ Without any arguments, returns a List with all Job objects.
+
job_setoptions({job}, {options}) *job_setoptions()*
Change options for {job}. Supported are:
"stoponexit" |job-stoponexit|
list_append_string(vimvars[VV_ERRORS].vv_list, gap->ga_data, gap->ga_len);
}
- void
+ int
assert_equal_common(typval_T *argvars, assert_type_T atype)
{
garray_T ga;
atype);
assert_error(&ga);
ga_clear(&ga);
+ return 1;
}
+ return 0;
}
- void
+ int
assert_equalfile(typval_T *argvars)
{
char_u buf1[NUMBUFLEN];
FILE *fd2;
if (fname1 == NULL || fname2 == NULL)
- return;
+ return 0;
IObuff[0] = NUL;
fd1 = mch_fopen((char *)fname1, READBIN);
ga_concat(&ga, IObuff);
assert_error(&ga);
ga_clear(&ga);
+ return 1;
}
+ return 0;
}
- void
+ int
assert_match_common(typval_T *argvars, assert_type_T atype)
{
garray_T ga;
atype);
assert_error(&ga);
ga_clear(&ga);
+ return 1;
}
+ return 0;
}
- void
+ int
assert_inrange(typval_T *argvars)
{
garray_T ga;
char_u numbuf[NUMBUFLEN];
if (error)
- return;
+ return 0;
if (actual < lower || actual > upper)
{
prepare_assert_error(&ga);
}
assert_error(&ga);
ga_clear(&ga);
+ return 1;
}
+ return 0;
}
/*
* Common for assert_true() and assert_false().
+ * Return non-zero for failure.
*/
- void
+ int
assert_bool(typval_T *argvars, int isTrue)
{
int error = FALSE;
if (argvars[0].v_type == VAR_SPECIAL
&& argvars[0].vval.v_number == (isTrue ? VVAL_TRUE : VVAL_FALSE))
- return;
+ return 0;
if (argvars[0].v_type != VAR_NUMBER
|| (get_tv_number_chk(&argvars[0], &error) == 0) == isTrue
|| error)
NULL, &argvars[0], ASSERT_OTHER);
assert_error(&ga);
ga_clear(&ga);
+ return 1;
}
+ return 0;
}
- void
+ int
assert_report(typval_T *argvars)
{
garray_T ga;
ga_concat(&ga, get_tv_string(&argvars[0]));
assert_error(&ga);
ga_clear(&ga);
+ return 1;
}
- void
+ int
assert_exception(typval_T *argvars)
{
garray_T ga;
ga_concat(&ga, (char_u *)"v:exception is not set");
assert_error(&ga);
ga_clear(&ga);
+ return 1;
}
else if (error != NULL
&& strstr((char *)vimvars[VV_EXCEPTION].vv_str, (char *)error) == NULL)
&vimvars[VV_EXCEPTION].vv_tv, ASSERT_OTHER);
assert_error(&ga);
ga_clear(&ga);
+ return 1;
}
+ return 0;
}
- void
+ int
assert_beeps(typval_T *argvars)
{
char_u *cmd = get_tv_string_chk(&argvars[0]);
garray_T ga;
+ int ret = 0;
called_vim_beep = FALSE;
suppress_errthrow = TRUE;
ga_concat(&ga, cmd);
assert_error(&ga);
ga_clear(&ga);
+ ret = 1;
}
suppress_errthrow = FALSE;
emsg_on_display = FALSE;
+ return ret;
}
- void
+ int
assert_fails(typval_T *argvars)
{
char_u *cmd = get_tv_string_chk(&argvars[0]);
garray_T ga;
+ int ret = 0;
called_emsg = FALSE;
suppress_errthrow = TRUE;
ga_concat(&ga, cmd);
assert_error(&ga);
ga_clear(&ga);
+ ret = 1;
}
else if (argvars[1].v_type != VAR_UNKNOWN)
{
&vimvars[VV_ERRMSG].vv_tv, ASSERT_OTHER);
assert_error(&ga);
ga_clear(&ga);
+ ret = 1;
}
}
emsg_silent = FALSE;
emsg_on_display = FALSE;
set_vim_var_string(VV_ERRMSG, NULL, 0);
+ return ret;
}
/*
* "assert_beeps(cmd [, error])" function
*/
static void
-f_assert_beeps(typval_T *argvars, typval_T *rettv UNUSED)
+f_assert_beeps(typval_T *argvars, typval_T *rettv)
{
- assert_beeps(argvars);
+ rettv->vval.v_number = assert_beeps(argvars);
}
/*
* "assert_equal(expected, actual[, msg])" function
*/
static void
-f_assert_equal(typval_T *argvars, typval_T *rettv UNUSED)
+f_assert_equal(typval_T *argvars, typval_T *rettv)
{
- assert_equal_common(argvars, ASSERT_EQUAL);
+ rettv->vval.v_number = assert_equal_common(argvars, ASSERT_EQUAL);
}
/*
* "assert_equalfile(fname-one, fname-two)" function
*/
static void
-f_assert_equalfile(typval_T *argvars, typval_T *rettv UNUSED)
+f_assert_equalfile(typval_T *argvars, typval_T *rettv)
{
- assert_equalfile(argvars);
+ rettv->vval.v_number = assert_equalfile(argvars);
}
/*
* "assert_notequal(expected, actual[, msg])" function
*/
static void
-f_assert_notequal(typval_T *argvars, typval_T *rettv UNUSED)
+f_assert_notequal(typval_T *argvars, typval_T *rettv)
{
- assert_equal_common(argvars, ASSERT_NOTEQUAL);
+ rettv->vval.v_number = assert_equal_common(argvars, ASSERT_NOTEQUAL);
}
/*
* "assert_exception(string[, msg])" function
*/
static void
-f_assert_exception(typval_T *argvars, typval_T *rettv UNUSED)
+f_assert_exception(typval_T *argvars, typval_T *rettv)
{
- assert_exception(argvars);
+ rettv->vval.v_number = assert_exception(argvars);
}
/*
* "assert_fails(cmd [, error])" function
*/
static void
-f_assert_fails(typval_T *argvars, typval_T *rettv UNUSED)
+f_assert_fails(typval_T *argvars, typval_T *rettv)
{
- assert_fails(argvars);
+ rettv->vval.v_number = assert_fails(argvars);
}
/*
* "assert_false(actual[, msg])" function
*/
static void
-f_assert_false(typval_T *argvars, typval_T *rettv UNUSED)
+f_assert_false(typval_T *argvars, typval_T *rettv)
{
- assert_bool(argvars, FALSE);
+ rettv->vval.v_number = assert_bool(argvars, FALSE);
}
/*
* "assert_inrange(lower, upper[, msg])" function
*/
static void
-f_assert_inrange(typval_T *argvars, typval_T *rettv UNUSED)
+f_assert_inrange(typval_T *argvars, typval_T *rettv)
{
- assert_inrange(argvars);
+ rettv->vval.v_number = assert_inrange(argvars);
}
/*
* "assert_match(pattern, actual[, msg])" function
*/
static void
-f_assert_match(typval_T *argvars, typval_T *rettv UNUSED)
+f_assert_match(typval_T *argvars, typval_T *rettv)
{
- assert_match_common(argvars, ASSERT_MATCH);
+ rettv->vval.v_number = assert_match_common(argvars, ASSERT_MATCH);
}
/*
* "assert_notmatch(pattern, actual[, msg])" function
*/
static void
-f_assert_notmatch(typval_T *argvars, typval_T *rettv UNUSED)
+f_assert_notmatch(typval_T *argvars, typval_T *rettv)
{
- assert_match_common(argvars, ASSERT_NOTMATCH);
+ rettv->vval.v_number = assert_match_common(argvars, ASSERT_NOTMATCH);
}
/*
* "assert_report(msg)" function
*/
static void
-f_assert_report(typval_T *argvars, typval_T *rettv UNUSED)
+f_assert_report(typval_T *argvars, typval_T *rettv)
{
- assert_report(argvars);
+ rettv->vval.v_number = assert_report(argvars);
}
/*
* "assert_true(actual[, msg])" function
*/
static void
-f_assert_true(typval_T *argvars, typval_T *rettv UNUSED)
+f_assert_true(typval_T *argvars, typval_T *rettv)
{
- assert_bool(argvars, TRUE);
+ rettv->vval.v_number = assert_bool(argvars, TRUE);
}
#ifdef FEAT_FLOAT
void reset_v_option_vars(void);
void prepare_assert_error(garray_T *gap);
void assert_error(garray_T *gap);
-void assert_equal_common(typval_T *argvars, assert_type_T atype);
-void assert_equalfile(typval_T *argvars);
-void assert_match_common(typval_T *argvars, assert_type_T atype);
-void assert_inrange(typval_T *argvars);
-void assert_bool(typval_T *argvars, int isTrue);
-void assert_report(typval_T *argvars);
-void assert_exception(typval_T *argvars);
-void assert_beeps(typval_T *argvars);
-void assert_fails(typval_T *argvars);
+int assert_equal_common(typval_T *argvars, assert_type_T atype);
+int assert_equalfile(typval_T *argvars);
+int assert_match_common(typval_T *argvars, assert_type_T atype);
+int assert_inrange(typval_T *argvars);
+int assert_bool(typval_T *argvars, int isTrue);
+int assert_report(typval_T *argvars);
+int assert_exception(typval_T *argvars);
+int assert_beeps(typval_T *argvars);
+int assert_fails(typval_T *argvars);
void fill_assert_error(garray_T *gap, typval_T *opt_msg_tv, char_u *exp_str, typval_T *exp_tv, typval_T *got_tv, assert_type_T atype);
int typval_compare(typval_T *typ1, typval_T *typ2, exptype_T type, int type_is, int ic);
char_u *typval_tostring(typval_T *arg);
" Test that the methods used for testing work.
func Test_assert_false()
- call assert_false(0)
- call assert_false(v:false)
+ call assert_equal(0, assert_false(0))
+ call assert_equal(0, assert_false(v:false))
+
+ call assert_equal(1, assert_false(123))
+ call assert_match("Expected False but got 123", v:errors[0])
+ call remove(v:errors, 0)
endfunc
func Test_assert_true()
- call assert_true(1)
- call assert_true(123)
- call assert_true(v:true)
+ call assert_equal(0, assert_true(1))
+ call assert_equal(0, assert_true(123))
+ call assert_equal(0, assert_true(v:true))
+
+ call assert_equal(1, assert_true(0))
+ call assert_match("Expected True but got 0", v:errors[0])
+ call remove(v:errors, 0)
endfunc
func Test_assert_equal()
let s = 'foo'
- call assert_equal('foo', s)
+ call assert_equal(0, assert_equal('foo', s))
let n = 4
- call assert_equal(4, n)
+ call assert_equal(0, assert_equal(4, n))
let l = [1, 2, 3]
- call assert_equal([1, 2, 3], l)
+ call assert_equal(0, assert_equal([1, 2, 3], l))
let s = 'foo'
- call assert_equal('bar', s)
+ call assert_equal(1, assert_equal('bar', s))
call assert_match("Expected 'bar' but got 'foo'", v:errors[0])
call remove(v:errors, 0)
endfunc
func Test_assert_equalfile()
- call assert_equalfile('abcabc', 'xyzxyz')
+ call assert_equal(1, assert_equalfile('abcabc', 'xyzxyz'))
call assert_match("E485: Can't read file abcabc", v:errors[0])
call remove(v:errors, 0)
let goodtext = ["one", "two", "three"]
call writefile(goodtext, 'Xone')
- call assert_equalfile('Xone', 'xyzxyz')
+ call assert_equal(1, assert_equalfile('Xone', 'xyzxyz'))
call assert_match("E485: Can't read file xyzxyz", v:errors[0])
call remove(v:errors, 0)
call writefile(goodtext, 'Xtwo')
- call assert_equalfile('Xone', 'Xtwo')
+ call assert_equal(0, assert_equalfile('Xone', 'Xtwo'))
call writefile([goodtext[0]], 'Xone')
- call assert_equalfile('Xone', 'Xtwo')
+ call assert_equal(1, assert_equalfile('Xone', 'Xtwo'))
call assert_match("first file is shorter", v:errors[0])
call remove(v:errors, 0)
call writefile(goodtext, 'Xone')
call writefile([goodtext[0]], 'Xtwo')
- call assert_equalfile('Xone', 'Xtwo')
+ call assert_equal(1, assert_equalfile('Xone', 'Xtwo'))
call assert_match("second file is shorter", v:errors[0])
call remove(v:errors, 0)
call writefile(['1234X89'], 'Xone')
call writefile(['1234Y89'], 'Xtwo')
- call assert_equalfile('Xone', 'Xtwo')
+ call assert_equal(1, assert_equalfile('Xone', 'Xtwo'))
call assert_match("difference at byte 4", v:errors[0])
call remove(v:errors, 0)
func Test_assert_notequal()
let n = 4
- call assert_notequal('foo', n)
+ call assert_equal(0, assert_notequal('foo', n))
let s = 'foo'
- call assert_notequal([1, 2, 3], s)
+ call assert_equal(0, assert_notequal([1, 2, 3], s))
- call assert_notequal('foo', s)
+ call assert_equal(1, assert_notequal('foo', s))
call assert_match("Expected not equal to 'foo'", v:errors[0])
call remove(v:errors, 0)
endfunc
func Test_assert_report()
- call assert_report('something is wrong')
+ call assert_equal(1, assert_report('something is wrong'))
call assert_match('something is wrong', v:errors[0])
call remove(v:errors, 0)
endfunc
try
nocommand
catch
- call assert_exception('E492:')
+ call assert_equal(0, assert_exception('E492:'))
endtry
try
catch
try
" illegal argument, get NULL for error
- call assert_exception([])
+ call assert_equal(1, assert_exception([]))
catch
- call assert_exception('E730:')
+ call assert_equal(0, assert_exception('E730:'))
endtry
endtry
endfunc
try
call assert_equal(s:w, '')
catch
- call assert_exception('E724:')
+ call assert_equal(0, assert_exception('E724:'))
call assert_match("Expected NULL but got ''", v:errors[0])
call remove(v:errors, 0)
endtry
endfunc
func Test_match()
- call assert_match('^f.*b.*r$', 'foobar')
+ call assert_equal(0, assert_match('^f.*b.*r$', 'foobar'))
- call assert_match('bar.*foo', 'foobar')
+ call assert_equal(1, assert_match('bar.*foo', 'foobar'))
call assert_match("Pattern 'bar.*foo' does not match 'foobar'", v:errors[0])
call remove(v:errors, 0)
- call assert_match('bar.*foo', 'foobar', 'wrong')
+ call assert_equal(1, assert_match('bar.*foo', 'foobar', 'wrong'))
call assert_match('wrong', v:errors[0])
call remove(v:errors, 0)
endfunc
func Test_notmatch()
- call assert_notmatch('foo', 'bar')
- call assert_notmatch('^foobar$', 'foobars')
+ call assert_equal(0, assert_notmatch('foo', 'bar'))
+ call assert_equal(0, assert_notmatch('^foobar$', 'foobars'))
- call assert_notmatch('foo', 'foobar')
+ call assert_equal(1, assert_notmatch('foo', 'foobar'))
call assert_match("Pattern 'foo' does match 'foobar'", v:errors[0])
call remove(v:errors, 0)
endfunc
func Test_assert_fail_fails()
- call assert_fails('xxx', {})
+ call assert_equal(1, assert_fails('xxx', {}))
call assert_match("Expected {} but got 'E731:", v:errors[0])
call remove(v:errors, 0)
endfunc
func Test_assert_beeps()
new
- call assert_beeps('normal h')
+ call assert_equal(0, assert_beeps('normal h'))
- call assert_beeps('normal 0')
+ call assert_equal(1, assert_beeps('normal 0'))
call assert_match("command did not beep: normal 0", v:errors[0])
call remove(v:errors, 0)
bwipe
endfunc
func Test_assert_inrange()
- call assert_inrange(7, 7, 7)
- call assert_inrange(5, 7, 5)
- call assert_inrange(5, 7, 6)
- call assert_inrange(5, 7, 7)
+ call assert_equal(0, assert_inrange(7, 7, 7))
+ call assert_equal(0, assert_inrange(5, 7, 5))
+ call assert_equal(0, assert_inrange(5, 7, 6))
+ call assert_equal(0, assert_inrange(5, 7, 7))
- call assert_inrange(5, 7, 4)
+ call assert_equal(1, assert_inrange(5, 7, 4))
call assert_match("Expected range 5 - 7, but got 4", v:errors[0])
call remove(v:errors, 0)
- call assert_inrange(5, 7, 8)
+ call assert_equal(1, assert_inrange(5, 7, 8))
call assert_match("Expected range 5 - 7, but got 8", v:errors[0])
call remove(v:errors, 0)
static int included_patches[] =
{ /* Add new patch number below this line */
+/**/
+ 1770,
/**/
1769,
/**/
projects / vim / commitdiff