diff --git a/src/eval.c b/src/eval.c
index cfeba2e..63f8bde 100644
--- a/src/eval.c
+++ b/src/eval.c
@@ -8815,7 +8815,7 @@
     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;
@@ -8828,10 +8828,12 @@
 								       atype);
 	assert_error(&ga);
 	ga_clear(&ga);
+	return 1;
     }
+    return 0;
 }
 
-    void
+    int
 assert_equalfile(typval_T *argvars)
 {
     char_u	buf1[NUMBUFLEN];
@@ -8843,7 +8845,7 @@
     FILE	*fd2;
 
     if (fname1 == NULL || fname2 == NULL)
-	return;
+	return 0;
 
     IObuff[0] = NUL;
     fd1 = mch_fopen((char *)fname1, READBIN);
@@ -8897,10 +8899,12 @@
 	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;
@@ -8918,10 +8922,12 @@
 									atype);
 	assert_error(&ga);
 	ga_clear(&ga);
+	return 1;
     }
+    return 0;
 }
 
-    void
+    int
 assert_inrange(typval_T *argvars)
 {
     garray_T	ga;
@@ -8934,7 +8940,7 @@
     char_u	numbuf[NUMBUFLEN];
 
     if (error)
-	return;
+	return 0;
     if (actual < lower || actual > upper)
     {
 	prepare_assert_error(&ga);
@@ -8951,13 +8957,16 @@
 	}
 	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;
@@ -8965,7 +8974,7 @@
 
     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)
@@ -8976,10 +8985,12 @@
 		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;
@@ -8988,9 +8999,10 @@
     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;
@@ -9002,6 +9014,7 @@
 	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)
@@ -9011,14 +9024,17 @@
 				  &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;
@@ -9031,17 +9047,20 @@
 	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;
@@ -9054,6 +9073,7 @@
 	ga_concat(&ga, cmd);
 	assert_error(&ga);
 	ga_clear(&ga);
+	ret = 1;
     }
     else if (argvars[1].v_type != VAR_UNKNOWN)
     {
@@ -9068,6 +9088,7 @@
 				     &vimvars[VV_ERRMSG].vv_tv, ASSERT_OTHER);
 	    assert_error(&ga);
 	    ga_clear(&ga);
+	ret = 1;
 	}
     }
 
@@ -9076,6 +9097,7 @@
     emsg_silent = FALSE;
     emsg_on_display = FALSE;
     set_vim_var_string(VV_ERRMSG, NULL, 0);
+    return ret;
 }
 
 /*
diff --git a/src/evalfunc.c b/src/evalfunc.c
index dd4462d..ae1425e 100644
--- a/src/evalfunc.c
+++ b/src/evalfunc.c
@@ -1300,108 +1300,108 @@
  * "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
diff --git a/src/proto/eval.pro b/src/proto/eval.pro
index 6f16ce0..3bbe815 100644
--- a/src/proto/eval.pro
+++ b/src/proto/eval.pro
@@ -121,15 +121,15 @@
 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);
diff --git a/src/testdir/test_assert.vim b/src/testdir/test_assert.vim
index 0de6ceb..6114728 100644
--- a/src/testdir/test_assert.vim
+++ b/src/testdir/test_assert.vim
@@ -1,58 +1,66 @@
 " 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)
 
@@ -62,17 +70,17 @@
 
 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
@@ -81,7 +89,7 @@
   try
     nocommand
   catch
-    call assert_exception('E492:')
+    call assert_equal(0, assert_exception('E492:'))
   endtry
 
   try
@@ -89,9 +97,9 @@
   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
@@ -113,59 +121,59 @@
   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)
 
diff --git a/src/version.c b/src/version.c
index 0a36b66..a824e8d 100644
--- a/src/version.c
+++ b/src/version.c
@@ -762,6 +762,8 @@
 static int included_patches[] =
 {   /* Add new patch number below this line */
 /**/
+    1770,
+/**/
     1769,
 /**/
     1768,