Tarantool development patches archive
 help / color / mirror / Atom feed
* [Tarantool-patches] [PATCH v2 00/10] test: lua-Harness suite patch bump
@ 2021-07-20 16:26 Maxim Kokryashkin via Tarantool-patches
  2021-07-20 16:26 ` [Tarantool-patches] [PATCH v2 01/10] test: port lua-Harness to Test.Assertion Maxim Kokryashkin via Tarantool-patches
                   ` (10 more replies)
  0 siblings, 11 replies; 22+ messages in thread
From: Maxim Kokryashkin via Tarantool-patches @ 2021-07-20 16:26 UTC (permalink / raw)
  To: tarantool-patches, imun, skaplun

As our experience has been considered by the maintainer of lua-Harness
and the issues we faced are finally fixed in mainline repo, we should
bump lua-Harness suite up to c4451fe0.

Part of tarantool/tarantool#5970
Part of tarantool/tarantool#4473

---
Changes in v2:
  - Fixed comments as per review by Igor Munkin <imun@tarantool.org>
  - Backported two more fixes from trunk
  - Disabled 241-standalone.t as it is facing some issues to run 
    properly on FreeBSD (for more information see
    tarantool/tarantool#6231)

Github branch: 
https://github.com/tarantool/luajit/tree/fckxorg/gh-5970-update-lua-harness

Issue:
https://github.com/tarantool/tarantool/issues/5970

Tests: passing


Maxim Kokryashkin (10):
  test: port lua-Harness to Test.Assertion
  test: rename lua-Harness tap to test_assertion
  test: use CI friendly variables in lua-Harness
  test: refactor with _retrieve_progname
  test: refactor with _dofile
  test: support tarantool in lua-Harness
  test: backport lua-Harness directory detection
  test: support tarantool cli in lua-Harness
  test: update lua-Harness to b7b1a9a2
  test: disable test/lua-Harness-tests/241-standalone.t on FreeBSD

 test/lua-Harness-tests/090-tap.t              |  10 +-
 test/lua-Harness-tests/091-profile.t          |  12 +-
 test/lua-Harness-tests/101-boolean.t          | 130 +--
 test/lua-Harness-tests/102-function.t         | 222 +++---
 test/lua-Harness-tests/103-nil.t              | 130 +--
 test/lua-Harness-tests/104-number.t           | 274 +++----
 test/lua-Harness-tests/105-string.t           | 312 ++++----
 test/lua-Harness-tests/106-table.t            | 136 ++--
 test/lua-Harness-tests/107-thread.t           | 132 +--
 test/lua-Harness-tests/108-userdata.t         | 128 +--
 test/lua-Harness-tests/200-examples.t         |  16 +-
 test/lua-Harness-tests/201-assign.t           |  84 +-
 test/lua-Harness-tests/202-expr.t             | 140 ++--
 test/lua-Harness-tests/203-lexico.t           |  78 +-
 test/lua-Harness-tests/204-grammar.t          |  78 +-
 test/lua-Harness-tests/211-scope.t            |  26 +-
 test/lua-Harness-tests/212-function.t         | 140 ++--
 test/lua-Harness-tests/213-closure.t          |  34 +-
 test/lua-Harness-tests/214-coroutine.t        |  98 +--
 test/lua-Harness-tests/221-table.t            |  56 +-
 test/lua-Harness-tests/222-constructor.t      |  36 +-
 test/lua-Harness-tests/223-iterator.t         |  20 +-
 test/lua-Harness-tests/231-metatable.t        | 236 +++---
 test/lua-Harness-tests/232-object.t           |  40 +-
 test/lua-Harness-tests/241-standalone.t       | 330 ++++++++
 .../241-standalone.t.disabled                 | 269 -------
 test/lua-Harness-tests/242-luac.t             |  88 +-
 test/lua-Harness-tests/301-basic.t            | 754 +++++++++---------
 test/lua-Harness-tests/303-package.t          | 125 +--
 test/lua-Harness-tests/304-string.t           | 650 +++++++--------
 test/lua-Harness-tests/305-utf8.t             |  10 +-
 test/lua-Harness-tests/306-table.t            | 188 ++---
 test/lua-Harness-tests/307-math.t             | 268 +++----
 test/lua-Harness-tests/308-io.t               | 252 +++---
 test/lua-Harness-tests/309-os.t               | 164 ++--
 test/lua-Harness-tests/310-debug.t            | 230 +++---
 test/lua-Harness-tests/311-bit32.t            |  72 +-
 test/lua-Harness-tests/314-regex.t            |  12 +-
 test/lua-Harness-tests/320-stdin.t            |  40 +-
 test/lua-Harness-tests/401-bitop.t            |  64 +-
 test/lua-Harness-tests/402-ffi.t              |  82 +-
 test/lua-Harness-tests/403-jit.t              | 100 +--
 test/lua-Harness-tests/404-ext.t              | 168 ++--
 test/lua-Harness-tests/411-luajit.t           | 211 +++++
 test/lua-Harness-tests/411-luajit.t.disabled  | 211 -----
 test/lua-Harness-tests/CMakeLists.txt         |   5 -
 test/lua-Harness-tests/lexico52/lexico.t      |  22 +-
 test/lua-Harness-tests/lexico53/boolean.t     |  44 +-
 test/lua-Harness-tests/lexico53/function.t    |  72 +-
 test/lua-Harness-tests/lexico53/lexico.t      |  14 +-
 test/lua-Harness-tests/lexico53/nil.t         |  44 +-
 test/lua-Harness-tests/lexico53/number.t      | 224 +++---
 test/lua-Harness-tests/lexico53/string.t      | 196 ++---
 test/lua-Harness-tests/lexico53/table.t       |  44 +-
 test/lua-Harness-tests/lexico53/thread.t      |  44 +-
 test/lua-Harness-tests/lexico53/userdata.t    |  44 +-
 test/lua-Harness-tests/lexico53/utf8.t        | 240 +++---
 test/lua-Harness-tests/lexico54/lexico.t      |   8 +-
 test/lua-Harness-tests/lexico54/metatable.t   |  14 +-
 test/lua-Harness-tests/lexico54/utf8.t        |  34 +-
 test/lua-Harness-tests/lexicojit/basic.t      |  14 +-
 test/lua-Harness-tests/lexicojit/ext.t        |  26 +-
 test/lua-Harness-tests/lexicojit/lexico.t     |  30 +-
 test/lua-Harness-tests/profile_ravi.lua       |   4 +-
 test/lua-Harness-tests/profile_tarantool.lua  |  63 ++
 .../{tap.lua => test_assertion.lua}           | 133 +--
 test/luajit-test-init.lua                     |   2 +
 67 files changed, 4165 insertions(+), 4012 deletions(-)
 create mode 100755 test/lua-Harness-tests/241-standalone.t
 delete mode 100755 test/lua-Harness-tests/241-standalone.t.disabled
 create mode 100755 test/lua-Harness-tests/411-luajit.t
 delete mode 100755 test/lua-Harness-tests/411-luajit.t.disabled
 create mode 100644 test/lua-Harness-tests/profile_tarantool.lua
 rename test/lua-Harness-tests/{tap.lua => test_assertion.lua} (58%)

-- 
2.32.0


^ permalink raw reply	[flat|nested] 22+ messages in thread

* [Tarantool-patches] [PATCH v2 01/10] test: port lua-Harness to Test.Assertion
  2021-07-20 16:26 [Tarantool-patches] [PATCH v2 00/10] test: lua-Harness suite patch bump Maxim Kokryashkin via Tarantool-patches
@ 2021-07-20 16:26 ` Maxim Kokryashkin via Tarantool-patches
  2021-07-25 21:08   ` Igor Munkin via Tarantool-patches
  2021-07-20 16:26 ` [Tarantool-patches] [PATCH v2 02/10] test: rename lua-Harness tap to test_assertion Maxim Kokryashkin via Tarantool-patches
                   ` (9 subsequent siblings)
  10 siblings, 1 reply; 22+ messages in thread
From: Maxim Kokryashkin via Tarantool-patches @ 2021-07-20 16:26 UTC (permalink / raw)
  To: tarantool-patches, imun, skaplun

Backports conversion to Test.Assertion patch[1] from lua-Harness suite

As a result out of this change out-of-source testing is broken, but the
previous assertion using package.path as a second argument worked fine.
Because of that, this commit includes fix, that was made by this patch[2]
in mainline lua-Harness.

[1]: https://framagit.org/fperrad/lua-Harness/-/commit/074fefa51da1276078f735fa8fb568963fe541f1
[2]: https://framagit.org/fperrad/lua-Harness/-/commit/c4451fe06fcdc0d83a72dfa56eaae3ed26151c04

Part of tarantool/tarantool#5970
Part of tarantool/tarantool#4473
---
Additional comments on issue with out-of-source testing:
https://github.com/tarantool/tarantool/issues/5970#issuecomment-880158605

 test/lua-Harness-tests/090-tap.t              |   8 +-
 test/lua-Harness-tests/091-profile.t          |  10 +-
 test/lua-Harness-tests/101-boolean.t          | 126 +--
 test/lua-Harness-tests/102-function.t         | 218 ++---
 test/lua-Harness-tests/103-nil.t              | 126 +--
 test/lua-Harness-tests/104-number.t           | 270 +++----
 test/lua-Harness-tests/105-string.t           | 308 ++++----
 test/lua-Harness-tests/106-table.t            | 132 ++--
 test/lua-Harness-tests/107-thread.t           | 128 +--
 test/lua-Harness-tests/108-userdata.t         | 124 +--
 test/lua-Harness-tests/200-examples.t         |  12 +-
 test/lua-Harness-tests/201-assign.t           |  82 +-
 test/lua-Harness-tests/202-expr.t             | 138 ++--
 test/lua-Harness-tests/203-lexico.t           |  66 +-
 test/lua-Harness-tests/204-grammar.t          |  76 +-
 test/lua-Harness-tests/211-scope.t            |  24 +-
 test/lua-Harness-tests/212-function.t         | 138 ++--
 test/lua-Harness-tests/213-closure.t          |  32 +-
 test/lua-Harness-tests/214-coroutine.t        |  96 +--
 test/lua-Harness-tests/221-table.t            |  54 +-
 test/lua-Harness-tests/222-constructor.t      |  34 +-
 test/lua-Harness-tests/223-iterator.t         |  18 +-
 test/lua-Harness-tests/231-metatable.t        | 232 +++---
 test/lua-Harness-tests/232-object.t           |  38 +-
 .../241-standalone.t.disabled                 | 116 +--
 test/lua-Harness-tests/242-luac.t             |  80 +-
 test/lua-Harness-tests/301-basic.t            | 748 +++++++++---------
 test/lua-Harness-tests/303-package.t          | 119 +--
 test/lua-Harness-tests/304-string.t           | 648 +++++++--------
 test/lua-Harness-tests/305-utf8.t             |   4 +-
 test/lua-Harness-tests/306-table.t            | 186 ++---
 test/lua-Harness-tests/307-math.t             | 266 +++----
 test/lua-Harness-tests/308-io.t               | 248 +++---
 test/lua-Harness-tests/309-os.t               | 158 ++--
 test/lua-Harness-tests/310-debug.t            | 226 +++---
 test/lua-Harness-tests/311-bit32.t            |  70 +-
 test/lua-Harness-tests/314-regex.t            |   8 +-
 test/lua-Harness-tests/320-stdin.t            |  26 +-
 test/lua-Harness-tests/401-bitop.t            |  60 +-
 test/lua-Harness-tests/402-ffi.t              |  78 +-
 test/lua-Harness-tests/403-jit.t              |  96 +--
 test/lua-Harness-tests/404-ext.t              | 162 ++--
 test/lua-Harness-tests/411-luajit.t.disabled  | 166 ++--
 test/lua-Harness-tests/lexico52/lexico.t      |  22 +-
 test/lua-Harness-tests/lexico53/boolean.t     |  44 +-
 test/lua-Harness-tests/lexico53/function.t    |  72 +-
 test/lua-Harness-tests/lexico53/lexico.t      |  14 +-
 test/lua-Harness-tests/lexico53/nil.t         |  44 +-
 test/lua-Harness-tests/lexico53/number.t      | 224 +++---
 test/lua-Harness-tests/lexico53/string.t      | 196 ++---
 test/lua-Harness-tests/lexico53/table.t       |  44 +-
 test/lua-Harness-tests/lexico53/thread.t      |  44 +-
 test/lua-Harness-tests/lexico53/userdata.t    |  44 +-
 test/lua-Harness-tests/lexico53/utf8.t        | 240 +++---
 test/lua-Harness-tests/lexico54/lexico.t      |   8 +-
 test/lua-Harness-tests/lexico54/metatable.t   |  14 +-
 test/lua-Harness-tests/lexico54/utf8.t        |  34 +-
 test/lua-Harness-tests/lexicojit/basic.t      |  14 +-
 test/lua-Harness-tests/lexicojit/ext.t        |  26 +-
 test/lua-Harness-tests/lexicojit/lexico.t     |  30 +-
 test/lua-Harness-tests/tap.lua                |  96 ++-
 61 files changed, 3599 insertions(+), 3566 deletions(-)

diff --git a/test/lua-Harness-tests/090-tap.t b/test/lua-Harness-tests/090-tap.t
index 92f04d8e..47a9b613 100755
--- a/test/lua-Harness-tests/090-tap.t
+++ b/test/lua-Harness-tests/090-tap.t
@@ -2,7 +2,7 @@
 --
 -- lua-Harness : <https://fperrad.frama.io/lua-Harness/>
 --
--- Copyright (C) 2018, Perrad Francois
+-- Copyright (C) 2018-2021, Perrad Francois
 --
 -- This code is licensed under the terms of the MIT/X11 license,
 -- like Lua itself.
@@ -25,9 +25,9 @@
 require'tap'
 
 plan(3)
-ok( true, 'ok' )
-is( 42, 42, '42 == 42' )
-pass( 'pass' )
+truthy( true, 'truthy' )
+equals( 42, 42, '42 == 42' )
+passes( 'pass' )
 
 -- Local Variables:
 --   mode: lua
diff --git a/test/lua-Harness-tests/091-profile.t b/test/lua-Harness-tests/091-profile.t
index db474384..53220569 100755
--- a/test/lua-Harness-tests/091-profile.t
+++ b/test/lua-Harness-tests/091-profile.t
@@ -2,7 +2,7 @@
 --
 -- lua-Harness : <https://fperrad.frama.io/lua-Harness/>
 --
--- Copyright (C) 2018, Perrad Francois
+-- Copyright (C) 2018-2021, Perrad Francois
 --
 -- This code is licensed under the terms of the MIT/X11 license,
 -- like Lua itself.
@@ -26,14 +26,14 @@ require'tap'
 
 plan'no_plan'
 
-type_ok(_VERSION, 'string', "variable _VERSION")
-like(_VERSION, '^Lua 5%.%d$')
+is_string(_VERSION, "variable _VERSION")
+matches(_VERSION, '^Lua 5%.%d$')
 
 if jit then
-    type_ok(jit.version_num, 'number', "variable jit.version_num")
+    is_number(jit.version_num, "variable jit.version_num")
 end
 
-local profile = require_ok'profile'
+require_ok'profile'
 
 done_testing()
 
diff --git a/test/lua-Harness-tests/101-boolean.t b/test/lua-Harness-tests/101-boolean.t
index c26b276e..95a3c0bd 100755
--- a/test/lua-Harness-tests/101-boolean.t
+++ b/test/lua-Harness-tests/101-boolean.t
@@ -2,7 +2,7 @@
 --
 -- lua-Harness : <https://fperrad.frama.io/lua-Harness/>
 --
--- Copyright (C) 2009-2018, Perrad Francois
+-- Copyright (C) 2009-2021, Perrad Francois
 --
 -- This code is licensed under the terms of the MIT/X11 license,
 -- like Lua itself.
@@ -27,91 +27,91 @@ local has_op53 = _VERSION >= 'Lua 5.3'
 
 plan'no_plan'
 
-error_like(function () return -true end,
-           "^[^:]+:%d+: attempt to perform arithmetic on a %w+ value",
-           "-true")
+error_matches(function () return -true end,
+        "^[^:]+:%d+: attempt to perform arithmetic on a %w+ value",
+        "-true")
 
-error_like(function () return #true end,
-           "^[^:]+:%d+: attempt to get length of a boolean value",
-           "#true")
+error_matches(function () return #true end,
+        "^[^:]+:%d+: attempt to get length of a boolean value",
+        "#true")
 
-is(not false, true, "not false")
+equals(not false, true, "not false")
 
-error_like(function () return true + 10 end,
-           "^[^:]+:%d+: attempt to perform arithmetic on a boolean value",
-           "true + 10")
+error_matches(function () return true + 10 end,
+        "^[^:]+:%d+: attempt to perform arithmetic on a boolean value",
+        "true + 10")
 
-error_like(function () return true - 2 end,
-           "^[^:]+:%d+: attempt to perform arithmetic on a boolean value",
-           "true - 2")
+error_matches(function () return true - 2 end,
+        "^[^:]+:%d+: attempt to perform arithmetic on a boolean value",
+        "true - 2")
 
-error_like(function () return true * 3.14 end,
-           "^[^:]+:%d+: attempt to perform arithmetic on a boolean value",
-           "true * 3.14")
+error_matches(function () return true * 3.14 end,
+        "^[^:]+:%d+: attempt to perform arithmetic on a boolean value",
+        "true * 3.14")
 
-error_like(function () return true / -7 end,
-           "^[^:]+:%d+: attempt to perform arithmetic on a boolean value",
-           "true / -7")
+error_matches(function () return true / -7 end,
+        "^[^:]+:%d+: attempt to perform arithmetic on a boolean value",
+        "true / -7")
 
-error_like(function () return true % 4 end,
-           "^[^:]+:%d+: attempt to perform arithmetic on a boolean value",
-           "true % 4")
+error_matches(function () return true % 4 end,
+        "^[^:]+:%d+: attempt to perform arithmetic on a boolean value",
+        "true % 4")
 
-error_like(function () return true ^ 3 end,
-           "^[^:]+:%d+: attempt to perform arithmetic on a boolean value",
-           "true ^ 3")
+error_matches(function () return true ^ 3 end,
+        "^[^:]+:%d+: attempt to perform arithmetic on a boolean value",
+        "true ^ 3")
 
-error_like(function () return true .. 'end' end,
-           "^[^:]+:%d+: attempt to concatenate a boolean value",
-           "true .. 'end'")
+error_matches(function () return true .. 'end' end,
+        "^[^:]+:%d+: attempt to concatenate a boolean value",
+        "true .. 'end'")
 
-is(true == true, true, "true == true")
+equals(true == true, true, "true == true")
 
-is(true ~= false, true, "true ~= false")
+equals(true ~= false, true, "true ~= false")
 
-is(true == 1, false, "true == 1")
+equals(true == 1, false, "true == 1")
 
-is(true ~= 1, true, "true ~= 1")
+equals(true ~= 1, true, "true ~= 1")
 
-error_like(function () return true < false end,
-           "^[^:]+:%d+: attempt to compare two boolean values",
-           "true < false")
+error_matches(function () return true < false end,
+        "^[^:]+:%d+: attempt to compare two boolean values",
+        "true < false")
 
-error_like(function () return true <= false end,
-           "^[^:]+:%d+: attempt to compare two boolean values",
-           "true <= false")
+error_matches(function () return true <= false end,
+        "^[^:]+:%d+: attempt to compare two boolean values",
+        "true <= false")
 
-error_like(function () return true > false end,
-           "^[^:]+:%d+: attempt to compare two boolean values",
-           "true > false")
+error_matches(function () return true > false end,
+        "^[^:]+:%d+: attempt to compare two boolean values",
+        "true > false")
 
-error_like(function () return true >= false end,
-           "^[^:]+:%d+: attempt to compare two boolean values",
-           "true >= false")
+error_matches(function () return true >= false end,
+        "^[^:]+:%d+: attempt to compare two boolean values",
+        "true >= false")
 
-error_like(function () return true < 0 end,
-           "^[^:]+:%d+: attempt to compare %w+ with %w+",
-           "true < 0")
+error_matches(function () return true < 0 end,
+        "^[^:]+:%d+: attempt to compare %w+ with %w+",
+        "true < 0")
 
-error_like(function () return true <= 0 end,
-           "^[^:]+:%d+: attempt to compare %w+ with %w+",
-           "true <= 0")
+error_matches(function () return true <= 0 end,
+        "^[^:]+:%d+: attempt to compare %w+ with %w+",
+        "true <= 0")
 
-error_like(function () return true > 0 end,
-           "^[^:]+:%d+: attempt to compare %w+ with %w+",
-           "true > 0")
+error_matches(function () return true > 0 end,
+        "^[^:]+:%d+: attempt to compare %w+ with %w+",
+        "true > 0")
 
-error_like(function () return true >= 0 end,
-           "^[^:]+:%d+: attempt to compare %w+ with %w+",
-           "true >= 0")
+error_matches(function () return true >= 0 end,
+        "^[^:]+:%d+: attempt to compare %w+ with %w+",
+        "true >= 0")
 
-error_like(function () local a = true; local b = a[1]; end,
-           "^[^:]+:%d+: attempt to index",
-           "index")
+error_matches(function () local a = true; local b = a[1]; end,
+        "^[^:]+:%d+: attempt to index",
+        "index")
 
-error_like(function () local a = true; a[1] = 1; end,
-           "^[^:]+:%d+: attempt to index",
-           "index")
+error_matches(function () local a = true; a[1] = 1; end,
+        "^[^:]+:%d+: attempt to index",
+        "index")
 
 if has_op53 then
     make_specific_checks'lexico53/boolean.t'
diff --git a/test/lua-Harness-tests/102-function.t b/test/lua-Harness-tests/102-function.t
index c49afc5e..26ced043 100755
--- a/test/lua-Harness-tests/102-function.t
+++ b/test/lua-Harness-tests/102-function.t
@@ -2,7 +2,7 @@
 --
 -- lua-Harness : <https://fperrad.frama.io/lua-Harness/>
 --
--- Copyright (C) 2009-2018, Perrad Francois
+-- Copyright (C) 2009-2021, Perrad Francois
 --
 -- This code is licensed under the terms of the MIT/X11 license,
 -- like Lua itself.
@@ -29,168 +29,168 @@ plan'no_plan'
 
 local f = function () return 1 end
 
-error_like(function () return -f end,
-           "^[^:]+:%d+: attempt to perform arithmetic on",
-           "-f")
+error_matches(function () return -f end,
+        "^[^:]+:%d+: attempt to perform arithmetic on",
+        "-f")
 
-error_like(function () f = print; return -f end,
-           "^[^:]+:%d+: attempt to perform arithmetic on")
+error_matches(function () f = print; return -f end,
+        "^[^:]+:%d+: attempt to perform arithmetic on")
 
-error_like(function () return #f end,
-           "^[^:]+:%d+: attempt to get length of",
-           "#f")
+error_matches(function () return #f end,
+        "^[^:]+:%d+: attempt to get length of",
+        "#f")
 
-error_like(function () f = print; return #f end,
-           "^[^:]+:%d+: attempt to get length of")
+error_matches(function () f = print; return #f end,
+        "^[^:]+:%d+: attempt to get length of")
 
-is(not f, false, "not f")
+equals(not f, false, "not f")
 
-is(not print, false)
+equals(not print, false)
 
-error_like(function () return f + 10 end,
-           "^[^:]+:%d+: attempt to perform arithmetic on",
-           "f + 10")
+error_matches(function () return f + 10 end,
+        "^[^:]+:%d+: attempt to perform arithmetic on",
+        "f + 10")
 
-error_like(function () f = print; return f + 10 end,
-           "^[^:]+:%d+: attempt to perform arithmetic on")
+error_matches(function () f = print; return f + 10 end,
+        "^[^:]+:%d+: attempt to perform arithmetic on")
 
-error_like(function () return f - 2 end,
-           "^[^:]+:%d+: attempt to perform arithmetic on",
-           "f - 2")
+error_matches(function () return f - 2 end,
+        "^[^:]+:%d+: attempt to perform arithmetic on",
+        "f - 2")
 
-error_like(function () f = print; return f - 2 end,
-           "^[^:]+:%d+: attempt to perform arithmetic on")
+error_matches(function () f = print; return f - 2 end,
+        "^[^:]+:%d+: attempt to perform arithmetic on")
 
-error_like(function () return f * 3.14 end,
-           "^[^:]+:%d+: attempt to perform arithmetic on",
-           "f * 3.14")
+error_matches(function () return f * 3.14 end,
+        "^[^:]+:%d+: attempt to perform arithmetic on",
+        "f * 3.14")
 
-error_like(function () f = print; return f * 3.14 end,
-           "^[^:]+:%d+: attempt to perform arithmetic on")
+error_matches(function () f = print; return f * 3.14 end,
+        "^[^:]+:%d+: attempt to perform arithmetic on")
 
-error_like(function () return f / -7 end,
-           "^[^:]+:%d+: attempt to perform arithmetic on",
-           "f / -7")
+error_matches(function () return f / -7 end,
+        "^[^:]+:%d+: attempt to perform arithmetic on",
+        "f / -7")
 
-error_like(function () f = print; return f / -7 end,
-           "^[^:]+:%d+: attempt to perform arithmetic on")
+error_matches(function () f = print; return f / -7 end,
+        "^[^:]+:%d+: attempt to perform arithmetic on")
 
-error_like(function () return f % 4 end,
-           "^[^:]+:%d+: attempt to perform arithmetic on",
-           "f % 4")
+error_matches(function () return f % 4 end,
+        "^[^:]+:%d+: attempt to perform arithmetic on",
+        "f % 4")
 
-error_like(function () f = print; return f % 4 end,
-           "^[^:]+:%d+: attempt to perform arithmetic on")
+error_matches(function () f = print; return f % 4 end,
+        "^[^:]+:%d+: attempt to perform arithmetic on")
 
-error_like(function () return f ^ 3 end,
-           "^[^:]+:%d+: attempt to perform arithmetic on",
-           "f ^ 3")
+error_matches(function () return f ^ 3 end,
+        "^[^:]+:%d+: attempt to perform arithmetic on",
+        "f ^ 3")
 
-error_like(function () f = print; return f ^ 3 end,
-           "^[^:]+:%d+: attempt to perform arithmetic on")
+error_matches(function () f = print; return f ^ 3 end,
+        "^[^:]+:%d+: attempt to perform arithmetic on")
 
-error_like(function () return f .. 'end' end,
-           "^[^:]+:%d+: attempt to concatenate",
-           "f .. 'end'")
+error_matches(function () return f .. 'end' end,
+        "^[^:]+:%d+: attempt to concatenate",
+        "f .. 'end'")
 
-error_like(function () f = print; return f .. 'end' end,
-           "^[^:]+:%d+: attempt to concatenate")
+error_matches(function () f = print; return f .. 'end' end,
+        "^[^:]+:%d+: attempt to concatenate")
 
 local g = f
-is(f == g, true, "f == f")
+equals(f == g, true, "f == f")
 
 g = print
-is(g == print, true)
+equals(g == print, true)
 
 g = function () return 2 end
-is(f ~= g, true, "f ~= g")
+equals(f ~= g, true, "f ~= g")
 local h = type
-is(f ~= h, true)
+equals(f ~= h, true)
 
-is(print ~= g, true)
-is(print ~= h, true)
+equals(print ~= g, true)
+equals(print ~= h, true)
 
-is(f == 1, false, "f == 1")
+equals(f == 1, false, "f == 1")
 
-is(print == 1, false)
+equals(print == 1, false)
 
-is(f ~= 1, true, "f ~= 1")
+equals(f ~= 1, true, "f ~= 1")
 
-is(print ~= 1, true)
+equals(print ~= 1, true)
 
-error_like(function () return f < g end,
-           "^[^:]+:%d+: attempt to compare two function values",
-           "f < g")
+error_matches(function () return f < g end,
+        "^[^:]+:%d+: attempt to compare two function values",
+        "f < g")
 
-error_like(function () f = print; g = type; return f < g end,
-           "^[^:]+:%d+: attempt to compare two function values")
+error_matches(function () f = print; g = type; return f < g end,
+        "^[^:]+:%d+: attempt to compare two function values")
 
-error_like(function () return f <= g end,
-           "^[^:]+:%d+: attempt to compare two function values",
-           "f <= g")
+error_matches(function () return f <= g end,
+        "^[^:]+:%d+: attempt to compare two function values",
+        "f <= g")
 
-error_like(function () f = print; g = type; return f <= g end,
-           "^[^:]+:%d+: attempt to compare two function values")
+error_matches(function () f = print; g = type; return f <= g end,
+        "^[^:]+:%d+: attempt to compare two function values")
 
-error_like(function () return f > g end,
-           "^[^:]+:%d+: attempt to compare two function values",
-           "f > g")
+error_matches(function () return f > g end,
+        "^[^:]+:%d+: attempt to compare two function values",
+        "f > g")
 
-error_like(function () f = print; g = type; return f > g end,
-           "^[^:]+:%d+: attempt to compare two function values")
+error_matches(function () f = print; g = type; return f > g end,
+        "^[^:]+:%d+: attempt to compare two function values")
 
-error_like(function () return f >= g end,
-           "^[^:]+:%d+: attempt to compare two function values",
-           "f >= g")
+error_matches(function () return f >= g end,
+        "^[^:]+:%d+: attempt to compare two function values",
+        "f >= g")
 
-error_like(function () f = print; g = type; return f >= g end,
-           "^[^:]+:%d+: attempt to compare two function values")
+error_matches(function () f = print; g = type; return f >= g end,
+        "^[^:]+:%d+: attempt to compare two function values")
 
-error_like(function () return f < 0 end,
-           "^[^:]+:%d+: attempt to compare %w+ with %w+",
-           "f < 0")
+error_matches(function () return f < 0 end,
+        "^[^:]+:%d+: attempt to compare %w+ with %w+",
+        "f < 0")
 
-error_like(function () f = print; return f < 0 end,
-           "^[^:]+:%d+: attempt to compare %w+ with %w+")
+error_matches(function () f = print; return f < 0 end,
+        "^[^:]+:%d+: attempt to compare %w+ with %w+")
 
-error_like(function () return f <= 0 end,
-           "^[^:]+:%d+: attempt to compare %w+ with %w+",
-           "f <= 0")
+error_matches(function () return f <= 0 end,
+        "^[^:]+:%d+: attempt to compare %w+ with %w+",
+        "f <= 0")
 
-error_like(function () f = print; return f <= 0 end,
-           "^[^:]+:%d+: attempt to compare %w+ with %w+")
+error_matches(function () f = print; return f <= 0 end,
+        "^[^:]+:%d+: attempt to compare %w+ with %w+")
 
-error_like(function () return f > 0 end,
-           "^[^:]+:%d+: attempt to compare %w+ with %w+",
-           "f > 0")
+error_matches(function () return f > 0 end,
+        "^[^:]+:%d+: attempt to compare %w+ with %w+",
+        "f > 0")
 
-error_like(function () f = print; return f > 0 end,
-           "^[^:]+:%d+: attempt to compare %w+ with %w+")
+error_matches(function () f = print; return f > 0 end,
+        "^[^:]+:%d+: attempt to compare %w+ with %w+")
 
-error_like(function () return f > 0 end,
-           "^[^:]+:%d+: attempt to compare %w+ with %w+",
-           "f >= 0")
+error_matches(function () return f > 0 end,
+        "^[^:]+:%d+: attempt to compare %w+ with %w+",
+        "f >= 0")
 
-error_like(function () f = print; return f >= 0 end,
-           "^[^:]+:%d+: attempt to compare %w+ with %w+")
+error_matches(function () f = print; return f >= 0 end,
+        "^[^:]+:%d+: attempt to compare %w+ with %w+")
 
-error_like(function () local a = f; local b = a[1]; end,
-           "^[^:]+:%d+: attempt to index",
-           "index")
+error_matches(function () local a = f; local b = a[1]; end,
+        "^[^:]+:%d+: attempt to index",
+        "index")
 
-error_like(function () local a = print; local b = a[1]; end,
-           "^[^:]+:%d+: attempt to index")
+error_matches(function () local a = print; local b = a[1]; end,
+        "^[^:]+:%d+: attempt to index")
 
-error_like(function () local a = f; a[1] = 1; end,
-           "^[^:]+:%d+: attempt to index",
-           "index")
+error_matches(function () local a = f; a[1] = 1; end,
+        "^[^:]+:%d+: attempt to index",
+        "index")
 
-error_like(function () local a = print; a[1] = 1; end,
-           "^[^:]+:%d+: attempt to index")
+error_matches(function () local a = print; a[1] = 1; end,
+        "^[^:]+:%d+: attempt to index")
 
 local t = {}
 t[print] = true
-ok(t[print])
+truthy(t[print])
 
 if has_op53 then
     make_specific_checks'lexico53/function.t'
diff --git a/test/lua-Harness-tests/103-nil.t b/test/lua-Harness-tests/103-nil.t
index 87a1c3b1..90a3b4f3 100755
--- a/test/lua-Harness-tests/103-nil.t
+++ b/test/lua-Harness-tests/103-nil.t
@@ -2,7 +2,7 @@
 --
 -- lua-Harness : <https://fperrad.frama.io/lua-Harness/>
 --
--- Copyright (C) 2009-2018, Perrad Francois
+-- Copyright (C) 2009-2021, Perrad Francois
 --
 -- This code is licensed under the terms of the MIT/X11 license,
 -- like Lua itself.
@@ -27,91 +27,91 @@ local has_op53 = _VERSION >= 'Lua 5.3'
 
 plan'no_plan'
 
-error_like(function () return -nil end,
-           "^[^:]+:%d+: attempt to perform arithmetic on a nil value",
-           "-nil")
+error_matches(function () return -nil end,
+        "^[^:]+:%d+: attempt to perform arithmetic on a nil value",
+        "-nil")
 
-error_like(function () return #nil end,
-           "^[^:]+:%d+: attempt to get length of a nil value",
-           "#nil")
+error_matches(function () return #nil end,
+        "^[^:]+:%d+: attempt to get length of a nil value",
+        "#nil")
 
-is(not nil, true, "not nil")
+equals(not nil, true, "not nil")
 
-error_like(function () return nil + 10 end,
-           "^[^:]+:%d+: attempt to perform arithmetic on a nil value",
-           "nil + 10")
+error_matches(function () return nil + 10 end,
+        "^[^:]+:%d+: attempt to perform arithmetic on a nil value",
+        "nil + 10")
 
-error_like(function () return nil - 2 end,
-           "^[^:]+:%d+: attempt to perform arithmetic on a nil value",
-           "nil - 2")
+error_matches(function () return nil - 2 end,
+        "^[^:]+:%d+: attempt to perform arithmetic on a nil value",
+        "nil - 2")
 
-error_like(function () return nil * 3.14 end,
-           "^[^:]+:%d+: attempt to perform arithmetic on a nil value",
-           "nil * 3.14")
+error_matches(function () return nil * 3.14 end,
+        "^[^:]+:%d+: attempt to perform arithmetic on a nil value",
+        "nil * 3.14")
 
-error_like(function () return nil / -7 end,
-           "^[^:]+:%d+: attempt to perform arithmetic on a nil value",
-           "nil / -7")
+error_matches(function () return nil / -7 end,
+        "^[^:]+:%d+: attempt to perform arithmetic on a nil value",
+        "nil / -7")
 
-error_like(function () return nil % 4 end,
-           "^[^:]+:%d+: attempt to perform arithmetic on a nil value",
-           "nil % 4")
+error_matches(function () return nil % 4 end,
+        "^[^:]+:%d+: attempt to perform arithmetic on a nil value",
+        "nil % 4")
 
-error_like(function () return nil ^ 3 end,
-           "^[^:]+:%d+: attempt to perform arithmetic on a nil value",
-           "nil ^ 3")
+error_matches(function () return nil ^ 3 end,
+        "^[^:]+:%d+: attempt to perform arithmetic on a nil value",
+        "nil ^ 3")
 
-error_like(function () return nil .. 'end' end,
-           "^[^:]+:%d+: attempt to concatenate a nil value",
-           "nil .. 'end'")
+error_matches(function () return nil .. 'end' end,
+        "^[^:]+:%d+: attempt to concatenate a nil value",
+        "nil .. 'end'")
 
-is(nil == nil, true, "nil == nil")
+equals(nil == nil, true, "nil == nil")
 
-is(nil ~= nil, false, "nil ~= nil")
+equals(nil ~= nil, false, "nil ~= nil")
 
-is(nil == 1, false, "nil == 1")
+equals(nil == 1, false, "nil == 1")
 
-is(nil ~= 1, true, "nil ~= 1")
+equals(nil ~= 1, true, "nil ~= 1")
 
-error_like(function () return nil < nil end,
-           "^[^:]+:%d+: attempt to compare two nil values",
-           "nil < nil")
+error_matches(function () return nil < nil end,
+        "^[^:]+:%d+: attempt to compare two nil values",
+        "nil < nil")
 
-error_like(function () return nil <= nil end,
-           "^[^:]+:%d+: attempt to compare two nil values",
-           "nil <= nil")
+error_matches(function () return nil <= nil end,
+        "^[^:]+:%d+: attempt to compare two nil values",
+        "nil <= nil")
 
-error_like(function () return nil > nil end,
-           "^[^:]+:%d+: attempt to compare two nil values",
-           "nil > nil")
+error_matches(function () return nil > nil end,
+        "^[^:]+:%d+: attempt to compare two nil values",
+        "nil > nil")
 
-error_like(function () return nil > nil end,
-           "^[^:]+:%d+: attempt to compare two nil values",
-           "nil >= nil")
+error_matches(function () return nil > nil end,
+        "^[^:]+:%d+: attempt to compare two nil values",
+        "nil >= nil")
 
-error_like(function () return nil < 0 end,
-           "^[^:]+:%d+: attempt to compare %w+ with %w+",
-           "nil < 0")
+error_matches(function () return nil < 0 end,
+        "^[^:]+:%d+: attempt to compare %w+ with %w+",
+        "nil < 0")
 
-error_like(function () return nil <= 0 end,
-           "^[^:]+:%d+: attempt to compare %w+ with %w+",
-           "nil <= 0")
+error_matches(function () return nil <= 0 end,
+        "^[^:]+:%d+: attempt to compare %w+ with %w+",
+        "nil <= 0")
 
-error_like(function () return nil > 0 end,
-           "^[^:]+:%d+: attempt to compare %w+ with %w+",
-           "nil > 0")
+error_matches(function () return nil > 0 end,
+        "^[^:]+:%d+: attempt to compare %w+ with %w+",
+        "nil > 0")
 
-error_like(function () return nil >= 0 end,
-           "^[^:]+:%d+: attempt to compare %w+ with %w+",
-           "nil >= 0")
+error_matches(function () return nil >= 0 end,
+        "^[^:]+:%d+: attempt to compare %w+ with %w+",
+        "nil >= 0")
 
-error_like(function () local a = nil; local b = a[1]; end,
-           "^[^:]+:%d+: attempt to index",
-           "index")
+error_matches(function () local a = nil; local b = a[1]; end,
+        "^[^:]+:%d+: attempt to index",
+        "index")
 
-error_like(function () local a = nil; a[1] = 1; end,
-           "^[^:]+:%d+: attempt to index",
-           "index")
+error_matches(function () local a = nil; a[1] = 1; end,
+        "^[^:]+:%d+: attempt to index",
+        "index")
 
 if has_op53 then
     make_specific_checks'lexico53/nil.t'
diff --git a/test/lua-Harness-tests/104-number.t b/test/lua-Harness-tests/104-number.t
index f5b81e3d..a41c5951 100755
--- a/test/lua-Harness-tests/104-number.t
+++ b/test/lua-Harness-tests/104-number.t
@@ -2,7 +2,7 @@
 --
 -- lua-Harness : <https://fperrad.frama.io/lua-Harness/>
 --
--- Copyright (C) 2009-2019, Perrad Francois
+-- Copyright (C) 2009-2021, Perrad Francois
 --
 -- This code is licensed under the terms of the MIT/X11 license,
 -- like Lua itself.
@@ -28,209 +28,209 @@ local has_op53 = _VERSION >= 'Lua 5.3'
 
 plan'no_plan'
 
-is(-1, -(1), "-1")
+equals(-1, -(1), "-1")
 
-is(not 1, false, "not 1")
+equals(not 1, false, "not 1")
 
-is(10 + 2, 12, "10 + 2")
+equals(10 + 2, 12, "10 + 2")
 
-is(2 - 10.5, -8.5, "2 - 10.5")
+equals(2 - 10.5, -8.5, "2 - 10.5")
 
-is(2 * 3, 6, "2 * 3")
+equals(2 * 3, 6, "2 * 3")
 
-is(3.14 * 1, 3.14, "3.14 * 1")
+equals(3.14 * 1, 3.14, "3.14 * 1")
 
-is(-7 / 0.5, -14, "-7 / 0.5")
+equals(-7 / 0.5, -14, "-7 / 0.5")
 
-type_ok(1.0 / 0.0, 'number', "1.0 / 0.0")
+is_number(1.0 / 0.0, "1.0 / 0.0")
 
-is(-25 % 3, 2, "-25 % 3")
+equals(-25 % 3, 2, "-25 % 3")
 
 if _VERSION >= 'Lua 5.3' then
-    error_like(function () return 1 % 0 end,
-               "^[^:]+:%d+: attempt to perform 'n%%0'",
-               "1 % 0")
+    error_matches(function () return 1 % 0 end,
+            "^[^:]+:%d+: attempt to perform 'n%%0'",
+            "1 % 0")
 else
-    type_ok(1 % 0, 'number', "1 % 0")
+    is_number(1 % 0, "1 % 0")
 end
 
-error_like(function () return 10 + true end,
-           "^[^:]+:%d+: attempt to perform arithmetic on a boolean value",
-           "10 + true")
+error_matches(function () return 10 + true end,
+        "^[^:]+:%d+: attempt to perform arithmetic on a boolean value",
+        "10 + true")
 
-error_like(function () return 2 - nil end,
-           "^[^:]+:%d+: attempt to perform arithmetic on a nil value",
-           "2 - nil")
+error_matches(function () return 2 - nil end,
+        "^[^:]+:%d+: attempt to perform arithmetic on a nil value",
+        "2 - nil")
 
-error_like(function () return 2 * {} end,
-           "^[^:]+:%d+: attempt to perform arithmetic on a table value",
-           "2 * {}")
+error_matches(function () return 2 * {} end,
+        "^[^:]+:%d+: attempt to perform arithmetic on a table value",
+        "2 * {}")
 
-error_like(function () return 3.14 * false end,
-           "^[^:]+:%d+: attempt to perform arithmetic on a boolean value",
-           "3.14 * false")
+error_matches(function () return 3.14 * false end,
+        "^[^:]+:%d+: attempt to perform arithmetic on a boolean value",
+        "3.14 * false")
 
-error_like(function () return -7 / {} end,
-           "^[^:]+:%d+: attempt to perform arithmetic on a table value",
-           "-7 / {}")
+error_matches(function () return -7 / {} end,
+        "^[^:]+:%d+: attempt to perform arithmetic on a table value",
+        "-7 / {}")
 
-error_like(function () return 3 ^ true end,
-           "^[^:]+:%d+: attempt to perform arithmetic on a boolean value",
-           "3 ^ true")
+error_matches(function () return 3 ^ true end,
+        "^[^:]+:%d+: attempt to perform arithmetic on a boolean value",
+        "3 ^ true")
 
-error_like(function () return -25 % false end,
-           "^[^:]+:%d+: attempt to perform arithmetic on a boolean value",
-           "-25 % false")
+error_matches(function () return -25 % false end,
+        "^[^:]+:%d+: attempt to perform arithmetic on a boolean value",
+        "-25 % false")
 
-error_like(function () return 10 + 'text' end,
-           "^[^:]+:%d+: attempt to",
-           "10 + 'text'")
+error_matches(function () return 10 + 'text' end,
+        "^[^:]+:%d+: attempt to",
+        "10 + 'text'")
 
-error_like(function () return 2 - 'text' end,
-           "^[^:]+:%d+: attempt to",
-           "2 - 'text'")
+error_matches(function () return 2 - 'text' end,
+        "^[^:]+:%d+: attempt to",
+        "2 - 'text'")
 
-error_like(function () return 2 * 'text' end,
-           "^[^:]+:%d+: attempt to",
-           "2 * 'text'")
+error_matches(function () return 2 * 'text' end,
+        "^[^:]+:%d+: attempt to",
+        "2 * 'text'")
 
-error_like(function () return 3.14 * 'text' end,
-           "^[^:]+:%d+: attempt to",
-           "3.14 * 'text'")
+error_matches(function () return 3.14 * 'text' end,
+        "^[^:]+:%d+: attempt to",
+        "3.14 * 'text'")
 
-error_like(function () return -7 / 'text' end,
-           "^[^:]+:%d+: attempt to",
-           "-7 / 'text'")
+error_matches(function () return -7 / 'text' end,
+        "^[^:]+:%d+: attempt to",
+        "-7 / 'text'")
 
-error_like(function () return 25 % 'text' end,
-           "^[^:]+:%d+: attempt to",
-           "25 % 'text'")
+error_matches(function () return 25 % 'text' end,
+        "^[^:]+:%d+: attempt to",
+        "25 % 'text'")
 
-error_like(function () return 3 ^ 'text' end,
-           "^[^:]+:%d+: attempt to",
-           "3 ^ 'text'")
+error_matches(function () return 3 ^ 'text' end,
+        "^[^:]+:%d+: attempt to",
+        "3 ^ 'text'")
 
 if profile.nocvts2n then
-    error_like(function () return 10 + '2' end,
-               "^[^:]+:%d+: attempt to",
-               "10 + '2'")
+    error_matches(function () return 10 + '2' end,
+            "^[^:]+:%d+: attempt to",
+            "10 + '2'")
 
-    error_like(function () return 2 - '10.5' end,
-               "^[^:]+:%d+: attempt to",
-               "2 - '10.5'")
+    error_matches(function () return 2 - '10.5' end,
+            "^[^:]+:%d+: attempt to",
+            "2 - '10.5'")
 
-    error_like(function () return 2 * '3' end,
-               "^[^:]+:%d+: attempt to",
-               "2 * '3'")
+    error_matches(function () return 2 * '3' end,
+            "^[^:]+:%d+: attempt to",
+            "2 * '3'")
 
-    error_like(function () return 3.14 * '1' end,
-               "^[^:]+:%d+: attempt to",
-               "3.14 * '1'")
+    error_matches(function () return 3.14 * '1' end,
+            "^[^:]+:%d+: attempt to",
+            "3.14 * '1'")
 
-    error_like(function () return -7 / '0.5' end,
-               "^[^:]+:%d+: attempt to",
-               "-7 / '0.5'")
+    error_matches(function () return -7 / '0.5' end,
+            "^[^:]+:%d+: attempt to",
+            "-7 / '0.5'")
 
-    error_like(function () return -25 % '3' end,
-               "^[^:]+:%d+: attempt to",
-               "-25 % '3'")
+    error_matches(function () return -25 % '3' end,
+            "^[^:]+:%d+: attempt to",
+            "-25 % '3'")
 
-    error_like(function () return 3 ^ '3' end,
-               "^[^:]+:%d+: attempt to",
-               "3 ^ '3'")
+    error_matches(function () return 3 ^ '3' end,
+            "^[^:]+:%d+: attempt to",
+            "3 ^ '3'")
 else
-    is(10 + '2', 12, "10 + '2'")
+    equals(10 + '2', 12, "10 + '2'")
 
-    is(2 - '10.5', -8.5, "2 - '10.5'")
+    equals(2 - '10.5', -8.5, "2 - '10.5'")
 
-    is(2 * '3', 6, "2 * '3'")
+    equals(2 * '3', 6, "2 * '3'")
 
-    is(3.14 * '1', 3.14, "3.14 * '1'")
+    equals(3.14 * '1', 3.14, "3.14 * '1'")
 
-    is(-7 / '0.5', -14, "-7 / '0.5'")
+    equals(-7 / '0.5', -14, "-7 / '0.5'")
 
-    is(-25 % '3', 2, "-25 % '3'")
+    equals(-25 % '3', 2, "-25 % '3'")
 
-    is(3 ^ '3', 27, "3 ^ '3'")
+    equals(3 ^ '3', 27, "3 ^ '3'")
 end
 
 if profile.nocvtn2s then
-    error_like(function () return 1 .. 'end' end,
-               "^[^:]+:%d+: attempt to concatenate a number value",
-               "1 .. 'end'")
+    error_matches(function () return 1 .. 'end' end,
+            "^[^:]+:%d+: attempt to concatenate a number value",
+            "1 .. 'end'")
 
-    error_like(function () return 1 .. 2 end,
-               "^[^:]+:%d+: attempt to concatenate a number value",
-               "1 .. 2")
+    error_matches(function () return 1 .. 2 end,
+            "^[^:]+:%d+: attempt to concatenate a number value",
+            "1 .. 2")
 else
-    is(1 .. 'end', '1end', "1 .. 'end'")
+    equals(1 .. 'end', '1end', "1 .. 'end'")
 
-    is(1 .. 2, '12', "1 .. 2")
+    equals(1 .. 2, '12', "1 .. 2")
 end
 
-error_like(function () return 1 .. true end,
-           "^[^:]+:%d+: attempt to concatenate a %w+ value",
-           "1 .. true")
+error_matches(function () return 1 .. true end,
+        "^[^:]+:%d+: attempt to concatenate a %w+ value",
+        "1 .. true")
 
-is(1.0 == 1, true, "1.0 == 1")
+equals(1.0 == 1, true, "1.0 == 1")
 
-is(1 ~= 2, true, "1 ~= 2")
+equals(1 ~= 2, true, "1 ~= 2")
 
-is(1 == true, false, "1 == true")
+equals(1 == true, false, "1 == true")
 
-is(1 ~= nil, true, "1 ~= nil")
+equals(1 ~= nil, true, "1 ~= nil")
 
-is(1 == '1', false, "1 == '1'")
+equals(1 == '1', false, "1 == '1'")
 
-is(1 ~= '1', true, "1 ~= '1'")
+equals(1 ~= '1', true, "1 ~= '1'")
 
-is(1 < 0, false, "1 < 0")
+equals(1 < 0, false, "1 < 0")
 
-is(1 <= 0, false, "1 <= 0")
+equals(1 <= 0, false, "1 <= 0")
 
-is(1 > 0, true, "1 > 0")
+equals(1 > 0, true, "1 > 0")
 
-is(1 >= 0, true, "1 >= 0")
+equals(1 >= 0, true, "1 >= 0")
 
-error_like(function () return 1 < false end,
-           "^[^:]+:%d+: attempt to compare %w+ with %w+",
-           "1 < false")
+error_matches(function () return 1 < false end,
+        "^[^:]+:%d+: attempt to compare %w+ with %w+",
+        "1 < false")
 
-error_like(function () return 1 <= nil end,
-           "^[^:]+:%d+: attempt to compare %w+ with %w+",
-           "1 <= nil")
+error_matches(function () return 1 <= nil end,
+        "^[^:]+:%d+: attempt to compare %w+ with %w+",
+        "1 <= nil")
 
-error_like(function () return 1 > true end,
-           "^[^:]+:%d+: attempt to compare %w+ with %w+",
-           "1 > true")
+error_matches(function () return 1 > true end,
+        "^[^:]+:%d+: attempt to compare %w+ with %w+",
+        "1 > true")
 
-error_like(function () return 1 >= {} end,
-           "^[^:]+:%d+: attempt to compare %w+ with %w+",
-           "1 >= {}")
+error_matches(function () return 1 >= {} end,
+        "^[^:]+:%d+: attempt to compare %w+ with %w+",
+        "1 >= {}")
 
-error_like(function () return 1 < '0' end,
-           "^[^:]+:%d+: attempt to compare %w+ with %w+",
-           "1 < '0'")
+error_matches(function () return 1 < '0' end,
+        "^[^:]+:%d+: attempt to compare %w+ with %w+",
+        "1 < '0'")
 
-error_like(function () return 1 <= '0' end,
-           "^[^:]+:%d+: attempt to compare %w+ with %w+",
-           "1 <= '0'")
+error_matches(function () return 1 <= '0' end,
+        "^[^:]+:%d+: attempt to compare %w+ with %w+",
+        "1 <= '0'")
 
-error_like(function () return 1 > '0' end,
-           "^[^:]+:%d+: attempt to compare %w+ with %w+",
-           "1 > '0'")
+error_matches(function () return 1 > '0' end,
+        "^[^:]+:%d+: attempt to compare %w+ with %w+",
+        "1 > '0'")
 
-error_like(function () return 1 >= '0' end,
-           "^[^:]+:%d+: attempt to compare %w+ with %w+",
-           "1 >= '0'")
+error_matches(function () return 1 >= '0' end,
+        "^[^:]+:%d+: attempt to compare %w+ with %w+",
+        "1 >= '0'")
 
-error_like(function () local a= 3.14; local b = a[1]; end,
-           "^[^:]+:%d+: attempt to index",
-           "index")
+error_matches(function () local a= 3.14; local b = a[1]; end,
+        "^[^:]+:%d+: attempt to index",
+        "index")
 
-error_like(function () local a = 3.14; a[1] = 1; end,
-           "^[^:]+:%d+: attempt to index",
-           "index")
+error_matches(function () local a = 3.14; a[1] = 1; end,
+        "^[^:]+:%d+: attempt to index",
+        "index")
 
 if has_op53 then
     make_specific_checks'lexico53/number.t'
diff --git a/test/lua-Harness-tests/105-string.t b/test/lua-Harness-tests/105-string.t
index 184deaba..af8c90b7 100755
--- a/test/lua-Harness-tests/105-string.t
+++ b/test/lua-Harness-tests/105-string.t
@@ -2,7 +2,7 @@
 --
 -- lua-Harness : <https://fperrad.frama.io/lua-Harness/>
 --
--- Copyright (C) 2009-2019, Perrad Francois
+-- Copyright (C) 2009-2021, Perrad Francois
 --
 -- This code is licensed under the terms of the MIT/X11 license,
 -- like Lua itself.
@@ -29,239 +29,239 @@ local has_op53 = _VERSION >= 'Lua 5.3'
 plan'no_plan'
 
 if profile.nocvts2n then
-    error_like(function () return - '1' end,
-               "^[^:]+:%d+: attempt to",
-               "-'1'")
+    error_matches(function () return - '1' end,
+            "^[^:]+:%d+: attempt to",
+            "-'1'")
 else
-    is(- '1', -1, "-'1'")
+    equals(- '1', -1, "-'1'")
 end
 
-error_like(function () return - 'text' end,
-           "^[^:]+:%d+: attempt to",
-           "-'text'")
+error_matches(function () return - 'text' end,
+        "^[^:]+:%d+: attempt to",
+        "-'text'")
 
-is(# 'text', 4, "#'text'")
+equals(# 'text', 4, "#'text'")
 
-is(not 'text', false, "not 'text'")
+equals(not 'text', false, "not 'text'")
 
 if profile.nocvts2n then
-    error_like(function () return '10' + 2 end,
-               "^[^:]+:%d+: attempt to",
-               "'10' + 2")
+    error_matches(function () return '10' + 2 end,
+            "^[^:]+:%d+: attempt to",
+            "'10' + 2")
 
-    error_like(function () return '2' - 10.5 end,
-               "^[^:]+:%d+: attempt to",
-               "'2' - 10.5")
+    error_matches(function () return '2' - 10.5 end,
+            "^[^:]+:%d+: attempt to",
+            "'2' - 10.5")
 
-    error_like(function () return '2' * 3 end,
-               "^[^:]+:%d+: attempt to",
-               "'2' * 3")
+    error_matches(function () return '2' * 3 end,
+            "^[^:]+:%d+: attempt to",
+            "'2' * 3")
 
-    error_like(function () return '3.14' * 1 end,
-               "^[^:]+:%d+: attempt to",
-               "'3.14' * 1")
+    error_matches(function () return '3.14' * 1 end,
+            "^[^:]+:%d+: attempt to",
+            "'3.14' * 1")
 
-    error_like(function () return '-7' / 0.5 end,
-               "^[^:]+:%d+: attempt to",
-               "'-7' / 0.5")
+    error_matches(function () return '-7' / 0.5 end,
+            "^[^:]+:%d+: attempt to",
+            "'-7' / 0.5")
 
-    error_like(function () return '-25' % 3 end,
-               "^[^:]+:%d+: attempt to",
-               "'-25' % 3")
+    error_matches(function () return '-25' % 3 end,
+            "^[^:]+:%d+: attempt to",
+            "'-25' % 3")
 
-    error_like(function () return '3' ^ 3 end,
-               "^[^:]+:%d+: attempt to",
-               "'3' ^ 3")
+    error_matches(function () return '3' ^ 3 end,
+            "^[^:]+:%d+: attempt to",
+            "'3' ^ 3")
 else
-    is('10' + 2, 12, "'10' + 2")
+    equals('10' + 2, 12, "'10' + 2")
 
-    is('2' - 10.5, -8.5, "'2' - 10.5")
+    equals('2' - 10.5, -8.5, "'2' - 10.5")
 
-    is('2' * 3, 6, "'2' * 3")
+    equals('2' * 3, 6, "'2' * 3")
 
-    is('3.14' * 1, 3.14, "'3.14' * 1")
+    equals('3.14' * 1, 3.14, "'3.14' * 1")
 
-    is('-7' / 0.5, -14, "'-7' / 0.5")
+    equals('-7' / 0.5, -14, "'-7' / 0.5")
 
-    is('-25' % 3, 2, "'-25' % 3")
+    equals('-25' % 3, 2, "'-25' % 3")
 
-    is('3' ^ 3, 27, "'3' ^ 3")
+    equals('3' ^ 3, 27, "'3' ^ 3")
 end
 
-error_like(function () return '10' + true end,
-           "^[^:]+:%d+: attempt to",
-           "'10' + true")
+error_matches(function () return '10' + true end,
+        "^[^:]+:%d+: attempt to",
+        "'10' + true")
 
-error_like(function () return '2' - nil end,
-           "^[^:]+:%d+: attempt to",
-           "'2' - nil")
+error_matches(function () return '2' - nil end,
+        "^[^:]+:%d+: attempt to",
+        "'2' - nil")
 
-error_like(function () return '2' * {} end,
-           "^[^:]+:%d+: attempt to",
-           "'2' * {}")
+error_matches(function () return '2' * {} end,
+        "^[^:]+:%d+: attempt to",
+        "'2' * {}")
 
-error_like(function () return '3.14' * false end,
-           "^[^:]+:%d+: attempt to",
-           "'3.14' * false")
+error_matches(function () return '3.14' * false end,
+        "^[^:]+:%d+: attempt to",
+        "'3.14' * false")
 
-error_like(function () return '-7' / {} end,
-           "^[^:]+:%d+: attempt to",
-           "'-7' / {}")
+error_matches(function () return '-7' / {} end,
+        "^[^:]+:%d+: attempt to",
+        "'-7' / {}")
 
-error_like(function () return '-25' % false end,
-           "^[^:]+:%d+: attempt to",
-           "'-25' % false")
+error_matches(function () return '-25' % false end,
+        "^[^:]+:%d+: attempt to",
+        "'-25' % false")
 
-error_like(function () return '3' ^ true end,
-           "^[^:]+:%d+: attempt to",
-           "'3' ^ true")
+error_matches(function () return '3' ^ true end,
+        "^[^:]+:%d+: attempt to",
+        "'3' ^ true")
 
-error_like(function () return '10' + 'text' end,
-           "^[^:]+:%d+: attempt to",
-           "'10' + 'text'")
+error_matches(function () return '10' + 'text' end,
+        "^[^:]+:%d+: attempt to",
+        "'10' + 'text'")
 
-error_like(function () return '2' - 'text' end,
-           "^[^:]+:%d+: attempt to",
-           "'2' - 'text'")
+error_matches(function () return '2' - 'text' end,
+        "^[^:]+:%d+: attempt to",
+        "'2' - 'text'")
 
-error_like(function () return '3.14' * 'text' end,
-           "^[^:]+:%d+: attempt to",
-           "'3.14' * 'text'")
+error_matches(function () return '3.14' * 'text' end,
+        "^[^:]+:%d+: attempt to",
+        "'3.14' * 'text'")
 
-error_like(function () return '-7' / 'text' end,
-           "^[^:]+:%d+: attempt to",
-           "'-7' / 'text'")
+error_matches(function () return '-7' / 'text' end,
+        "^[^:]+:%d+: attempt to",
+        "'-7' / 'text'")
 
-error_like(function () return '-25' % 'text' end,
-           "^[^:]+:%d+: attempt to",
-           "'-25' % 'text'")
+error_matches(function () return '-25' % 'text' end,
+        "^[^:]+:%d+: attempt to",
+        "'-25' % 'text'")
 
-error_like(function () return '3' ^ 'text' end,
-           "^[^:]+:%d+: attempt to",
-           "'3' ^ 'text'")
+error_matches(function () return '3' ^ 'text' end,
+        "^[^:]+:%d+: attempt to",
+        "'3' ^ 'text'")
 
 if profile.nocvts2n then
-    error_like(function () return '10' + '2' end,
-               "^[^:]+:%d+: attempt to",
-               "'10' + '2'")
+    error_matches(function () return '10' + '2' end,
+            "^[^:]+:%d+: attempt to",
+            "'10' + '2'")
 
-    error_like(function () return '2' - '10.5' end,
-               "^[^:]+:%d+: attempt to",
-               "'2' - '10.5'")
+    error_matches(function () return '2' - '10.5' end,
+            "^[^:]+:%d+: attempt to",
+            "'2' - '10.5'")
 
-    error_like(function () return '2' * '3' end,
-               "^[^:]+:%d+: attempt to",
-               "'2' * '3'")
+    error_matches(function () return '2' * '3' end,
+            "^[^:]+:%d+: attempt to",
+            "'2' * '3'")
 
-    error_like(function () return '3.14' * '1' end,
-               "^[^:]+:%d+: attempt to",
-               "'3.14' * '1'")
+    error_matches(function () return '3.14' * '1' end,
+            "^[^:]+:%d+: attempt to",
+            "'3.14' * '1'")
 
-    error_like(function () return '-7' / '0.5' end,
-               "^[^:]+:%d+: attempt to",
-               "'-7' / '0.5'")
+    error_matches(function () return '-7' / '0.5' end,
+            "^[^:]+:%d+: attempt to",
+            "'-7' / '0.5'")
 
-    error_like(function () return '-25' % '3' end,
-               "^[^:]+:%d+: attempt to",
-               "'-25' % '3'")
+    error_matches(function () return '-25' % '3' end,
+            "^[^:]+:%d+: attempt to",
+            "'-25' % '3'")
 
-    error_like(function () return '3' ^ '3' end,
-               "^[^:]+:%d+: attempt to",
-               "'3' ^ '3'")
+    error_matches(function () return '3' ^ '3' end,
+            "^[^:]+:%d+: attempt to",
+            "'3' ^ '3'")
 else
-    is('10' + '2', 12, "'10' + '2'")
+    equals('10' + '2', 12, "'10' + '2'")
 
-    is('2' - '10.5', -8.5, "'2' - '10.5'")
+    equals('2' - '10.5', -8.5, "'2' - '10.5'")
 
-    is('2' * '3', 6, "'2' * '3'")
+    equals('2' * '3', 6, "'2' * '3'")
 
-    is('3.14' * '1', 3.14, "'3.14' * '1'")
+    equals('3.14' * '1', 3.14, "'3.14' * '1'")
 
-    is('-7' / '0.5', -14, "'-7' / '0.5'")
+    equals('-7' / '0.5', -14, "'-7' / '0.5'")
 
-    is('-25' % '3', 2, "'-25' % '3'")
+    equals('-25' % '3', 2, "'-25' % '3'")
 
-    is('3' ^ '3', 27, "'3' ^ '3'")
+    equals('3' ^ '3', 27, "'3' ^ '3'")
 end
 
-is('1' .. 'end', '1end', "'1' .. 'end'")
+equals('1' .. 'end', '1end', "'1' .. 'end'")
 
 if profile.nocvtn2s then
-    error_like(function () return '1' .. 2 end,
-               "^[^:]+:%d+: attempt to concatenate a number value",
-               "'1' .. 2")
+    error_matches(function () return '1' .. 2 end,
+            "^[^:]+:%d+: attempt to concatenate a number value",
+            "'1' .. 2")
 else
-    is('1' .. 2, '12', "'1' .. 2")
+    equals('1' .. 2, '12', "'1' .. 2")
 end
 
-error_like(function () return '1' .. true end,
-           "^[^:]+:%d+: attempt to concatenate a boolean value",
-           "'1' .. true")
+error_matches(function () return '1' .. true end,
+        "^[^:]+:%d+: attempt to concatenate a boolean value",
+        "'1' .. true")
 
-is('foo\0bar' <= 'foo\0baz', true, "'foo\\0bar' <= 'foo\\0baz'")
+equals('foo\0bar' <= 'foo\0baz', true, "'foo\\0bar' <= 'foo\\0baz'")
 
-is('foo\0bar' ~= 'foo', true, "'foo\\0bar' ~= 'foo'")
+equals('foo\0bar' ~= 'foo', true, "'foo\\0bar' ~= 'foo'")
 
-is('foo\0bar' >= 'foo', true, "'foo\\0bar' >= 'foo'")
+equals('foo\0bar' >= 'foo', true, "'foo\\0bar' >= 'foo'")
 
-is('1.0' == '1', false, "'1.0' == '1'")
+equals('1.0' == '1', false, "'1.0' == '1'")
 
-is('1' ~= '2', true, "'1' ~= '2'")
+equals('1' ~= '2', true, "'1' ~= '2'")
 
-is('1' == true, false, "'1' == true")
+equals('1' == true, false, "'1' == true")
 
-is('1' ~= nil, true, "'1' ~= nil")
+equals('1' ~= nil, true, "'1' ~= nil")
 
-is('1' == 1, false, "'1' == 1")
+equals('1' == 1, false, "'1' == 1")
 
-is('1' ~= 1, true, "'1' ~= 1")
+equals('1' ~= 1, true, "'1' ~= 1")
 
-is('1' < '0', false, "'1' < '0'")
+equals('1' < '0', false, "'1' < '0'")
 
-is('1' <= '0', false, "'1' <= '0'")
+equals('1' <= '0', false, "'1' <= '0'")
 
-is('1' > '0', true, "'1' > '0'")
+equals('1' > '0', true, "'1' > '0'")
 
-is('1' >= '0', true, "'1' >= '0'")
+equals('1' >= '0', true, "'1' >= '0'")
 
-error_like(function () return '1' < false end,
-           "^[^:]+:%d+: attempt to compare %w+ with %w+",
-           "'1' < false")
+error_matches(function () return '1' < false end,
+        "^[^:]+:%d+: attempt to compare %w+ with %w+",
+        "'1' < false")
 
-error_like(function () return '1' <= nil end,
-           "^[^:]+:%d+: attempt to compare %w+ with %w+",
-           "'1' <= nil")
+error_matches(function () return '1' <= nil end,
+        "^[^:]+:%d+: attempt to compare %w+ with %w+",
+        "'1' <= nil")
 
-error_like(function () return '1' > true end,
-           "^[^:]+:%d+: attempt to compare %w+ with %w+",
-           "'1' > true")
+error_matches(function () return '1' > true end,
+        "^[^:]+:%d+: attempt to compare %w+ with %w+",
+        "'1' > true")
 
-error_like(function () return '1' >= {} end,
-           "^[^:]+:%d+: attempt to compare %w+ with %w+",
-           "'1' >= {}")
+error_matches(function () return '1' >= {} end,
+        "^[^:]+:%d+: attempt to compare %w+ with %w+",
+        "'1' >= {}")
 
-error_like(function () return '1' < 0 end,
-           "^[^:]+:%d+: attempt to compare %w+ with %w+",
-           "'1' < 0")
+error_matches(function () return '1' < 0 end,
+        "^[^:]+:%d+: attempt to compare %w+ with %w+",
+        "'1' < 0")
 
-error_like(function () return '1' <= 0 end,
-           "^[^:]+:%d+: attempt to compare %w+ with %w+",
-           "'1' <= 0")
+error_matches(function () return '1' <= 0 end,
+        "^[^:]+:%d+: attempt to compare %w+ with %w+",
+        "'1' <= 0")
 
-error_like(function () return '1' > 0 end,
-           "^[^:]+:%d+: attempt to compare %w+ with %w+",
-           "'1' > 0")
+error_matches(function () return '1' > 0 end,
+        "^[^:]+:%d+: attempt to compare %w+ with %w+",
+        "'1' > 0")
 
-error_like(function () return '1' > 0 end,
-           "^[^:]+:%d+: attempt to compare %w+ with %w+",
-           "'1' >== 0")
+error_matches(function () return '1' > 0 end,
+        "^[^:]+:%d+: attempt to compare %w+ with %w+",
+        "'1' >== 0")
 
 local a = 'text'
-is(a[1], nil, "index")
+equals(a[1], nil, "index")
 
-error_like(function () a = 'text'; a[1] = 1; end,
-           "^[^:]+:%d+: attempt to index",
-           "index")
+error_matches(function () a = 'text'; a[1] = 1; end,
+        "^[^:]+:%d+: attempt to index",
+        "index")
 
 if has_op53 then
     make_specific_checks'lexico53/string.t'
diff --git a/test/lua-Harness-tests/106-table.t b/test/lua-Harness-tests/106-table.t
index 667b9c8d..03d45085 100755
--- a/test/lua-Harness-tests/106-table.t
+++ b/test/lua-Harness-tests/106-table.t
@@ -2,7 +2,7 @@
 --
 -- lua-Harness : <https://fperrad.frama.io/lua-Harness/>
 --
--- Copyright (C) 2009-2018, Perrad Francois
+-- Copyright (C) 2009-2021, Perrad Francois
 --
 -- This code is licensed under the terms of the MIT/X11 license,
 -- like Lua itself.
@@ -27,99 +27,99 @@ local has_op53 = _VERSION >= 'Lua 5.3'
 
 plan'no_plan'
 
-error_like(function () return -{} end,
-           "^[^:]+:%d+: attempt to perform arithmetic on",
-           "-{}")
+error_matches(function () return -{} end,
+        "^[^:]+:%d+: attempt to perform arithmetic on",
+        "-{}")
 
-is(# {}, 0, "#{}")
-is(# {4,5,6}, 3)
+equals(# {}, 0, "#{}")
+equals(# {4,5,6}, 3)
 
-is(not {}, false, "not {}")
+equals(not {}, false, "not {}")
 
-error_like(function () return {} + 10 end,
-           "^[^:]+:%d+: attempt to perform arithmetic on",
-           "{} + 10")
+error_matches(function () return {} + 10 end,
+        "^[^:]+:%d+: attempt to perform arithmetic on",
+        "{} + 10")
 
-error_like(function () return {} - 2 end,
-           "^[^:]+:%d+: attempt to perform arithmetic on",
-           "{} - 2")
+error_matches(function () return {} - 2 end,
+        "^[^:]+:%d+: attempt to perform arithmetic on",
+        "{} - 2")
 
-error_like(function () return {} * 3.14 end,
-           "^[^:]+:%d+: attempt to perform arithmetic on",
-           "{} * 3.14")
+error_matches(function () return {} * 3.14 end,
+        "^[^:]+:%d+: attempt to perform arithmetic on",
+        "{} * 3.14")
 
-error_like(function () return {} / 7 end,
-           "^[^:]+:%d+: attempt to perform arithmetic on",
-           "{} / 7")
+error_matches(function () return {} / 7 end,
+        "^[^:]+:%d+: attempt to perform arithmetic on",
+        "{} / 7")
 
-error_like(function () return {} % 4 end,
-           "^[^:]+:%d+: attempt to perform arithmetic on",
-           "{} % 4")
+error_matches(function () return {} % 4 end,
+        "^[^:]+:%d+: attempt to perform arithmetic on",
+        "{} % 4")
 
-error_like(function () return {} ^ 3 end,
-           "^[^:]+:%d+: attempt to perform arithmetic on",
-           "{} ^ 3")
+error_matches(function () return {} ^ 3 end,
+        "^[^:]+:%d+: attempt to perform arithmetic on",
+        "{} ^ 3")
 
-error_like(function () return {} .. 'end' end,
-           "^[^:]+:%d+: attempt to concatenate",
-           "{} .. 'end'")
+error_matches(function () return {} .. 'end' end,
+        "^[^:]+:%d+: attempt to concatenate",
+        "{} .. 'end'")
 
-is({} == {}, false, "{} == {}")
+equals({} == {}, false, "{} == {}")
 
 local t1 = {}
 local t2 = {}
-is(t1 == t1, true, "t1 == t1")
-is(t1 == t2, false, "t1 == t2")
-is(t1 ~= t2, true, "t1 ~= t2")
+equals(t1 == t1, true, "t1 == t1")
+equals(t1 == t2, false, "t1 == t2")
+equals(t1 ~= t2, true, "t1 ~= t2")
 
-is({} == 1, false, "{} == 1")
+equals({} == 1, false, "{} == 1")
 
-is({} ~= 1, true, "{} ~= 1")
+equals({} ~= 1, true, "{} ~= 1")
 
-error_like(function () return t1 < t2 end,
-           "^[^:]+:%d+: attempt to compare two table values",
-           "t1 < t2")
+error_matches(function () return t1 < t2 end,
+        "^[^:]+:%d+: attempt to compare two table values",
+        "t1 < t2")
 
-error_like(function () return t1 <= t2 end,
-           "^[^:]+:%d+: attempt to compare two table values",
-           "t1 <= t2")
+error_matches(function () return t1 <= t2 end,
+        "^[^:]+:%d+: attempt to compare two table values",
+        "t1 <= t2")
 
-error_like(function () return t1 > t2 end,
-           "^[^:]+:%d+: attempt to compare two table values",
-           "t1 > t2")
+error_matches(function () return t1 > t2 end,
+        "^[^:]+:%d+: attempt to compare two table values",
+        "t1 > t2")
 
-error_like(function () return t1 >= t2 end,
-           "^[^:]+:%d+: attempt to compare two table values",
-           "t1 >= t2")
+error_matches(function () return t1 >= t2 end,
+        "^[^:]+:%d+: attempt to compare two table values",
+        "t1 >= t2")
 
-error_like(function () return {} < 0 end,
-           "^[^:]+:%d+: attempt to compare %w+ with %w+",
-           "{} < 0")
+error_matches(function () return {} < 0 end,
+        "^[^:]+:%d+: attempt to compare %w+ with %w+",
+        "{} < 0")
 
-error_like(function () return {} <= 0 end,
-           "^[^:]+:%d+: attempt to compare %w+ with %w+",
-           "{} <= 0")
+error_matches(function () return {} <= 0 end,
+        "^[^:]+:%d+: attempt to compare %w+ with %w+",
+        "{} <= 0")
 
-error_like(function () return {} > 0 end,
-           "^[^:]+:%d+: attempt to compare %w+ with %w+",
-           "{} > 0")
+error_matches(function () return {} > 0 end,
+        "^[^:]+:%d+: attempt to compare %w+ with %w+",
+        "{} > 0")
 
-error_like(function () return {} >= 0 end,
-           "^[^:]+:%d+: attempt to compare %w+ with %w+",
-           "{} >= 0")
+error_matches(function () return {} >= 0 end,
+        "^[^:]+:%d+: attempt to compare %w+ with %w+",
+        "{} >= 0")
 
 local t = {}
-is( t[1], nil, "index" )
+equals( t[1], nil, "index" )
 t[1] = 42
-is( t[1], 42, "index" )
+equals( t[1], 42, "index" )
 
-error_like(function () t = {}; t[nil] = 42 end,
-           "^[^:]+:%d+: table index is nil",
-           "table index is nil")
+error_matches(function () t = {}; t[nil] = 42 end,
+        "^[^:]+:%d+: table index is nil",
+        "table index is nil")
 
-error_like(function () t = {}; t[0/0] = 42 end,
-           "^[^:]+:%d+: table index is NaN",
-           "table index is NaN")
+error_matches(function () t = {}; t[0/0] = 42 end,
+        "^[^:]+:%d+: table index is NaN",
+        "table index is NaN")
 
 if has_op53 then
     make_specific_checks'lexico53/table.t'
diff --git a/test/lua-Harness-tests/107-thread.t b/test/lua-Harness-tests/107-thread.t
index 5c5bf22f..36003bab 100755
--- a/test/lua-Harness-tests/107-thread.t
+++ b/test/lua-Harness-tests/107-thread.t
@@ -2,7 +2,7 @@
 --
 -- lua-Harness : <https://fperrad.frama.io/lua-Harness/>
 --
--- Copyright (C) 2009-2018, Perrad Francois
+-- Copyright (C) 2009-2021, Perrad Francois
 --
 -- This code is licensed under the terms of the MIT/X11 license,
 -- like Lua itself.
@@ -29,97 +29,97 @@ plan'no_plan'
 
 local co = coroutine.create(function () return 1 end)
 
-error_like(function () return -co end,
-           "^[^:]+:%d+: attempt to perform arithmetic on",
-           "-co")
+error_matches(function () return -co end,
+        "^[^:]+:%d+: attempt to perform arithmetic on",
+        "-co")
 
-error_like(function () return #co end,
-           "^[^:]+:%d+: attempt to get length of",
-           "#co")
+error_matches(function () return #co end,
+        "^[^:]+:%d+: attempt to get length of",
+        "#co")
 
-is(not co, false, "not co")
+equals(not co, false, "not co")
 
-error_like(function () return co + 10 end,
-           "^[^:]+:%d+: attempt to perform arithmetic on",
-           "co + 10")
+error_matches(function () return co + 10 end,
+        "^[^:]+:%d+: attempt to perform arithmetic on",
+        "co + 10")
 
-error_like(function () return co - 2 end,
-           "^[^:]+:%d+: attempt to perform arithmetic on",
-           "co - 2")
+error_matches(function () return co - 2 end,
+        "^[^:]+:%d+: attempt to perform arithmetic on",
+        "co - 2")
 
-error_like(function () return co * 3.14 end,
-           "^[^:]+:%d+: attempt to perform arithmetic on",
-           "co * 3.14")
+error_matches(function () return co * 3.14 end,
+        "^[^:]+:%d+: attempt to perform arithmetic on",
+        "co * 3.14")
 
-error_like(function () return co / 7 end,
-           "^[^:]+:%d+: attempt to perform arithmetic on",
-           "co / 7")
+error_matches(function () return co / 7 end,
+        "^[^:]+:%d+: attempt to perform arithmetic on",
+        "co / 7")
 
-error_like(function () return co % 4 end,
-           "^[^:]+:%d+: attempt to perform arithmetic on",
-           "co % 4")
+error_matches(function () return co % 4 end,
+        "^[^:]+:%d+: attempt to perform arithmetic on",
+        "co % 4")
 
-error_like(function () return co ^ 3 end,
-           "^[^:]+:%d+: attempt to perform arithmetic on",
-           "co ^ 3")
+error_matches(function () return co ^ 3 end,
+        "^[^:]+:%d+: attempt to perform arithmetic on",
+        "co ^ 3")
 
-error_like(function () return co .. 'end' end,
-           "^[^:]+:%d+: attempt to concatenate",
-           "co .. 'end'")
+error_matches(function () return co .. 'end' end,
+        "^[^:]+:%d+: attempt to concatenate",
+        "co .. 'end'")
 
-is(co == co, true, "co == co")
+equals(co == co, true, "co == co")
 
 local co1 = coroutine.create(function () return 1 end)
 local co2 = coroutine.create(function () return 2 end)
-is(co1 ~= co2, true, "co1 ~= co2")
+equals(co1 ~= co2, true, "co1 ~= co2")
 
-is(co == 1, false, "co == 1")
+equals(co == 1, false, "co == 1")
 
-is(co ~= 1, true, "co ~= 1")
+equals(co ~= 1, true, "co ~= 1")
 
-error_like(function () return co1 < co2 end,
-           "^[^:]+:%d+: attempt to compare two thread values",
-           "co1 < co2")
+error_matches(function () return co1 < co2 end,
+        "^[^:]+:%d+: attempt to compare two thread values",
+        "co1 < co2")
 
-error_like(function () return co1 <= co2 end,
-           "^[^:]+:%d+: attempt to compare two thread values",
-           "co1 <= co2")
+error_matches(function () return co1 <= co2 end,
+        "^[^:]+:%d+: attempt to compare two thread values",
+        "co1 <= co2")
 
-error_like(function () return co1 > co2 end,
-           "^[^:]+:%d+: attempt to compare two thread values",
-           "co1 > co2")
+error_matches(function () return co1 > co2 end,
+        "^[^:]+:%d+: attempt to compare two thread values",
+        "co1 > co2")
 
-error_like(function () return co1 >= co2 end,
-           "^[^:]+:%d+: attempt to compare two thread values",
-           "co1 >= co2")
+error_matches(function () return co1 >= co2 end,
+        "^[^:]+:%d+: attempt to compare two thread values",
+        "co1 >= co2")
 
-error_like(function () return co < 0 end,
-           "^[^:]+:%d+: attempt to compare %w+ with %w+",
-           "co < 0")
+error_matches(function () return co < 0 end,
+        "^[^:]+:%d+: attempt to compare %w+ with %w+",
+        "co < 0")
 
-error_like(function () return co <= 0 end,
-           "^[^:]+:%d+: attempt to compare %w+ with %w+",
-           "co <= 0")
+error_matches(function () return co <= 0 end,
+        "^[^:]+:%d+: attempt to compare %w+ with %w+",
+        "co <= 0")
 
-error_like(function () return co > 0 end,
-           "^[^:]+:%d+: attempt to compare %w+ with %w+",
-           "co > 0")
+error_matches(function () return co > 0 end,
+        "^[^:]+:%d+: attempt to compare %w+ with %w+",
+        "co > 0")
 
-error_like(function () return co > 0 end,
-           "^[^:]+:%d+: attempt to compare %w+ with %w+",
-           "co >= 0")
+error_matches(function () return co > 0 end,
+        "^[^:]+:%d+: attempt to compare %w+ with %w+",
+        "co >= 0")
 
-error_like(function () local a = co[1] end,
-           "^[^:]+:%d+: attempt to index",
-           "index")
+error_matches(function () local a = co[1] end,
+        "^[^:]+:%d+: attempt to index",
+        "index")
 
-error_like(function () co[1] = 1 end,
-           "^[^:]+:%d+: attempt to index",
-           "index")
+error_matches(function () co[1] = 1 end,
+        "^[^:]+:%d+: attempt to index",
+        "index")
 
 local t = {}
 t[co] = true
-ok(t[co])
+truthy(t[co])
 
 if has_op53 then
     make_specific_checks'lexico53/thread.t'
diff --git a/test/lua-Harness-tests/108-userdata.t b/test/lua-Harness-tests/108-userdata.t
index 48a5f60f..41b820d3 100755
--- a/test/lua-Harness-tests/108-userdata.t
+++ b/test/lua-Harness-tests/108-userdata.t
@@ -2,7 +2,7 @@
 --
 -- lua-Harness : <https://fperrad.frama.io/lua-Harness/>
 --
--- Copyright (C) 2009-2018, Perrad Francois
+-- Copyright (C) 2009-2021, Perrad Francois
 --
 -- This code is licensed under the terms of the MIT/X11 license,
 -- like Lua itself.
@@ -29,94 +29,94 @@ plan'no_plan'
 
 local u = io.stdin
 
-error_like(function () return -u end,
-           "^[^:]+:%d+: attempt to perform arithmetic on",
-           "-u")
+error_matches(function () return -u end,
+        "^[^:]+:%d+: attempt to perform arithmetic on",
+        "-u")
 
-error_like(function () return #u end,
-           "^[^:]+:%d+: attempt to get length of",
-           "#u")
+error_matches(function () return #u end,
+        "^[^:]+:%d+: attempt to get length of",
+        "#u")
 
-is(not u, false, "not u")
+equals(not u, false, "not u")
 
-error_like(function () return u + 10 end,
-           "^[^:]+:%d+: attempt to perform arithmetic on",
-           "u + 10")
+error_matches(function () return u + 10 end,
+        "^[^:]+:%d+: attempt to perform arithmetic on",
+        "u + 10")
 
-error_like(function () return u - 2 end,
-           "^[^:]+:%d+: attempt to perform arithmetic on",
-           "u - 2")
+error_matches(function () return u - 2 end,
+        "^[^:]+:%d+: attempt to perform arithmetic on",
+        "u - 2")
 
-error_like(function () return u * 3.14 end,
-           "^[^:]+:%d+: attempt to perform arithmetic on",
-           "u * 3.14")
+error_matches(function () return u * 3.14 end,
+        "^[^:]+:%d+: attempt to perform arithmetic on",
+        "u * 3.14")
 
-error_like(function () return u / 7 end,
-           "^[^:]+:%d+: attempt to perform arithmetic on",
-           "u / 7")
+error_matches(function () return u / 7 end,
+        "^[^:]+:%d+: attempt to perform arithmetic on",
+        "u / 7")
 
-error_like(function () return u % 4 end,
-           "^[^:]+:%d+: attempt to perform arithmetic on",
-           "u % 4")
+error_matches(function () return u % 4 end,
+        "^[^:]+:%d+: attempt to perform arithmetic on",
+        "u % 4")
 
-error_like(function () return u ^ 3 end,
-           "^[^:]+:%d+: attempt to perform arithmetic on",
-           "u ^ 3")
+error_matches(function () return u ^ 3 end,
+        "^[^:]+:%d+: attempt to perform arithmetic on",
+        "u ^ 3")
 
-error_like(function () return u .. 'end' end,
-           "^[^:]+:%d+: attempt to concatenate",
-           "u .. 'end'")
+error_matches(function () return u .. 'end' end,
+        "^[^:]+:%d+: attempt to concatenate",
+        "u .. 'end'")
 
-is(u == u, true, "u == u")
+equals(u == u, true, "u == u")
 
 local v = io.stdout
-is(u ~= v, true, "u ~= v")
+equals(u ~= v, true, "u ~= v")
 
-is(u == 1, false, "u == 1")
+equals(u == 1, false, "u == 1")
 
-is(u ~= 1, true, "u ~= 1")
+equals(u ~= 1, true, "u ~= 1")
 
-error_like(function () return u < v end,
-           "^[^:]+:%d+: attempt to compare two",
-           "u < v")
+error_matches(function () return u < v end,
+        "^[^:]+:%d+: attempt to compare two",
+        "u < v")
 
-error_like(function () return u <= v end,
-           "^[^:]+:%d+: attempt to compare two",
-           "u <= v")
+error_matches(function () return u <= v end,
+        "^[^:]+:%d+: attempt to compare two",
+        "u <= v")
 
-error_like(function () return u > v end,
-           "^[^:]+:%d+: attempt to compare two",
-           "u > v")
+error_matches(function () return u > v end,
+        "^[^:]+:%d+: attempt to compare two",
+        "u > v")
 
-error_like(function () return u >= v end,
-           "^[^:]+:%d+: attempt to compare two",
-           "u >= v")
+error_matches(function () return u >= v end,
+        "^[^:]+:%d+: attempt to compare two",
+        "u >= v")
 
-error_like(function () return u < 0 end,
-           "^[^:]+:%d+: attempt to compare",
-           "u < 0")
+error_matches(function () return u < 0 end,
+        "^[^:]+:%d+: attempt to compare",
+        "u < 0")
 
-error_like(function () return u <= 0 end,
-           "^[^:]+:%d+: attempt to compare",
-           "u <= 0")
+error_matches(function () return u <= 0 end,
+        "^[^:]+:%d+: attempt to compare",
+        "u <= 0")
 
-error_like(function () return u > 0 end,
-           "^[^:]+:%d+: attempt to compare",
-           "u > 0")
+error_matches(function () return u > 0 end,
+        "^[^:]+:%d+: attempt to compare",
+        "u > 0")
 
-error_like(function () return u > 0 end,
-           "^[^:]+:%d+: attempt to compare",
-           "u >= 0")
+error_matches(function () return u > 0 end,
+        "^[^:]+:%d+: attempt to compare",
+        "u >= 0")
 
-is(u[1], nil, "index")
+equals(u[1], nil, "index")
 
-error_like(function () u[1] = 1 end,
-           "^[^:]+:%d+: attempt to index",
-           "index")
+error_matches(function () u[1] = 1 end,
+        "^[^:]+:%d+: attempt to index",
+        "index")
 
 local t = {}
 t[u] = true
-ok(t[u])
+truthy(t[u])
 
 if has_op53 then
     make_specific_checks'lexico53/userdata.t'
diff --git a/test/lua-Harness-tests/200-examples.t b/test/lua-Harness-tests/200-examples.t
index 362aae3a..708ee3bd 100755
--- a/test/lua-Harness-tests/200-examples.t
+++ b/test/lua-Harness-tests/200-examples.t
@@ -2,7 +2,7 @@
 --
 -- lua-Harness : <https://fperrad.frama.io/lua-Harness/>
 --
--- Copyright (C) 2009-2018, Perrad Francois
+-- Copyright (C) 2009-2021, Perrad Francois
 --
 -- This code is licensed under the terms of the MIT/X11 license,
 -- like Lua itself.
@@ -35,7 +35,7 @@ function factorial (n)
         return n * factorial(n-1)
     end
 end
-is(factorial(7), 5040, "factorial (recursive)")
+equals(factorial(7), 5040, "factorial (recursive)")
 
 local function local_factorial (n)
     if n == 0 then
@@ -44,7 +44,7 @@ local function local_factorial (n)
         return n * local_factorial(n-1)
     end
 end
-is(local_factorial(7), 5040, "factorial (recursive)")
+equals(local_factorial(7), 5040, "factorial (recursive)")
 
 local function loop_factorial (n)
     local a = 1
@@ -53,7 +53,7 @@ local function loop_factorial (n)
     end
     return a
 end
-is(loop_factorial(7), 5040, "factorial (loop)")
+equals(loop_factorial(7), 5040, "factorial (loop)")
 
 local function iter_factorial (n)
     local function iter (product, counter)
@@ -65,7 +65,7 @@ local function iter_factorial (n)
     end
     return iter(1, 1)
 end
-is(iter_factorial(7), 5040, "factorial (iter)")
+equals(iter_factorial(7), 5040, "factorial (iter)")
 
 --[[
 
@@ -86,7 +86,7 @@ local function A (k, x1, x2, x3, x4, x5)
     end
 end
 
-is(A(10,
+equals(A(10,
         function () return 1 end,
         function () return -1 end,
         function () return -1 end,
diff --git a/test/lua-Harness-tests/201-assign.t b/test/lua-Harness-tests/201-assign.t
index 7d023d8e..3e978091 100755
--- a/test/lua-Harness-tests/201-assign.t
+++ b/test/lua-Harness-tests/201-assign.t
@@ -2,7 +2,7 @@
 --
 -- lua-Harness : <https://fperrad.frama.io/lua-Harness/>
 --
--- Copyright (C) 2009-2020, Perrad Francois
+-- Copyright (C) 2009-2021, Perrad Francois
 --
 -- This code is licensed under the terms of the MIT/X11 license,
 -- like Lua itself.
@@ -34,19 +34,19 @@ local has_env = _VERSION >= 'Lua 5.2'
 plan'no_plan'
 
 do
-    is(b, nil, "global variable")
+    equals(b, nil, "global variable")
     b = 10
-    is(b, 10)
+    equals(b, 10)
     if has_env then
-        is(_ENV.b, 10, "_ENV")
-        is(_G, _ENV, "_G")
-        error_like([[ _ENV = nil; b = 20 ]],
-                   "attempt to ")
+        equals(_ENV.b, 10, "_ENV")
+        equals(_G, _ENV, "_G")
+        error_matches([[ _ENV = nil; b = 20 ]],
+                "attempt to ")
     else
-        is(_ENV, nil, "no _ENV");
+        equals(_ENV, nil, "no _ENV");
     end
     b = nil
-    is(b, nil)
+    equals(b, nil)
 end
 
 do
@@ -55,39 +55,39 @@ do
     i, a[i] = i+1, 20
     -- this behavior is undefined
     -- see http://lua-users.org/lists/lua-l/2006-06/msg00378.html
-    is(i, 4, "check eval")
-    is(a[3], 20)
+    equals(i, 4, "check eval")
+    equals(a[3], 20)
 end
 
 do
     local x = 1.
     local y = 2.
     x, y = y, x -- swap
-    is(x, 2, "check swap")
-    is(y, 1)
+    equals(x, 2, "check swap")
+    equals(y, 1)
 end
 
 do
     local a, b, c = 0, 1
-    is(a, 0, "check padding")
-    is(b, 1)
-    is(c, nil)
+    equals(a, 0, "check padding")
+    equals(b, 1)
+    equals(c, nil)
     a, b = a+1, b+1, a+b
-    is(a, 1)
-    is(b, 2)
+    equals(a, 1)
+    equals(b, 2)
     a, b, c = 0
-    is(a, 0)
-    is(b, nil)
-    is(c, nil)
+    equals(a, 0)
+    equals(b, nil)
+    equals(c, nil)
 end
 
 do
     local function f() return 1, 2 end
     local a, b, c, d = f()
-    is(a, 1, "adjust with function")
-    is(b, 2)
-    is(c, nil)
-    is(d, nil)
+    equals(a, 1, "adjust with function")
+    equals(b, 2)
+    equals(c, nil)
+    equals(d, nil)
 end
 
 do
@@ -95,37 +95,37 @@ do
     local a = 2
     local b, c
     a, b, c = f(), 3
-    is(a, nil, "padding with function")
-    is(b, 3)
-    is(c, nil)
+    equals(a, nil, "padding with function")
+    equals(b, 3)
+    equals(c, nil)
 end
 
 do
     local my_i = 1
-    is(my_i, 1, "local variable")
+    equals(my_i, 1, "local variable")
     local my_i = 2
-    is(my_i, 2)
+    equals(my_i, 2)
 end
 
 do
     local i = 1
     local j = i
-    is(i, 1, "local variable")
-    is(j, 1)
+    equals(i, 1, "local variable")
+    equals(j, 1)
     j = 2
-    is(i, 1)
-    is(j, 2)
+    equals(i, 1)
+    equals(j, 2)
 end
 
 do
     local function f(x) return 2*x end
-    is(f(2), 4, "param & result of function")
+    equals(f(2), 4, "param & result of function")
     local a = 2
     a = f(a)
-    is(a, 4)
+    equals(a, 4)
     local b = 2
     b = f(b)
-    is(b, 4)
+    equals(b, 4)
 end
 
 do
@@ -134,10 +134,10 @@ do
     local n3 = 3
     local n4 = 4
     n1,n2,n3,n4 = n4,n3,n2,n1
-    is(n1, 4, "assignment list swap values")
-    is(n2, 3)
-    is(n3, 2)
-    is(n4, 1)
+    equals(n1, 4, "assignment list swap values")
+    equals(n2, 3)
+    equals(n3, 2)
+    equals(n4, 1)
 end
 
 done_testing()
diff --git a/test/lua-Harness-tests/202-expr.t b/test/lua-Harness-tests/202-expr.t
index 25767507..f86276af 100755
--- a/test/lua-Harness-tests/202-expr.t
+++ b/test/lua-Harness-tests/202-expr.t
@@ -2,7 +2,7 @@
 --
 -- lua-Harness : <https://fperrad.frama.io/lua-Harness/>
 --
--- Copyright (C) 2009-2020, Perrad Francois
+-- Copyright (C) 2009-2021, Perrad Francois
 --
 -- This code is licensed under the terms of the MIT/X11 license,
 -- like Lua itself.
@@ -36,115 +36,115 @@ local nocvts2n = profile.nocvts2n
 plan'no_plan'
 
 local x = math.pi
-is(tostring(x - x%0.0001), tostring(3.1415), "modulo")
+equals(tostring(x - x%0.0001), tostring(3.1415), "modulo")
 
 local a = {}; a.x = 1; a.y = 0;
 local b = {}; b.x = 1; b.y = 0;
 local c = a
-is(a == c, true, "relational op (by reference)")
-is(a ~= b, true)
-
-is('0' == 0, false, "relational op")
-is(2 < 15, true)
-is('2' < '15', false)
-
-error_like(function () return 2 < '15' end,
-           "compare",
-           "relational op")
-
-error_like(function () return '2' < 15 end,
-           "compare",
-           "relational op")
-
-is(4 and 5, 5, "logical op")
-is(nil and 13, nil)
-is(false and 13, false)
-is(4 or 5, 4)
-is(false or 5, 5)
-is(false or 'text', 'text')
-
-is(10 or 20, 10, "logical op")
-is(10 or error(), 10)
-is(nil or 'a', 'a')
-is(nil and 10, nil)
-is(false and error(), false)
-is(false and nil, false)
-is(false or nil, nil)
-is(10 and 20, 20)
-
-is(not nil, true, "logical not")
-is(not false, true)
-is(not 0, false)
-is(not not nil, false)
-is(not 'text', false)
+equals(a == c, true, "relational op (by reference)")
+equals(a ~= b, true)
+
+equals('0' == 0, false, "relational op")
+equals(2 < 15, true)
+equals('2' < '15', false)
+
+error_matches(function () return 2 < '15' end,
+        "compare",
+        "relational op")
+
+error_matches(function () return '2' < 15 end,
+        "compare",
+        "relational op")
+
+equals(4 and 5, 5, "logical op")
+equals(nil and 13, nil)
+equals(false and 13, false)
+equals(4 or 5, 4)
+equals(false or 5, 5)
+equals(false or 'text', 'text')
+
+equals(10 or 20, 10, "logical op")
+equals(10 or error(), 10)
+equals(nil or 'a', 'a')
+equals(nil and 10, nil)
+equals(false and error(), false)
+equals(false and nil, false)
+equals(false or nil, nil)
+equals(10 and 20, 20)
+
+equals(not nil, true, "logical not")
+equals(not false, true)
+equals(not 0, false)
+equals(not not nil, false)
+equals(not 'text', false)
 a = {}
-is(not a, false)
-is(not (a == a), false)
-is(not (a ~= a), true)
+equals(not a, false)
+equals(not (a == a), false)
+equals(not (a ~= a), true)
 
-is("Hello " .. "World", "Hello World", "concatenation")
+equals("Hello " .. "World", "Hello World", "concatenation")
 if not nocvtn2s then
-    is(0 .. 1, '01')
+    equals(0 .. 1, '01')
 end
 a = "Hello"
-is(a .. " World", "Hello World")
-is(a, "Hello")
+equals(a .. " World", "Hello World")
+equals(a, "Hello")
 
 if not nocvts2n then
-    is('10' + 1, 11, "coercion")
-    is('-5.3' * '2', -10.6)
+    equals('10' + 1, 11, "coercion")
+    equals('-5.3' * '2', -10.6)
 end
-is(tostring(10), '10')
+equals(tostring(10), '10')
 if not nocvtn2s then
-    is(10 .. 20, '1020')
-    is(10 .. '', '10')
+    equals(10 .. 20, '1020')
+    equals(10 .. '', '10')
 end
 
-error_like(function () return 'hello' + 1 end,
-           ((not nocvts2n and _VERSION >= 'Lua 5.4') or ravi) and "attempt to add" or "perform arithmetic",
-           "no coercion")
+error_matches(function () return 'hello' + 1 end,
+        ((not nocvts2n and _VERSION >= 'Lua 5.4') or ravi) and "attempt to add" or "perform arithmetic",
+        "no coercion")
 
-error_like(function ()
+error_matches(function ()
                 local function first() return end
                 local function limit() return 2 end
                 local function step()  return 1 end
                 for i = first(), limit(), step() do
                     print(i)
                 end
-           end,
-           "^[^:]+:%d+:.- 'for' initial value",
-           "for tonumber")
+        end,
+        "^[^:]+:%d+:.- 'for' initial value",
+        "for tonumber")
 
-error_like(function ()
+error_matches(function ()
                 local function first() return 1 end
                 local function limit() return end
                 local function step()  return 2 end
                 for i = first(), limit(), step() do
                     print(i)
                 end
-           end,
-           "^[^:]+:%d+:.- 'for' limit",
-           "for tonumber")
+        end,
+        "^[^:]+:%d+:.- 'for' limit",
+        "for tonumber")
 
-error_like(function ()
+error_matches(function ()
                 local function first() return 1 end
                 local function limit() return 2 end
                 local function step()  return end
                 for i = first(), limit(), step() do
                     print(i)
                 end
-           end,
-           "^[^:]+:%d+:.- 'for' step",
-           "for tonumber")
+        end,
+        "^[^:]+:%d+:.- 'for' step",
+        "for tonumber")
 
 if _VERSION >= 'Lua 5.4' then
-    error_like(function ()
+    error_matches(function ()
                     for i = 1, 10, 0 do
                         print(i)
                     end
-               end,
-               "^[^:]+:%d+: 'for' step is zero",
-               "for step zero")
+            end,
+            "^[^:]+:%d+: 'for' step is zero",
+            "for step zero")
 end
 
 done_testing()
diff --git a/test/lua-Harness-tests/203-lexico.t b/test/lua-Harness-tests/203-lexico.t
index 7f554820..6143615c 100755
--- a/test/lua-Harness-tests/203-lexico.t
+++ b/test/lua-Harness-tests/203-lexico.t
@@ -2,7 +2,7 @@
 --
 -- lua-Harness : <https://fperrad.frama.io/lua-Harness/>
 --
--- Copyright (C) 2010-2020, Perrad Francois
+-- Copyright (C) 2010-2021, Perrad Francois
 --
 -- This code is licensed under the terms of the MIT/X11 license,
 -- like Lua itself.
@@ -37,71 +37,71 @@ local luajit21 = jit and (jit.version_num >= 20100 or jit.version:match'^RaptorJ
 
 plan'no_plan'
 
-is("\65", "A")
-is("\065", "A")
+equals("\65", "A")
+equals("\065", "A")
 
-is(string.byte("\a"), 7)
-is(string.byte("\b"), 8)
-is(string.byte("\f"), 12)
-is(string.byte("\n"), 10)
-is(string.byte("\r"), 13)
-is(string.byte("\t"), 9)
-is(string.byte("\v"), 11)
-is(string.byte("\\"), 92)
+equals(string.byte("\a"), 7)
+equals(string.byte("\b"), 8)
+equals(string.byte("\f"), 12)
+equals(string.byte("\n"), 10)
+equals(string.byte("\r"), 13)
+equals(string.byte("\t"), 9)
+equals(string.byte("\v"), 11)
+equals(string.byte("\\"), 92)
 
-is(string.len("A\0B"), 3)
+equals(string.len("A\0B"), 3)
 
 do
     local f, msg = loadstring [[a = "A\300"]]
     if _VERSION == 'Lua 5.1' then
-        like(msg, "^[^:]+:%d+: .- near")
+        matches(msg, "^[^:]+:%d+: .- near")
     else
-        like(msg, "^[^:]+:%d+: .- escape .- near")
+        matches(msg, "^[^:]+:%d+: .- escape .- near")
     end
 
     f, msg = loadstring [[a = " unfinished string ]]
-    like(msg, "^[^:]+:%d+: unfinished string near")
+    matches(msg, "^[^:]+:%d+: unfinished string near")
 
     f, msg = loadstring [[a = " unfinished string
 ]]
-    like(msg, "^[^:]+:%d+: unfinished string near")
+    matches(msg, "^[^:]+:%d+: unfinished string near")
 
     f, msg = loadstring [[a = " unfinished string \
 ]]
-    like(msg, "^[^:]+:%d+: unfinished string near")
+    matches(msg, "^[^:]+:%d+: unfinished string near")
 
     f, msg = loadstring [[a = " unfinished string \]]
-    like(msg, "^[^:]+:%d+: unfinished string near")
+    matches(msg, "^[^:]+:%d+: unfinished string near")
 
     f, msg = loadstring "a = [[ unfinished long string "
-    like(msg, "^[^:]+:%d+: unfinished long string .-near")
+    matches(msg, "^[^:]+:%d+: unfinished long string .-near")
 
     f, msg = loadstring "a = [== invalid long string delimiter "
-    like(msg, "^[^:]+:%d+: invalid long string delimiter near")
+    matches(msg, "^[^:]+:%d+: invalid long string delimiter near")
 end
 
 do
     local a = 'alo\n123"'
-    is('alo\n123"', a)
-    is("alo\n123\"", a)
-    is('\97lo\10\04923"', a)
-    is([[alo
+    equals('alo\n123"', a)
+    equals("alo\n123\"", a)
+    equals('\97lo\10\04923"', a)
+    equals([[alo
 123"]], a)
-    is([==[
+    equals([==[
 alo
 123"]==], a)
 end
 
-is(3.0, 3)
-is(314.16e-2, 3.1416)
-is(0.31416E1, 3.1416)
-is(.3, 0.3)
-is(0xff, 255)
-is(0x56, 86)
+equals(3.0, 3)
+equals(314.16e-2, 3.1416)
+equals(0.31416E1, 3.1416)
+equals(.3, 0.3)
+equals(0xff, 255)
+equals(0x56, 86)
 
 do
     local f, msg = loadstring [[a = 12e34e56]]
-    like(msg, "^[^:]+:%d+: malformed number near")
+    matches(msg, "^[^:]+:%d+: malformed number near")
 end
 
 --[===[
@@ -114,7 +114,7 @@ end
 
 do
     local f, msg = loadstring "  --[[ unfinished long comment "
-    like(msg, "^[^:]+:%d+: unfinished long comment .-near")
+    matches(msg, "^[^:]+:%d+: unfinished long comment .-near")
 end
 
 if _VERSION >= 'Lua 5.2' or jit then
diff --git a/test/lua-Harness-tests/204-grammar.t b/test/lua-Harness-tests/204-grammar.t
index d9ae3a6f..c34fd28c 100755
--- a/test/lua-Harness-tests/204-grammar.t
+++ b/test/lua-Harness-tests/204-grammar.t
@@ -2,7 +2,7 @@
 --
 -- lua-Harness : <https://fperrad.frama.io/lua-Harness/>
 --
--- Copyright (C) 2010-2020, Perrad Francois
+-- Copyright (C) 2010-2021, Perrad Francois
 --
 -- This code is licensed under the terms of the MIT/X11 license,
 -- like Lua itself.
@@ -39,19 +39,19 @@ plan'no_plan'
 do --[[ empty statement ]]
     local f, msg = loadstring [[; a = 1]]
     if _VERSION == 'Lua 5.1' and not profile.luajit_compat52 then
-        like(msg, "^[^:]+:%d+: unexpected symbol near ';'", "empty statement")
+        matches(msg, "^[^:]+:%d+: unexpected symbol near ';'", "empty statement")
     else
-        type_ok(f, 'function', "empty statement")
+        is_function(f, "empty statement")
     end
 
     f = loadstring [[a = 1; a = 2]]
-    type_ok(f, 'function')
+    is_function(f)
 
     f, msg = loadstring [[a = 1;;; a = 2]]
     if _VERSION == 'Lua 5.1' and not profile.luajit_compat52 then
-        like(msg, "^[^:]+:%d+: unexpected symbol near ';'")
+        matches(msg, "^[^:]+:%d+: unexpected symbol near ';'")
     else
-        type_ok(f, 'function')
+        is_function(f)
     end
 end
 
@@ -67,11 +67,11 @@ function f()
 end
 ]]
     if _VERSION == 'Lua 5.1' then
-        like(msg, "^[^:]+:%d+: no loop to break", "orphan break")
+        matches(msg, "^[^:]+:%d+: no loop to break", "orphan break")
     elseif _VERSION <= 'Lua 5.3' then
-        like(msg, "^[^:]+:%d+: <break> at line 5 not inside a loop", "orphan break")
+        matches(msg, "^[^:]+:%d+: <break> at line 5 not inside a loop", "orphan break")
     else
-        like(msg, "^[^:]+:%d+: break outside loop at line 5", "orphan break")
+        matches(msg, "^[^:]+:%d+: break outside loop at line 5", "orphan break")
     end
 end
 
@@ -88,9 +88,9 @@ function f()
 end
 ]]
     if _VERSION == 'Lua 5.1' and not profile.luajit_compat52 then
-        like(msg, "^[^:]+:%d+: 'end' expected %(to close 'while' at line 3%) near 'print'", "break anywhere")
+        matches(msg, "^[^:]+:%d+: 'end' expected %(to close 'while' at line 3%) near 'print'", "break anywhere")
     else
-        type_ok(f, 'function', "break anywhere")
+        is_function(f, "break anywhere")
     end
 
     f, msg = loadstring [[
@@ -107,9 +107,9 @@ function f()
 end
 ]]
     if _VERSION == 'Lua 5.1' and not profile.luajit_compat52 then
-        like(msg, "^[^:]+:%d+: 'end' expected %(to close 'if' at line 5%) near 'print'", "break anywhere")
+        matches(msg, "^[^:]+:%d+: 'end' expected %(to close 'if' at line 5%) near 'print'", "break anywhere")
     else
-        type_ok(f, 'function', "break anywhere")
+        is_function(f, "break anywhere")
     end
 end
 
@@ -120,9 +120,9 @@ if has_goto then
     goto unknown
 ]]
     if jit then
-        like(msg, ":%d+: undefined label 'unknown'", "unknown goto")
+        matches(msg, ":%d+: undefined label 'unknown'", "unknown goto")
     else
-        like(msg, ":%d+: no visible label 'unknown' for <goto> at line %d+", "unknown goto")
+        matches(msg, ":%d+: no visible label 'unknown' for <goto> at line %d+", "unknown goto")
     end
 
     f, msg = loadstring [[
@@ -131,9 +131,9 @@ if has_goto then
 ::label::
 ]]
     if jit then
-        like(msg, ":%d+: duplicate label 'label'", "duplicate label")
+        matches(msg, ":%d+: duplicate label 'label'", "duplicate label")
     else
-        like(msg, ":%d+: label 'label' already defined on line %d+", "duplicate label")
+        matches(msg, ":%d+: label 'label' already defined on line %d+", "duplicate label")
     end
 
     f, msg = loadstring [[
@@ -144,9 +144,9 @@ if has_goto then
     goto e
 ]]
     if jit then
-        like(msg, ":%d+: <goto f> jumps into the scope of local 'x'", "bad goto")
+        matches(msg, ":%d+: <goto f> jumps into the scope of local 'x'", "bad goto")
     else
-        like(msg, ":%d+: <goto f> at line %d+ jumps into the scope of local 'x'", "bad goto")
+        matches(msg, ":%d+: <goto f> at line %d+ jumps into the scope of local 'x'", "bad goto")
     end
 
     f= loadstring [[
@@ -160,67 +160,67 @@ do
 ::s3::
 end
 ]]
-    type_ok(f, 'function', "goto")
+    is_function(f, "goto")
 else
     diag("no goto")
 end
 
 do --[[ syntax error ]]
     local f, msg = loadstring [[a = { 1, 2, 3)]]
-    like(msg, ":%d+: '}' expected near '%)'", "constructor { }")
+    matches(msg, ":%d+: '}' expected near '%)'", "constructor { }")
 
     f, msg = loadstring [[a = (1 + 2}]]
-    like(msg, ":%d+: '%)' expected near '}'", "expr ( )")
+    matches(msg, ":%d+: '%)' expected near '}'", "expr ( )")
 
     f, msg = loadstring [[a = f(1, 2}]]
-    like(msg, ":%d+: '%)' expected near '}'", "expr ( )")
+    matches(msg, ":%d+: '%)' expected near '}'", "expr ( )")
 
     f, msg = loadstring [[function f () return 1]]
-    like(msg, ":%d+: 'end' expected near '?<eof>'?", "function end")
+    matches(msg, ":%d+: 'end' expected near '?<eof>'?", "function end")
 
     f, msg = loadstring [[do local a = f()]]
-    like(msg, ":%d+: 'end' expected near '?<eof>'?", "do end")
+    matches(msg, ":%d+: 'end' expected near '?<eof>'?", "do end")
 
     f, msg = loadstring [[for i = 1, 2 do print(i)]]
-    like(msg, ":%d+: 'end' expected near '?<eof>'?", "for end")
+    matches(msg, ":%d+: 'end' expected near '?<eof>'?", "for end")
 
     f, msg = loadstring [[if true then f()]]
-    like(msg, ":%d+: 'end' expected near '?<eof>'?", "if end")
+    matches(msg, ":%d+: 'end' expected near '?<eof>'?", "if end")
 
     f, msg = loadstring [[while true do f()]]
-    like(msg, ":%d+: 'end' expected near '?<eof>'?", "while end")
+    matches(msg, ":%d+: 'end' expected near '?<eof>'?", "while end")
 
     f, msg = loadstring [[repeat f()]]
-    like(msg, ":%d+: 'until' expected near '?<eof>'?", "repeat until")
+    matches(msg, ":%d+: 'until' expected near '?<eof>'?", "repeat until")
 
     f, msg = loadstring [[function f (a, 2) return a * 2 end]]
-    like(msg, ":%d+: <name> or '...' expected near '2'", "function parameter list")
+    matches(msg, ":%d+: <name> or '...' expected near '2'", "function parameter list")
 
     f, msg = loadstring [[a = o:m[1, 2)]]
-    like(msg, ":%d+: function arguments expected near '%['", "function argument list")
+    matches(msg, ":%d+: function arguments expected near '%['", "function argument list")
 
     f, msg = loadstring [[for i do print(i) end]]
-    like(msg, ":%d+: '=' or 'in' expected near 'do'", "for init")
+    matches(msg, ":%d+: '=' or 'in' expected near 'do'", "for init")
 
     f, msg = loadstring [[for i = 1, 2 print(i) end]]
-    like(msg, ":%d+: 'do' expected near 'print'", "for do")
+    matches(msg, ":%d+: 'do' expected near 'print'", "for do")
 
     f, msg = loadstring [[if true f() end]]
-    like(msg, ":%d+: 'then' expected near 'f'", "if then")
+    matches(msg, ":%d+: 'then' expected near 'f'", "if then")
 
     f, msg = loadstring [[while true f() end]]
-    like(msg, ":%d+: 'do' expected near 'f", "while do")
+    matches(msg, ":%d+: 'do' expected near 'f", "while do")
 end
 
 if has_attr then
     local f, msg = load [[local foo < bar > = 'bar']]
-    like(msg, "^[^:]+:%d+: unknown attribute 'bar'")
+    matches(msg, "^[^:]+:%d+: unknown attribute 'bar'")
 
     f, msg = load [[local foo <const> = 'bar'; foo = 'baz']]
-    like(msg, "^[^:]+:%d+: attempt to assign to const variable 'foo'")
+    matches(msg, "^[^:]+:%d+: attempt to assign to const variable 'foo'")
 
     f, msg = load [[local foo <close> = 'bar'; foo = 'baz']]
-    like(msg, "^[^:]+:%d+: attempt to assign to const variable 'foo'")
+    matches(msg, "^[^:]+:%d+: attempt to assign to const variable 'foo'")
 end
 
 done_testing()
diff --git a/test/lua-Harness-tests/211-scope.t b/test/lua-Harness-tests/211-scope.t
index 64eed521..2c449ab5 100755
--- a/test/lua-Harness-tests/211-scope.t
+++ b/test/lua-Harness-tests/211-scope.t
@@ -2,7 +2,7 @@
 --
 -- lua-Harness : <https://fperrad.frama.io/lua-Harness/>
 --
--- Copyright (C) 2009-2020, Perrad Francois
+-- Copyright (C) 2009-2021, Perrad Francois
 --
 -- This code is licensed under the terms of the MIT/X11 license,
 -- like Lua itself.
@@ -38,15 +38,15 @@ plan(10)
 x = 10
 do
     local x = x
-    is(x, 10, "scope")
+    equals(x, 10, "scope")
     x = x + 1
     do
         local x = x + 1
-        is(x, 12)
+        equals(x, 12)
     end
-    is(x, 11)
+    equals(x, 11)
 end
-is(x, 10)
+equals(x, 10)
 
 --[[ scope ]]
 x = 10
@@ -61,22 +61,22 @@ end
 if i > 20 then
     local x
     x = 20
-    nok("scope")
+    fails("scope")
 else
-    is(x, 10, "scope")
+    equals(x, 10, "scope")
 end
 
-is(x, 10)
+equals(x, 10)
 
 --[[ scope ]]
 local a, b = 1, 10
 if a < b then
-    is(a, 1, "scope")
+    equals(a, 1, "scope")
     local a
-    is(a, nil)
+    equals(a, nil)
 end
-is(a, 1)
-is(b, 10)
+equals(a, 1)
+equals(b, 10)
 
 -- Local Variables:
 --   mode: lua
diff --git a/test/lua-Harness-tests/212-function.t b/test/lua-Harness-tests/212-function.t
index 28510537..8325e79b 100755
--- a/test/lua-Harness-tests/212-function.t
+++ b/test/lua-Harness-tests/212-function.t
@@ -2,7 +2,7 @@
 --
 -- lua-Harness : <https://fperrad.frama.io/lua-Harness/>
 --
--- Copyright (C) 2009-2020, Perrad Francois
+-- Copyright (C) 2009-2021, Perrad Francois
 --
 -- This code is licensed under the terms of the MIT/X11 license,
 -- like Lua itself.
@@ -45,15 +45,15 @@ do --[[ add ]]
     end
 
     local t = { 10, 20, 30, 40 }
-    is(add(t), 100, "add")
+    equals(add(t), 100, "add")
 end
 
 do --[[ f ]]
     local function f(a, b) return a or b end
 
-    is(f(3), 3, "f")
-    is(f(3, 4), 3)
-    is(f(3, 4, 5), 3)
+    equals(f(3), 3, "f")
+    equals(f(3, 4), 3)
+    equals(f(3, 4, 5), 3)
 end
 
 do --[[ incCount ]]
@@ -64,13 +64,13 @@ do --[[ incCount ]]
         count = count + n
     end
 
-    is(count, 0, "inCount")
+    equals(count, 0, "inCount")
     incCount()
-    is(count, 1)
+    equals(count, 1)
     incCount(2)
-    is(count, 3)
+    equals(count, 3)
     incCount(1)
-    is(count, 4)
+    equals(count, 4)
 end
 
 do --[[ maximum ]]
@@ -87,8 +87,8 @@ do --[[ maximum ]]
     end
 
     local m, mi = maximum({8,10,23,12,5})
-    is(m, 23, "maximum")
-    is(mi, 3)
+    equals(m, 23, "maximum")
+    equals(mi, 3)
 end
 
 do --[[ call by value ]]
@@ -98,13 +98,13 @@ do --[[ call by value ]]
     end
 
     local a = 12
-    is(a, 12, "call by value")
+    equals(a, 12, "call by value")
     local b = f(a)
-    is(b, 11)
-    is(a, 12)
+    equals(b, 11)
+    equals(a, 12)
     local c = f(12)
-    is(c, 11)
-    is(a, 12)
+    equals(c, 11)
+    equals(a, 12)
 end
 
 do --[[ call by ref ]]
@@ -114,38 +114,38 @@ do --[[ call by ref ]]
     end
 
     local a = { 'a', 'b', 'c' }
-    is(table.concat(a, ','), 'a,b,c', "call by ref")
+    equals(table.concat(a, ','), 'a,b,c', "call by ref")
     local b = f(a)
-    is(table.concat(b, ','), 'a,b,c,end')
-    is(table.concat(a, ','), 'a,b,c,end')
+    equals(table.concat(b, ','), 'a,b,c,end')
+    equals(table.concat(a, ','), 'a,b,c,end')
 end
 
 do --[[ var args ]]
     local function g1(a, b, ...)
         local arg = {...}
-        is(a, 3, "vararg")
-        is(b, nil)
-        is(#arg, 0)
-        is(arg[1], nil)
+        equals(a, 3, "vararg")
+        equals(b, nil)
+        equals(#arg, 0)
+        equals(arg[1], nil)
     end
     g1(3)
 
     local function g2(a, b, ...)
         local arg = {...}
-        is(a, 3)
-        is(b, 4)
-        is(#arg, 0)
-        is(arg[1], nil)
+        equals(a, 3)
+        equals(b, 4)
+        equals(#arg, 0)
+        equals(arg[1], nil)
     end
     g2(3, 4)
 
     local function g3(a, b, ...)
         local arg = {...}
-        is(a, 3)
-        is(b, 4)
-        is(#arg, 2)
-        is(arg[1], 5)
-        is(arg[2], 8)
+        equals(a, 3)
+        equals(b, 4)
+        equals(#arg, 2)
+        equals(arg[1], 5)
+        equals(arg[2], 8)
     end
     g3(3, 4, 5, 8)
 end
@@ -153,48 +153,48 @@ end
 do --[[ var args ]]
     local function g1(a, b, ...)
         local c, d, e = ...
-        is(a, 3, "var args")
-        is(b, nil)
-        is(c, nil)
-        is(d, nil)
-        is(e, nil)
+        equals(a, 3, "var args")
+        equals(b, nil)
+        equals(c, nil)
+        equals(d, nil)
+        equals(e, nil)
     end
     g1(3)
 
     local function g2(a, b, ...)
         local c, d, e = ...
-        is(a, 3)
-        is(b, 4)
-        is(c, nil)
-        is(d, nil)
-        is(e, nil)
+        equals(a, 3)
+        equals(b, 4)
+        equals(c, nil)
+        equals(d, nil)
+        equals(e, nil)
     end
     g2(3, 4)
 
     local function g3(a, b, ...)
         local c, d, e = ...
-        is(a, 3)
-        is(b, 4)
-        is(c, 5)
-        is(d, 8)
-        is(e, nil)
+        equals(a, 3)
+        equals(b, 4)
+        equals(c, 5)
+        equals(d, 8)
+        equals(e, nil)
     end
     g3(3, 4, 5, 8)
 end
 
 do --[[ var args ]]
     local function g1(a, b, ...)
-        is(#{a, b, ...}, 1, "varargs")
+        equals(#{a, b, ...}, 1, "varargs")
     end
     g1(3)
 
     local function g2(a, b, ...)
-        is(#{a, b, ...}, 2)
+        equals(#{a, b, ...}, 2)
     end
     g2(3, 4)
 
     local function g3(a, b, ...)
-        is(#{a, b, ...}, 4)
+        equals(#{a, b, ...}, 4)
     end
     g3(3, 4, 5, 8)
 end
@@ -206,20 +206,20 @@ do --[[ var args ]]
     local function k() return 'c', (f()) end
 
     local x, y = f()
-    is(x, 1, "var args")
-    is(y, 2)
+    equals(x, 1, "var args")
+    equals(y, 2)
     local z
     x, y, z = g()
-    is(x, 'a')
-    is(y, 1)
-    is(z, 2)
+    equals(x, 'a')
+    equals(y, 1)
+    equals(z, 2)
     x, y = h()
-    is(x, 1)
-    is(y, 'b')
+    equals(x, 1)
+    equals(y, 'b')
     x, y, z = k()
-    is(x, 'c')
-    is(y, 1)
-    is(z, nil)
+    equals(x, 'c')
+    equals(y, 1)
+    equals(z, nil)
 end
 
 do --[[ invalid var args ]]
@@ -228,7 +228,7 @@ function f ()
     print(...)
 end
 ]]
-    like(msg, "^[^:]+:%d+: cannot use '...' outside a vararg function", "invalid var args")
+    matches(msg, "^[^:]+:%d+: cannot use '...' outside a vararg function", "invalid var args")
 end
 
 do --[[ tail call ]]
@@ -241,8 +241,8 @@ do --[[ tail call ]]
         return 'end', 0
     end
 
-    eq_array({foo(3)}, {'end', 0}, "tail call")
-    eq_array(output, {3, 2, 1, 0})
+    array_equals({foo(3)}, {'end', 0}, "tail call")
+    array_equals(output, {3, 2, 1, 0})
 end
 
 do --[[ no tail call ]]
@@ -255,8 +255,8 @@ do --[[ no tail call ]]
         return 'end', 0
     end
 
-    is(foo(3), 'end', "no tail call")
-    eq_array(output, {3, 2, 1, 0})
+    equals(foo(3), 'end', "no tail call")
+    array_equals(output, {3, 2, 1, 0})
 end
 
 do --[[ no tail call ]]
@@ -268,16 +268,16 @@ do --[[ no tail call ]]
         end
     end
 
-    is(foo(3), nil, "no tail call")
-    eq_array(output, {3, 2, 1, 0})
+    equals(foo(3), nil, "no tail call")
+    array_equals(output, {3, 2, 1, 0})
 end
 
 do --[[ sub name ]]
     local function f () return 1 end
-    is(f(), 1, "sub name")
+    equals(f(), 1, "sub name")
 
     function f () return 2 end
-    is(f(), 2)
+    equals(f(), 2)
 end
 
 -- Local Variables:
diff --git a/test/lua-Harness-tests/213-closure.t b/test/lua-Harness-tests/213-closure.t
index fc3bd29c..925a0b84 100755
--- a/test/lua-Harness-tests/213-closure.t
+++ b/test/lua-Harness-tests/213-closure.t
@@ -2,7 +2,7 @@
 --
 -- lua-Harness : <https://fperrad.frama.io/lua-Harness/>
 --
--- Copyright (C) 2009-2018, Perrad Francois
+-- Copyright (C) 2009-2021, Perrad Francois
 --
 -- This code is licensed under the terms of the MIT/X11 license,
 -- like Lua itself.
@@ -36,8 +36,8 @@ do --[[ inc ]]
         return counter
     end
 
-    is(inc(1), 1, "inc")
-    is(inc(2), 3)
+    equals(inc(1), 1, "inc")
+    equals(inc(2), 3)
 end
 
 do --[[ newCounter ]]
@@ -50,13 +50,13 @@ do --[[ newCounter ]]
     end
 
     local c1 = newCounter()
-    is(c1(), 1, "newCounter")
-    is(c1(), 2)
+    equals(c1(), 1, "newCounter")
+    equals(c1(), 2)
 
     local c2 = newCounter()
-    is(c2(), 1)
-    is(c1(), 3)
-    is(c2(), 2)
+    equals(c2(), 1)
+    equals(c1(), 3)
+    equals(c2(), 2)
 end
 
 do --[[
@@ -71,9 +71,9 @@ of them share the same x.
         a[i] = function () y=y+1; return x+y end
     end
 
-    is(a[1](), 21, "ten closures")
-    is(a[1](), 22)
-    is(a[2](), 21)
+    equals(a[1](), 21, "ten closures")
+    equals(a[1](), 22)
+    equals(a[2](), 21)
 end
 
 do --[[ add ]]
@@ -82,12 +82,12 @@ do --[[ add ]]
     end
 
     local f = add(2)
-    type_ok(f, 'function', "add")
-    is(f(10), 12)
+    is_function(f, "add")
+    equals(f(10), 12)
     local g = add(5)
-    is(g(1), 6)
-    is(g(10), 15)
-    is(f(1), 3)
+    equals(g(1), 6)
+    equals(g(10), 15)
+    equals(f(1), 3)
 end
 
 -- Local Variables:
diff --git a/test/lua-Harness-tests/214-coroutine.t b/test/lua-Harness-tests/214-coroutine.t
index 92929e1b..3101f840 100755
--- a/test/lua-Harness-tests/214-coroutine.t
+++ b/test/lua-Harness-tests/214-coroutine.t
@@ -2,7 +2,7 @@
 --
 -- lua-Harness : <https://fperrad.frama.io/lua-Harness/>
 --
--- Copyright (C) 2009-2020, Perrad Francois
+-- Copyright (C) 2009-2021, Perrad Francois
 --
 -- This code is licensed under the terms of the MIT/X11 license,
 -- like Lua itself.
@@ -58,11 +58,11 @@ do
         return b, 'end'
     end)
 
-    eq_array({coroutine.resume(co, 1, 10)}, {true, 4}, "foo1")
-    eq_array({coroutine.resume(co, 'r')}, {true, 11, -9})
-    eq_array({coroutine.resume(co, "x", "y")}, {true, 10, 'end'})
-    eq_array({coroutine.resume(co, "x", "y")}, {false, "cannot resume dead coroutine"})
-    eq_array(output, {
+    array_equals({coroutine.resume(co, 1, 10)}, {true, 4}, "foo1")
+    array_equals({coroutine.resume(co, 'r')}, {true, 11, -9})
+    array_equals({coroutine.resume(co, "x", "y")}, {true, 10, 'end'})
+    array_equals({coroutine.resume(co, "x", "y")}, {false, "cannot resume dead coroutine"})
+    array_equals(output, {
         'co-body 1 10',
         'foo 2',
         'co-body r',
@@ -75,21 +75,21 @@ do
     local co = coroutine.create(function ()
         output = 'hi'
     end)
-    like(co, '^thread: 0?[Xx]?%x+$', "basics")
+    matches(co, '^thread: 0?[Xx]?%x+$', "basics")
 
-    is(coroutine.status(co), 'suspended')
+    equals(coroutine.status(co), 'suspended')
     coroutine.resume(co)
-    is(output, 'hi')
-    is(coroutine.status(co), 'dead')
+    equals(output, 'hi')
+    equals(coroutine.status(co), 'dead')
 
-    error_like(function () coroutine.create(true) end,
-               "^[^:]+:%d+: bad argument #1 to 'create' %(.- expected")
+    error_matches(function () coroutine.create(true) end,
+            "^[^:]+:%d+: bad argument #1 to 'create' %(.- expected")
 
-    error_like(function () coroutine.resume(true) end,
-               "^[^:]+:%d+: bad argument #1 to 'resume' %(.- expected")
+    error_matches(function () coroutine.resume(true) end,
+            "^[^:]+:%d+: bad argument #1 to 'resume' %(.- expected")
 
-    error_like(function () coroutine.status(true) end,
-               "^[^:]+:%d+: bad argument #1 to 'status' %(.- expected")
+    error_matches(function () coroutine.status(true) end,
+            "^[^:]+:%d+: bad argument #1 to 'status' %(.- expected")
 end
 
 do
@@ -104,13 +104,13 @@ do
     coroutine.resume(co)
     if has_running52 then
         local thr, ismain = coroutine.running()
-        type_ok(thr, 'thread', "running")
-        is(ismain, true, "running")
+        is_thread(thr, "running")
+        is_true(ismain, "running")
     else
         local thr = coroutine.running()
-        is(thr, nil, "main thread")
+        is_nil(thr, "main thread")
     end
-    is(coroutine.status(co), 'suspended', "basics")
+    equals(coroutine.status(co), 'suspended', "basics")
     coroutine.resume(co)
     coroutine.resume(co)
     coroutine.resume(co)
@@ -121,8 +121,8 @@ do
     coroutine.resume(co)
     coroutine.resume(co)
     coroutine.resume(co)
-    eq_array({coroutine.resume(co)}, {false, 'cannot resume dead coroutine'})
-    eq_array(output, {1,2,3,4,5,6,7,8,9,10})
+    array_equals({coroutine.resume(co)}, {false, 'cannot resume dead coroutine'})
+    array_equals(output, {1,2,3,4,5,6,7,8,9,10})
 end
 
 do
@@ -130,7 +130,7 @@ do
         coroutine.yield(a + b, a - b)
     end)
 
-    eq_array({coroutine.resume(co, 20, 10)}, {true, 30, 10}, "basics")
+    array_equals({coroutine.resume(co, 20, 10)}, {true, 30, 10}, "basics")
 end
 
 do
@@ -138,7 +138,7 @@ do
         return 6, 7
     end)
 
-    eq_array({coroutine.resume(co)}, {true, 6, 7}, "basics")
+    array_equals({coroutine.resume(co)}, {true, 6, 7}, "basics")
 end
 
 if has_coroutine52 then
@@ -147,8 +147,8 @@ if has_coroutine52 then
             return coroutine.yield(...)
         end, ...)
     end)
-    eq_array({co("Hello")}, {"Hello"})
-    eq_array({co("World")}, {true, "World"})
+    array_equals({co("Hello")}, {"Hello"})
+    array_equals({co("World")}, {true, "World"})
 end
 
 if has_coroutine52 then
@@ -160,8 +160,8 @@ if has_coroutine52 then
             return coroutine.yield(...)
         end, backtrace, ...)
     end)
-    eq_array({co("Hello")}, {"Hello"})
-    eq_array({co("World")}, {true, "World"})
+    array_equals({co("Hello")}, {"Hello"})
+    array_equals({co("World")}, {true, "World"})
 end
 
 if has_coroutine52 then
@@ -180,19 +180,19 @@ if has_coroutine52 then
     co()
     co(true)
     co(false)
-    eq_array(output, {true, false})
+    array_equals(output, {true, false})
 end
 
 if has_coroutine52 then
     local co = coroutine.wrap(print)
-    type_ok(co, 'function')
+    is_function(co)
 
-    error_like(function () coroutine.wrap(true) end,
-               "^[^:]+:%d+: bad argument #1 to 'wrap' %(function expected, got boolean%)")
+    error_matches(function () coroutine.wrap(true) end,
+            "^[^:]+:%d+: bad argument #1 to 'wrap' %(function expected, got boolean%)")
 
     co = coroutine.wrap(function () error"in coro" end)
-    error_like(function () co() end,
-               "^[^:]+:%d+: [^:]+:%d+: in coro$")
+    error_matches(function () co() end,
+            "^[^:]+:%d+: [^:]+:%d+: in coro$")
 end
 
 do
@@ -200,18 +200,18 @@ do
         error "in coro"
     end)
     local r, msg = coroutine.resume(co)
-    is(r, false)
-    like(msg, "^[^:]+:%d+: in coro$")
+    is_false(r)
+    matches(msg, "^[^:]+:%d+: in coro$")
 end
 
 do
-    error_like(function () coroutine.yield() end,
-               "attempt to yield")
+    error_matches(function () coroutine.yield() end,
+            "attempt to yield")
 
     if has_isyieldable then
-        is(coroutine.isyieldable(), false, "isyieldable")
+        is_false(coroutine.isyieldable(), "isyieldable")
     else
-        is(coroutine.isyieldable, nil, "no coroutine.isyieldable")
+        is_nil(coroutine.isyieldable, "no coroutine.isyieldable")
     end
 end
 
@@ -221,17 +221,17 @@ if has_close then
     local co = coroutine.create(function ()
         output = 'hi'
     end)
-    is(coroutine.close(co), true, "close")
-    is(coroutine.status(co), 'dead')
-    is(coroutine.close(co), true, "close again")
+    is_true(coroutine.close(co), "close")
+    equals(coroutine.status(co), 'dead')
+    is_true(coroutine.close(co), "close again")
 
-    error_like(function () coroutine.close(coroutine.running()) end,
-               "^[^:]+:%d+: cannot close a running coroutine")
+    error_matches(function () coroutine.close(coroutine.running()) end,
+        "^[^:]+:%d+: cannot close a running coroutine")
 
-    error_like(function () coroutine.close(42) end,
-               "^[^:]+:%d+: bad argument #1 to 'close' %(thread expected, got number%)")
+    error_matches(function () coroutine.close(42) end,
+        "^[^:]+:%d+: bad argument #1 to 'close' %(thread expected, got number%)")
 else
-    is(coroutine.close, nil, "no coroutine.close")
+    is_nil(coroutine.close, "no coroutine.close")
 end
 
 done_testing()
diff --git a/test/lua-Harness-tests/221-table.t b/test/lua-Harness-tests/221-table.t
index c064a339..1b4e6ff6 100755
--- a/test/lua-Harness-tests/221-table.t
+++ b/test/lua-Harness-tests/221-table.t
@@ -2,7 +2,7 @@
 --
 -- lua-Harness : <https://fperrad.frama.io/lua-Harness/>
 --
--- Copyright (C) 2009-2018, Perrad Francois
+-- Copyright (C) 2009-2021, Perrad Francois
 --
 -- This code is licensed under the terms of the MIT/X11 license,
 -- like Lua itself.
@@ -33,20 +33,20 @@ do
     local k = 'x'
     a[k] = 10
     a[20] = 'great'
-    is(a['x'], 10)
+    equals(a['x'], 10)
     k = 20
-    is(a[k], 'great')
+    equals(a[k], 'great')
     a['x'] = a ['x'] + 1
-    is(a['x'], 11)
+    equals(a['x'], 11)
 end
 
 do
     local a = {}
     a['x'] = 10
     local b = a
-    is(b['x'], 10)
+    equals(b['x'], 10)
     b['x'] = 20
-    is(a['x'], 20)
+    equals(a['x'], 20)
     a = nil
     b = nil
 end
@@ -54,19 +54,19 @@ end
 do
     local a = {}
     for i=1,1000 do a[i] = i*2 end
-    is(a[9], 18)
+    equals(a[9], 18)
     a['x'] = 10
-    is(a['x'], 10)
-    is(a['y'], nil)
+    equals(a['x'], 10)
+    equals(a['y'], nil)
 end
 
 do
     local a = {}
     local x = 'y'
     a[x] = 10
-    is(a[x], 10)
-    is(a.x, nil)
-    is(a.y, 10)
+    equals(a[x], 10)
+    equals(a.x, nil)
+    equals(a.y, 10)
 end
 
 do
@@ -75,41 +75,41 @@ do
     a[i] = "one value"
     a[j] = "another value"
     a[k] = "yet another value"
-    is(a[j], "another value")
-    is(a[k], "yet another value")
-    is(a[tonumber(j)], "one value")
-    is(a[tonumber(k)], "one value")
+    equals(a[j], "another value")
+    equals(a[k], "yet another value")
+    equals(a[tonumber(j)], "one value")
+    equals(a[tonumber(k)], "one value")
 end
 
 do
     local t = { {'a','b','c'}, 10 }
-    is(t[2], 10)
-    is(t[1][3], 'c')
+    equals(t[2], 10)
+    equals(t[1][3], 'c')
     t[1][1] = 'A'
-    is(table.concat(t[1],','), 'A,b,c')
+    equals(table.concat(t[1],','), 'A,b,c')
 end
 
 do
     local tt = { {'a','b','c'}, 10 }
-    is(tt[2], 10)
-    is(tt[1][3], 'c')
+    equals(tt[2], 10)
+    equals(tt[1][3], 'c')
     tt[1][1] = 'A'
-    is(table.concat(tt[1],','), 'A,b,c')
+    equals(table.concat(tt[1],','), 'A,b,c')
 end
 
 do
     local a = {}
-    error_like(function () a() end,
-               "^[^:]+:%d+: .- call")
+    error_matches(function () a() end,
+            "^[^:]+:%d+: .- call")
 end
 
 do
     local tt = { {'a','b','c'}, 10 }
-    is((tt)[2], 10)
-    is((tt[1])[3], 'c');
+    equals((tt)[2], 10)
+    equals((tt[1])[3], 'c');
     (tt)[1][2] = 'B'
     (tt[1])[3] = 'C'
-    is(table.concat(tt[1],','), 'a,B,C')
+    equals(table.concat(tt[1],','), 'a,B,C')
 end
 
 -- Local Variables:
diff --git a/test/lua-Harness-tests/222-constructor.t b/test/lua-Harness-tests/222-constructor.t
index a01be2ec..ce89b9aa 100755
--- a/test/lua-Harness-tests/222-constructor.t
+++ b/test/lua-Harness-tests/222-constructor.t
@@ -2,7 +2,7 @@
 --
 -- lua-Harness : <https://fperrad.frama.io/lua-Harness/>
 --
--- Copyright (C) 2009-2020, Perrad Francois
+-- Copyright (C) 2009-2021, Perrad Francois
 --
 -- This code is licensed under the terms of the MIT/X11 license,
 -- like Lua itself.
@@ -37,8 +37,8 @@ plan(16)
 do --[[ list-style init ]]
     local days = {'Sunday', 'Monday', 'Tuesday', 'Wednesday',
                   'Thursday', 'Friday', 'Saturday'}
-    is(days[4], 'Wednesday', "list-style init")
-    is(#days, 7)
+    equals(days[4], 'Wednesday', "list-style init")
+    equals(#days, 7)
 end
 
 do
@@ -52,7 +52,7 @@ do
                     1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
                     1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
                     1, 2, 3, 4, 5, 6, 7, 8, 9, 0 }
-    is(#large, 100)
+    equals(#large, 100)
     large = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
               1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
               1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
@@ -63,13 +63,13 @@ do
               1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
               1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
               1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 }
-    is(#large, 200)
+    equals(#large, 200)
 end
 
 do --[[ record-style init ]]
     local a = {x=0, y=0}
-    is(a.x, 0, "record-style init")
-    is(a.y, 0)
+    equals(a.x, 0, "record-style init")
+    equals(a.y, 0)
 end
 
 do
@@ -77,9 +77,9 @@ do
     local x = {0, 1, 2}
     w[1] = "another field"
     x.f = w
-    is(w['x'], 0, "ctor")
-    is(w[1], "another field")
-    is(x.f[1], "another field")
+    equals(w['x'], 0, "ctor")
+    equals(w[1], "another field")
+    equals(x.f[1], "another field")
     w.x = nil
 end
 
@@ -90,7 +90,7 @@ do --[[ mix record-style and list-style init ]]
                        {x=-10, y=1},
                        {x=0,   y=1}
                      }
-    is(polyline[2].x, -10, "mix record-style and list-style init")
+    equals(polyline[2].x, -10, "mix record-style and list-style init")
 end
 
 do
@@ -98,17 +98,17 @@ do
                      ['*'] = 'mul', ['/'] = 'div'}
     local i = 20; local s = '-'
     local a = {[i+0] = s, [i+1] = s..s, [i+2] = s..s..s}
-    is(opnames[s], 'sub', "ctor")
-    is(a[22], '---')
+    equals(opnames[s], 'sub', "ctor")
+    equals(a[22], '---')
 end
 
 do
     local function f() return 10, 20 end
 
-    eq_array({f()}, {10, 20}, "ctor")
-    eq_array({'a', f()}, {'a', 10, 20})
-    eq_array({f(), 'b'}, {10, 'b'})
-    eq_array({'c', (f())}, {'c', 10})
+    array_equals({f()}, {10, 20}, "ctor")
+    array_equals({'a', f()}, {'a', 10, 20})
+    array_equals({f(), 'b'}, {10, 'b'})
+    array_equals({'c', (f())}, {'c', 10})
 end
 
 -- Local Variables:
diff --git a/test/lua-Harness-tests/223-iterator.t b/test/lua-Harness-tests/223-iterator.t
index 777ad73d..a95fd1fe 100755
--- a/test/lua-Harness-tests/223-iterator.t
+++ b/test/lua-Harness-tests/223-iterator.t
@@ -2,7 +2,7 @@
 --
 -- lua-Harness : <https://fperrad.frama.io/lua-Harness/>
 --
--- Copyright (C) 2009-2018, Perrad Francois
+-- Copyright (C) 2009-2021, Perrad Francois
 --
 -- This code is licensed under the terms of the MIT/X11 license,
 -- like Lua itself.
@@ -48,7 +48,7 @@ do --[[ list_iter ]]
     for element in list_iter(t) do
         output[#output+1] = element
     end
-    eq_array(output, t, "list_iter")
+    array_equals(output, t, "list_iter")
 end
 
 do --[[ values ]]
@@ -65,7 +65,7 @@ do --[[ values ]]
     for element in values(t) do
         output[#output+1] = element
     end
-    eq_array(output, t, "values")
+    array_equals(output, t, "values")
 end
 
 do --[[ emul ipairs ]]
@@ -87,7 +87,7 @@ do --[[ emul ipairs ]]
         output[#output+1] = i
         output[#output+1] = v
     end
-    eq_array(output, {1, 'one', 2, 'two', 3, 'three'}, "emul ipairs")
+    array_equals(output, {1, 'one', 2, 'two', 3, 'three'}, "emul ipairs")
 end
 
 do --[[ emul pairs ]]
@@ -101,7 +101,7 @@ do --[[ emul pairs ]]
         output[#output+1] = k
         output[#output+1] = v
     end
-    eq_array(output, {1, 'one', 2, 'two', 3, 'three'}, "emul ipairs")
+    array_equals(output, {1, 'one', 2, 'two', 3, 'three'}, "emul ipairs")
 end
 
 do --[[ with next ]]
@@ -111,7 +111,7 @@ do --[[ with next ]]
         output[#output+1] = k
         output[#output+1] = v
     end
-    eq_array(output, {1, 'one', 2, 'two', 3, 'three'}, "with next")
+    array_equals(output, {1, 'one', 2, 'two', 3, 'three'}, "with next")
 end
 
 do --[[ permutations ]]
@@ -143,7 +143,7 @@ do --[[ permutations ]]
     for p in permutations{'a', 'b', 'c'} do
         output[#output+1] = table.concat(p, ' ')
     end
-    eq_array(output, {'b c a','c b a','c a b','a c b','b a c','a b c'}, "permutations")
+    array_equals(output, {'b c a','c b a','c a b','a c b','b a c','a b c'}, "permutations")
 end
 
 do --[[ permutations with wrap ]]
@@ -171,7 +171,7 @@ do --[[ permutations with wrap ]]
     for p in permutations{'a', 'b', 'c'} do
         output[#output+1] = table.concat(p, ' ')
     end
-    eq_array(output, {'b c a','c b a','c a b','a c b','b a c','a b c'}, "permutations with wrap")
+    array_equals(output, {'b c a','c b a','c a b','a c b','b a c','a b c'}, "permutations with wrap")
 end
 
 do --[[ fibo ]]
@@ -192,7 +192,7 @@ do --[[ fibo ]]
         output[#output+1] = n
         if n > 30 then break end
     end
-    eq_array(output, {0, 1, 1, 2, 3, 5, 8, 13, 21, 34}, "fibo")
+    array_equals(output, {0, 1, 1, 2, 3, 5, 8, 13, 21, 34}, "fibo")
 end
 
 -- Local Variables:
diff --git a/test/lua-Harness-tests/231-metatable.t b/test/lua-Harness-tests/231-metatable.t
index 97ac5420..8d181d0e 100755
--- a/test/lua-Harness-tests/231-metatable.t
+++ b/test/lua-Harness-tests/231-metatable.t
@@ -2,7 +2,7 @@
 --
 -- lua-Harness : <https://fperrad.frama.io/lua-Harness/>
 --
--- Copyright (C) 2009-2020, Perrad Francois
+-- Copyright (C) 2009-2021, Perrad Francois
 --
 -- This code is licensed under the terms of the MIT/X11 license,
 -- like Lua itself.
@@ -44,34 +44,34 @@ plan'no_plan'
 
 do
     local t = {}
-    is(getmetatable(t), nil, "metatable")
+    equals(getmetatable(t), nil, "metatable")
     local t1 = {}
-    is(setmetatable(t, t1), t)
-    is(getmetatable(t), t1)
-    is(setmetatable(t, nil), t)
-    error_like(function () setmetatable(t, true) end,
-               "^[^:]+:%d+: bad argument #2 to 'setmetatable' %(nil or table expected")
+    equals(setmetatable(t, t1), t)
+    equals(getmetatable(t), t1)
+    equals(setmetatable(t, nil), t)
+    error_matches(function () setmetatable(t, true) end,
+            "^[^:]+:%d+: bad argument #2 to 'setmetatable' %(nil or table expected")
 
     local mt = {}
     mt.__metatable = "not your business"
     setmetatable(t, mt)
-    is(getmetatable(t), "not your business", "protected metatable")
-    error_like(function () setmetatable(t, {}) end,
-               "^[^:]+:%d+: cannot change a protected metatable")
+    equals(getmetatable(t), "not your business", "protected metatable")
+    error_matches(function () setmetatable(t, {}) end,
+            "^[^:]+:%d+: cannot change a protected metatable")
 
-    is(getmetatable('').__index, string, "metatable for string")
+    equals(getmetatable('').__index, string, "metatable for string")
 
-    is(getmetatable(nil), nil, "metatable for nil")
-    is(getmetatable(false), nil, "metatable for boolean")
-    is(getmetatable(2), nil, "metatable for number")
-    is(getmetatable(print), nil, "metatable for function")
+    equals(getmetatable(nil), nil, "metatable for nil")
+    equals(getmetatable(false), nil, "metatable for boolean")
+    equals(getmetatable(2), nil, "metatable for number")
+    equals(getmetatable(print), nil, "metatable for function")
 end
 
 do
     local t = {}
     local mt = { __tostring=function () return '__TABLE__' end }
     setmetatable(t, mt)
-    is(tostring(t), '__TABLE__', "__tostring")
+    equals(tostring(t), '__TABLE__', "__tostring")
 end
 
 do
@@ -81,26 +81,26 @@ do
     function mt.__tostring () a = "return nothing" end
     setmetatable(t, mt)
     if has_metamethod_tostring53 then
-        error_like(function () tostring(t) end,
-                   "^[^:]+:%d+: '__tostring' must return a string")
-        is(a, "return nothing")
+        error_matches(function () tostring(t) end,
+                "^[^:]+:%d+: '__tostring' must return a string")
+        equals(a, "return nothing")
         if has_metamethod_tostring54 then
-            error_like(function () print(t) end,
-                       "^[^:]+:%d+: '__tostring' must return a string")
+            error_matches(function () print(t) end,
+                    "^[^:]+:%d+: '__tostring' must return a string")
         else
-            error_is(function () print(t) end,
-                     "'__tostring' must return a string")
+            error_equals(function () print(t) end,
+                    "'__tostring' must return a string")
         end
     else
-        is(tostring(t), nil, "__tostring no-output")
-        is(a, "return nothing")
-        error_like(function () print(t) end,
-                   "^[^:]+:%d+: 'tostring' must return a string to 'print'")
+        equals(tostring(t), nil, "__tostring no-output")
+        equals(a, "return nothing")
+        error_matches(function () print(t) end,
+                "^[^:]+:%d+: 'tostring' must return a string to 'print'")
     end
 
     mt.__tostring = function () return '__FIRST__', 2 end
     setmetatable(t, mt)
-    is(tostring(t), '__FIRST__', "__tostring too-many-output")
+    equals(tostring(t), '__FIRST__', "__tostring too-many-output")
 end
 
 do
@@ -108,9 +108,9 @@ do
     t.mt = {}
     setmetatable(t, t.mt)
     t.mt.__tostring = "not a function"
-    error_like(function () tostring(t) end,
-               "attempt to call",
-               "__tostring invalid")
+    error_matches(function () tostring(t) end,
+            "attempt to call",
+            "__tostring invalid")
 end
 
 do
@@ -118,9 +118,9 @@ do
     local mt = { __len=function () return 42 end }
     setmetatable(t, mt)
     if has_metamethod52 then
-        is(#t, 42, "__len")
+        equals(#t, 42, "__len")
     else
-        is(#t, 0, "__len 5.1")
+        equals(#t, 0, "__len 5.1")
     end
 end
 
@@ -131,9 +131,9 @@ if has_metamethod52 then
     if jit then
         todo("not with LuaJIT")
     end
-    error_like(function () print(table.concat(t)) end,
-               "object length is not a.-er",
-               "__len invalid")
+    error_matches(function () print(table.concat(t)) end,
+            "object length is not a.-er",
+            "__len invalid")
 end
 
 do
@@ -145,7 +145,7 @@ do
         end,
     }
     setmetatable(t, mt)
-    is(t .. t .. t ..'end' .. '.', "t|t|t|end.", "__concat")
+    equals(t .. t .. t ..'end' .. '.', "t|t|t|end.", "__concat")
 end
 
 do --[[ Cplx ]]
@@ -183,11 +183,11 @@ do --[[ Cplx ]]
     local c1 = Cplx.new(1, 3)
     local c2 = Cplx.new(2, -1)
 
-    is(tostring(c1 + c2), '(3,2)', "cplx __add")
-    is(tostring(c1 + 3), '(4,3)')
-    is(tostring(-2 + c1), '(-1,3)')
-    is(tostring(c1 + '3'), '(4,3)')
-    is(tostring('-2' + c1), '(-1,3)')
+    equals(tostring(c1 + c2), '(3,2)', "cplx __add")
+    equals(tostring(c1 + 3), '(4,3)')
+    equals(tostring(-2 + c1), '(-1,3)')
+    equals(tostring(c1 + '3'), '(4,3)')
+    equals(tostring('-2' + c1), '(-1,3)')
 
     function Cplx.mt.__sub (a, b)
         if type(a) ~= 'table' then
@@ -200,11 +200,11 @@ do --[[ Cplx ]]
         return r
     end
 
-    is(tostring(c1 - c2), '(-1,4)', "cplx __sub")
-    is(tostring(c1 - 3), '(-2,3)')
-    is(tostring(-2 - c1), '(-3,-3)')
-    is(tostring(c1 - '3'), '(-2,3)')
-    is(tostring('-2' - c1), '(-3,-3)')
+    equals(tostring(c1 - c2), '(-1,4)', "cplx __sub")
+    equals(tostring(c1 - 3), '(-2,3)')
+    equals(tostring(-2 - c1), '(-3,-3)')
+    equals(tostring(c1 - '3'), '(-2,3)')
+    equals(tostring('-2' - c1), '(-3,-3)')
 
     function Cplx.mt.__mul (a, b)
         if type(a) ~= 'table' then
@@ -218,11 +218,11 @@ do --[[ Cplx ]]
         return r
     end
 
-    is(tostring(c1 * c2), '(5,5)', "cplx __mul")
-    is(tostring(c1 * 3), '(3,9)')
-    is(tostring(-2 * c1), '(-2,-6)')
-    is(tostring(c1 * '3'), '(3,9)')
-    is(tostring('-2' * c1), '(-2,-6)')
+    equals(tostring(c1 * c2), '(5,5)', "cplx __mul")
+    equals(tostring(c1 * 3), '(3,9)')
+    equals(tostring(-2 * c1), '(-2,-6)')
+    equals(tostring(c1 * '3'), '(3,9)')
+    equals(tostring('-2' * c1), '(-2,-6)')
 
     function Cplx.mt.__div (a, b)
         if type(a) ~= 'table' then
@@ -241,11 +241,11 @@ do --[[ Cplx ]]
     c1 = Cplx.new(2, 6)
     c2 = Cplx.new(2, 0)
 
-    is(tostring(c1 / c2), '(1,3)', "cplx __div")
-    is(tostring(c1 / 2), '(1,3)')
-    is(tostring(-4 / c2), '(-2,0)')
-    is(tostring(c1 / '2'), '(1,3)')
-    is(tostring('-4' / c2), '(-2,0)')
+    equals(tostring(c1 / c2), '(1,3)', "cplx __div")
+    equals(tostring(c1 / 2), '(1,3)')
+    equals(tostring(-4 / c2), '(-2,0)')
+    equals(tostring(c1 / '2'), '(1,3)')
+    equals(tostring('-4' / c2), '(-2,0)')
 
     function Cplx.mt.__unm (a)
         if type(a) ~= 'table' then
@@ -256,7 +256,7 @@ do --[[ Cplx ]]
     end
 
     c1 = Cplx.new(1, 3)
-    is(tostring(- c1), '(-1,-3)', "cplx __unm")
+    equals(tostring(- c1), '(-1,-3)', "cplx __unm")
 
     function Cplx.mt.__len (a)
         return math.sqrt(a.re*a.re + a.im*a.im)
@@ -264,9 +264,9 @@ do --[[ Cplx ]]
 
     c1 = Cplx.new(3, 4)
     if has_metamethod52 then
-        is( #c1, 5, "cplx __len")
+        equals( #c1, 5, "cplx __len")
     else
-        is( #c1, 0, "__len 5.1")
+        equals( #c1, 0, "__len 5.1")
     end
 
     function Cplx.mt.__eq (a, b)
@@ -283,10 +283,10 @@ do --[[ Cplx ]]
     c2 = Cplx.new(1, 3)
     local c3 = Cplx.new(2, 0)
 
-    is(c1 ~= c2, true, "cplx __eq")
-    is(c1 == c3, true)
-    is(c1 == 2, false)
-    is(Cplx.mt.__eq(c1, 2), true)
+    equals(c1 ~= c2, true, "cplx __eq")
+    equals(c1 == c3, true)
+    equals(c1 == 2, false)
+    equals(Cplx.mt.__eq(c1, 2), true)
 
     function Cplx.mt.__lt (a, b)
         if type(a) ~= 'table' then
@@ -300,14 +300,14 @@ do --[[ Cplx ]]
         return ra < rb
     end
 
-    is(c1 < c2, true, "cplx __lt")
-    is(c1 < c3, false)
+    equals(c1 < c2, true, "cplx __lt")
+    equals(c1 < c3, false)
     if has_metamethod_le_emulated then
-        is(c1 <= c3, true)
+        equals(c1 <= c3, true)
     end
     if has_metamethod52 then
-        is(c1 < 1, false)
-        is(c1 < 4, true)
+        equals(c1 < 1, false)
+        equals(c1 < 4, true)
     end
 
     function Cplx.mt.__le (a, b)
@@ -322,9 +322,9 @@ do --[[ Cplx ]]
         return ra <= rb
     end
 
-    is(c1 < c2, true, "cplx __lt __le")
-    is(c1 < c3, false)
-    is(c1 <= c3, true)
+    equals(c1 < c2, true, "cplx __lt __le")
+    equals(c1 < c3, false)
+    equals(c1 <= c3, true)
 
     local a = nil
     function Cplx.mt.__call (obj)
@@ -334,20 +334,20 @@ do --[[ Cplx ]]
 
     c1 = Cplx.new(2, 0)
     local r = c1()
-    is(r, true, "cplx __call (without args)")
-    is(a, "Cplx.__call (2,0)")
+    equals(r, true, "cplx __call (without args)")
+    equals(a, "Cplx.__call (2,0)")
 
     function Cplx.mt.__call (obj, ...)
         a = "Cplx.__call " .. tostring(obj) .. ", " .. table.concat({...}, ", ")
         return true
     end
 
-    is(c1(), true, "cplx __call (with args)")
-    is(a, "Cplx.__call (2,0), ")
-    is(c1('a'), true)
-    is(a, "Cplx.__call (2,0), a")
-    is(c1('a', 'b', 'c'), true)
-    is(a, "Cplx.__call (2,0), a, b, c")
+    equals(c1(), true, "cplx __call (with args)")
+    equals(a, "Cplx.__call (2,0), ")
+    equals(c1('a'), true)
+    equals(a, "Cplx.__call (2,0), a")
+    equals(c1('a', 'b', 'c'), true)
+    equals(a, "Cplx.__call (2,0), a, b, c")
 end
 
 --[[ delegate ]]
@@ -371,7 +371,7 @@ if has_metamethod_pairs then
         r[#r+1] = k
     end
     table.sort(r)
-    is( table.concat(r, ','), 'a,b,c', "__pairs" )
+    equals( table.concat(r, ','), 'a,b,c', "__pairs" )
 end
 if has_metamethod_ipairs then
     local t = {
@@ -388,7 +388,7 @@ if has_metamethod_ipairs then
     for i, v in ipairs(t) do
         r = r .. v
     end
-    is( r, 'abc', "__ipairs" )
+    equals( r, 'abc', "__ipairs" )
 end
 
 do --[[ Window ]]
@@ -409,17 +409,17 @@ do --[[ Window ]]
     end
 
     local w = Window.new{x=10, y=20}
-    is(w.x, 10, "table-access")
-    is(w.width, 100)
-    is(rawget(w, 'x'), 10)
-    is(rawget(w, 'width'), nil)
+    equals(w.x, 10, "table-access")
+    equals(w.width, 100)
+    equals(rawget(w, 'x'), 10)
+    equals(rawget(w, 'width'), nil)
 
     Window.mt.__index = Window.prototype  -- just a table
     w = Window.new{x=10, y=20}
-    is(w.x, 10, "table-access")
-    is(w.width, 100)
-    is(rawget(w, 'x'), 10)
-    is(rawget(w, 'width'), nil)
+    equals(w.x, 10, "table-access")
+    equals(w.width, 100)
+    equals(rawget(w, 'x'), 10)
+    equals(rawget(w, 'width'), nil)
 end
 
 do --[[ tables with default values ]]
@@ -429,11 +429,11 @@ do --[[ tables with default values ]]
     end
 
     local tab = {x=10, y=20}
-    is(tab.x, 10, "tables with default values")
-    is(tab.z, nil)
+    equals(tab.x, 10, "tables with default values")
+    equals(tab.z, nil)
     setDefault_1(tab, 0)
-    is(tab.x, 10)
-    is(tab.z, 0)
+    equals(tab.x, 10)
+    equals(tab.z, 0)
 end
 
 do --[[ tables with default values ]]
@@ -444,11 +444,11 @@ do --[[ tables with default values ]]
     end
 
     local tab = {x=10, y=20}
-    is(tab.x, 10, "tables with default values")
-    is(tab.z, nil)
+    equals(tab.x, 10, "tables with default values")
+    equals(tab.z, nil)
     setDefault_2(tab, 0)
-    is(tab.x, 10)
-    is(tab.z, 0)
+    equals(tab.x, 10)
+    equals(tab.z, 0)
 end
 
 do --[[ tables with default values ]]
@@ -460,11 +460,11 @@ do --[[ tables with default values ]]
     end
 
     local tab = {x=10, y=20}
-    is(tab.x, 10, "tables with default values")
-    is(tab.z, nil)
+    equals(tab.x, 10, "tables with default values")
+    equals(tab.z, nil)
     setDefault_3(tab, 0)
-    is(tab.x, 10)
-    is(tab.z, 0)
+    equals(tab.x, 10)
+    equals(tab.z, 0)
 end
 
 do --[[ private access ]]
@@ -492,9 +492,9 @@ do --[[ private access ]]
     setmetatable(t, mt)
 
     t[2] = 'hello'
-    is(t[2], 'hello', "tracking table accesses")
-    is(w, "*update of element 2 to hello")
-    is(r, "*access to element 2")
+    equals(t[2], 'hello', "tracking table accesses")
+    equals(w, "*update of element 2 to hello")
+    equals(r, "*access to element 2")
 end
 
 do --[[ private access ]]
@@ -527,9 +527,9 @@ do --[[ private access ]]
     t = track(t)
 
     t[2] = 'hello'
-    is(t[2], 'hello', "tracking table accesses")
-    is(w, "*update of element 2 to hello")
-    is(r, "*access to element 2")
+    equals(t[2], 'hello', "tracking table accesses")
+    equals(w, "*update of element 2 to hello")
+    equals(r, "*access to element 2")
 end
 
 do --[[ read-only table ]]
@@ -548,10 +548,10 @@ do --[[ read-only table ]]
     local days = readOnly{'Sunday', 'Monday', 'Tuesday', 'Wednesday',
                          'Thurday', 'Friday', 'Saturday'}
 
-    is(days[1], 'Sunday', "read-only tables")
+    equals(days[1], 'Sunday', "read-only tables")
 
-    error_like(function () days[2] = 'Noday' end,
-               "^[^:]+:%d+: attempt to update a read%-only table")
+    error_matches(function () days[2] = 'Noday' end,
+            "^[^:]+:%d+: attempt to update a read%-only table")
 end
 
 do --[[ declare global ]]
@@ -568,13 +568,13 @@ do --[[ declare global ]]
         end,
     })
 
-    error_like(function () new_a = 1 end,
-               "^[^:]+:%d+: attempt to write to undeclared variable new_a",
-               "declaring global variables")
+    error_matches(function () new_a = 1 end,
+            "^[^:]+:%d+: attempt to write to undeclared variable new_a",
+            "declaring global variables")
 
     declare 'new_a'
     new_a = 1
-    is(new_a, 1)
+    equals(new_a, 1)
 end
 
 do
@@ -585,7 +585,7 @@ do
     }
     local t = setmetatable({}, mt)
     t[1] = 42
-    is(newindex[1], 42, "__newindex")
+    equals(newindex[1], 42, "__newindex")
 end
 
 if has_anno_toclose then
diff --git a/test/lua-Harness-tests/232-object.t b/test/lua-Harness-tests/232-object.t
index 0d875729..583e37a6 100755
--- a/test/lua-Harness-tests/232-object.t
+++ b/test/lua-Harness-tests/232-object.t
@@ -2,7 +2,7 @@
 --
 -- lua-Harness : <https://fperrad.frama.io/lua-Harness/>
 --
--- Copyright (C) 2009-2018, Perrad Francois
+-- Copyright (C) 2009-2021, Perrad Francois
 --
 -- This code is licensed under the terms of the MIT/X11 license,
 -- like Lua itself.
@@ -37,11 +37,11 @@ do --[[ object ]]
 
     local a1 = Account; Account = nil
     a1.withdraw(a1, 100.00)
-    is(a1.balance, -100, "object")
+    equals(a1.balance, -100, "object")
 
     local a2 = {balance = 0, withdraw = a1.withdraw}
     a2.withdraw(a2, 260.00)
-    is(a2.balance, -260)
+    equals(a2.balance, -260)
 end
 
 do --[[ object ]]
@@ -53,7 +53,7 @@ do --[[ object ]]
 
     local a = Account
     a:withdraw(100.00)
-    is(a.balance, -100, "object")
+    equals(a.balance, -100, "object")
 
     Account = { balance = 0,
                 withdraw = function (self, v)
@@ -65,9 +65,9 @@ do --[[ object ]]
     end
 
     Account.deposit(Account, 200.00)
-    is(Account.balance, 200, "object")
+    equals(Account.balance, 200, "object")
     Account:withdraw(100.00)
-    is(Account.balance, 100)
+    equals(Account.balance, 100)
 end
 
 do --[[ class ]]
@@ -90,12 +90,12 @@ do --[[ class ]]
 
     local a = Account:new{balance = 0}
     a:deposit(100.00)
-    is(a.balance, 100, "classe")
+    equals(a.balance, 100, "classe")
 
     local b = Account:new()
-    is(b.balance, 0)
+    equals(b.balance, 0)
     b:deposit(200.00)
-    is(b.balance, 200)
+    equals(b.balance, 200)
 end
 
 do --[[ inheritance ]]
@@ -121,7 +121,7 @@ do --[[ inheritance ]]
     end
 
     local a = Account:new()
-    is(a.balance, 0, "inheritance")
+    equals(a.balance, 0, "inheritance")
     -- r, msg = pcall(Account.withdraw, a, 100)
     -- print(msg)
 
@@ -143,10 +143,10 @@ do --[[ inheritance ]]
     local s = SpecialAccount:new{limit=1000.00}
 
     s:deposit(100.00)
-    is(s.balance, 100)
+    equals(s.balance, 100)
 
     s:withdraw(200.00)
-    is(s.balance, -100)
+    equals(s.balance, -100)
 end
 
 do --[[ multiple inheritance ]]
@@ -201,9 +201,9 @@ do --[[ multiple inheritance ]]
     local NamedAccount = createClass(Account, Named)
 
     local account = NamedAccount:new{name = "Paul"}
-    is(account:getname(), 'Paul', "multiple inheritance")
+    equals(account:getname(), 'Paul', "multiple inheritance")
     account:deposit(100.00)
-    is(account.balance, 100)
+    equals(account.balance, 100)
 end
 
 do --[[ multiple inheritance (patched) ]]
@@ -259,9 +259,9 @@ do --[[ multiple inheritance (patched) ]]
     local NamedAccount = createClass(Account, Named)
 
     local account = NamedAccount:new{name = "Paul"}
-    is(account:getname(), 'Paul', "multiple inheritance (patched)")
+    equals(account:getname(), 'Paul', "multiple inheritance (patched)")
     account:deposit(100.00)
-    is(account.balance, 100)
+    equals(account.balance, 100)
 end
 
 do --[[ privacy ]]
@@ -287,7 +287,7 @@ do --[[ privacy ]]
 
     local acc1 = newAccount(100.00)
     acc1.withdraw(40.00)
-    is(acc1.getBalance(), 60, "privacy")
+    equals(acc1.getBalance(), 60, "privacy")
 end
 
 do --[[ single-method approach ]]
@@ -301,9 +301,9 @@ do --[[ single-method approach ]]
     end
 
     local d = newObject(0)
-    is(d('get'), 0, "single-method approach")
+    equals(d('get'), 0, "single-method approach")
     d('set', 10)
-    is(d('get'), 10)
+    equals(d('get'), 10)
 end
 
 -- Local Variables:
diff --git a/test/lua-Harness-tests/241-standalone.t.disabled b/test/lua-Harness-tests/241-standalone.t.disabled
index c5237eed..deb5421d 100755
--- a/test/lua-Harness-tests/241-standalone.t.disabled
+++ b/test/lua-Harness-tests/241-standalone.t.disabled
@@ -2,7 +2,7 @@
 --
 -- lua-Harness : <https://fperrad.frama.io/lua-Harness/>
 --
--- Copyright (C) 2009-2020, Perrad Francois
+-- Copyright (C) 2009-2021, Perrad Francois
 --
 -- This code is licensed under the terms of the MIT/X11 license,
 -- like Lua itself.
@@ -59,17 +59,17 @@ f:close()
 
 local cmd = lua .. " hello-241.lua"
 f = io.popen(cmd)
-is(f:read'*l', 'Hello World', "file")
+equals(f:read'*l', 'Hello World', "file")
 f:close()
 
 cmd = lua .. " -- hello-241.lua"
 f = io.popen(cmd)
-is(f:read'*l', 'Hello World', "-- file")
+equals(f:read'*l', 'Hello World', "-- file")
 f:close()
 
 cmd = lua .. " no_file-241.lua 2>&1"
 f = io.popen(cmd)
-like(f:read'*l', "^[^:]+: cannot open no_file%-241%.lua", "no file")
+matches(f:read'*l', "^[^:]+: cannot open no_file%-241%.lua", "no file")
 f:close()
 
 if has_bytecode then
@@ -80,7 +80,7 @@ if has_bytecode then
     end
     cmd = lua .. " hello-241.luac"
     f = io.popen(cmd)
-    is(f:read'*l', 'Hello World', "bytecode")
+    equals(f:read'*l', 'Hello World', "bytecode")
     f:close()
     os.remove('hello-241.luac') -- clean up
 
@@ -88,8 +88,8 @@ if has_bytecode then
         os.execute(luac .. " -s -o hello-hello-241.luac hello-241.lua hello-241.lua")
         cmd = lua .. " hello-hello-241.luac"
         f = io.popen(cmd)
-        is(f:read'*l', 'Hello World', "combine 1")
-        is(f:read'*l', 'Hello World', "combine 2")
+        equals(f:read'*l', 'Hello World', "combine 1")
+        equals(f:read'*l', 'Hello World', "combine 2")
         f:close()
         os.remove('hello-hello-241.luac') -- clean up
     end
@@ -97,116 +97,116 @@ end
 
 cmd = lua .. " < hello-241.lua"
 f = io.popen(cmd)
-is(f:read'*l', 'Hello World', "redirect")
+equals(f:read'*l', 'Hello World', "redirect")
 f:close()
 
 cmd = lua .. " - < hello-241.lua"
 f = io.popen(cmd)
-is(f:read'*l', 'Hello World', "redirect")
+equals(f:read'*l', 'Hello World', "redirect")
 f:close()
 
 cmd = lua .. " -i hello-241.lua < hello-241.lua 2>&1"
 f = io.popen(cmd)
-like(f:read'*l', banner, "-i")
+matches(f:read'*l', banner, "-i")
 if ujit then
-    like(f:read'*l', '^JIT:')
+    matches(f:read'*l', '^JIT:')
 end
 if ravi then
-    like(f:read'*l', '^Copyright %(C%)')
-    like(f:read'*l', '^Portions Copyright %(C%)')
-    like(f:read'*l', '^Options')
+    matches(f:read'*l', '^Copyright %(C%)')
+    matches(f:read'*l', '^Portions Copyright %(C%)')
+    matches(f:read'*l', '^Options')
 end
-is(f:read'*l', 'Hello World')
+equals(f:read'*l', 'Hello World')
 f:close()
 
 cmd = lua .. [[ -e"a=1" -e "print(a)"]]
 f = io.popen(cmd)
-is(f:read'*l', '1', "-e")
+equals(f:read'*l', '1', "-e")
 f:close()
 
 cmd = lua .. [[ -e "error('msg')"  2>&1]]
 f = io.popen(cmd)
-is(f:read'*l', lua .. [[: (command line):1: msg]], "error")
-is(f:read'*l', "stack traceback:", "backtrace")
+equals(f:read'*l', lua .. [[: (command line):1: msg]], "error")
+equals(f:read'*l', "stack traceback:", "backtrace")
 f:close()
 
 cmd = lua .. [[ -e "error(setmetatable({}, {__tostring=function() return 'MSG' end}))"  2>&1]]
 f = io.popen(cmd)
 if has_error52 or jit then
-    is(f:read'*l', lua .. [[: MSG]], "error with object")
+    equals(f:read'*l', lua .. [[: MSG]], "error with object")
 else
-    is(f:read'*l', lua .. [[: (error object is not a string)]], "error with object")
+    equals(f:read'*l', lua .. [[: (error object is not a string)]], "error with object")
 end
 if jit then
-    is(f:read'*l', "stack traceback:", "backtrace")
+    equals(f:read'*l', "stack traceback:", "backtrace")
 else
-    is(f:read'*l', nil, "not backtrace")
+    equals(f:read'*l', nil, "not backtrace")
 end
 f:close()
 
 cmd = lua .. [[ -e "error{}"  2>&1]]
 f = io.popen(cmd)
 if has_error53 then
-    is(f:read'l', lua .. [[: (error object is a table value)]], "error")
-    is(f:read'l', "stack traceback:", "backtrace")
+    equals(f:read'l', lua .. [[: (error object is a table value)]], "error")
+    equals(f:read'l', "stack traceback:", "backtrace")
 elseif has_error52 then
-    is(f:read'*l', lua .. [[: (no error message)]], "error")
-    is(f:read'*l', nil, "not backtrace")
+    equals(f:read'*l', lua .. [[: (no error message)]], "error")
+    equals(f:read'*l', nil, "not backtrace")
 else
-    is(f:read'*l', lua .. [[: (error object is not a string)]], "error")
-    is(f:read'*l', nil, "not backtrace")
+    equals(f:read'*l', lua .. [[: (error object is not a string)]], "error")
+    equals(f:read'*l', nil, "not backtrace")
 end
 f:close()
 
 cmd = lua .. [[ -e"a=1" -e "print(a)" hello-241.lua]]
 f = io.popen(cmd)
-is(f:read'*l', '1', "-e & script")
-is(f:read'*l', 'Hello World')
+equals(f:read'*l', '1', "-e & script")
+equals(f:read'*l', 'Hello World')
 f:close()
 
 cmd = lua .. [[ -e"a=1" -i < hello-241.lua 2>&1]]
 f = io.popen(cmd)
-like(f:read'*l', banner, "-e & -i")
+matches(f:read'*l', banner, "-e & -i")
 f:close()
 
 cmd = lua .. [[ -e "?syntax error?" 2>&1]]
 f = io.popen(cmd)
-like(f:read'*l', "^.-%d: unexpected symbol near '%?'", "-e bad")
+matches(f:read'*l', "^.-%d: unexpected symbol near '%?'", "-e bad")
 f:close()
 
 cmd = lua .. [[ -e 2>&1]]
 f = io.popen(cmd)
 if _VERSION ~= 'Lua 5.1' then
-    like(f:read'*l', "^[^:]+: '%-e' needs argument", "no file")
+    matches(f:read'*l', "^[^:]+: '%-e' needs argument", "-e w/o arg")
 end
-like(f:read'*l', "^usage: ", "no file")
+matches(f:read'*l', "^usage: ")
 f:close()
 
 cmd = lua .. [[ -v 2>&1]]
 f = io.popen(cmd)
-like(f:read'*l', banner, "-v")
+matches(f:read'*l', banner, "-v")
 f:close()
 
 cmd = lua .. [[ -v hello-241.lua 2>&1]]
 f = io.popen(cmd)
-like(f:read'*l', banner, "-v & script")
+matches(f:read'*l', banner, "-v & script")
 if ravi then
-    like(f:read'*l', '^Copyright %(C%)')
-    like(f:read'*l', '^Portions Copyright %(C%)')
-    like(f:read'*l', '^Options')
+    matches(f:read'*l', '^Copyright %(C%)')
+    matches(f:read'*l', '^Portions Copyright %(C%)')
+    matches(f:read'*l', '^Options')
 end
-is(f:read'*l', 'Hello World')
+equals(f:read'*l', 'Hello World')
 f:close()
 
 cmd = lua .. [[ -v -- 2>&1]]
 f = io.popen(cmd)
-like(f:read'*l', banner, "-v --")
+matches(f:read'*l', banner, "-v --")
 f:close()
 
 if has_opt_E then
     cmd = lua .. [[ -E hello-241.lua 2>&1]]
     f = io.popen(cmd)
-    is(f:read'*l', 'Hello World', "-E")
+    equals(f:read'*l', 'Hello World', "-E")
     f:close()
 else
     diag("no -E")
@@ -215,44 +215,52 @@ end
 cmd = lua .. [[ -u 2>&1]]
 f = io.popen(cmd)
 if _VERSION ~= 'Lua 5.1' then
-    like(f:read'*l', "^[^:]+: unrecognized option '%-u'", "unknown option")
+    matches(f:read'*l', "^[^:]+: unrecognized option '%-u'", "unknown option")
 end
-like(f:read'*l', "^usage: ", "no file")
+matches(f:read'*l', "^usage: ")
 f:close()
 
 cmd = lua .. [[ --u 2>&1]]
 f = io.popen(cmd)
 if _VERSION ~= 'Lua 5.1' then
-    like(f:read'*l', "^[^:]+: unrecognized option '%-%-u'", "unknown option")
+    matches(f:read'*l', "^[^:]+: unrecognized option '%-%-u'", "unknown option")
 end
-like(f:read'*l', "^usage: ", "no file")
+matches(f:read'*l', "^usage: ")
 f:close()
 
-cmd = lua .. [[ -ltap -e "print(type(ok))"]]
+f = io.open('foo.lua', 'w')
+f:write([[
+function FOO () end
+]])
+f:close()
+
+cmd = lua .. [[ -lfoo -e "print(type(FOO))"]]
 f = io.popen(cmd)
-is(f:read'*l', 'function', "-ltap")
+equals(f:read'*l', 'function', "-lfoo")
 f:close()
 
-cmd = lua .. [[ -l tap -e "print(type(ok))"]]
+cmd = lua .. [[ -l foo -e "print(type(FOO))"]]
 f = io.popen(cmd)
-is(f:read'*l', 'function', "-l tap")
+equals(f:read'*l', 'function', "-l foo")
 f:close()
 
+os.remove('foo.lua') -- clean up
+
 cmd = lua .. [[ -l lpeg -e "print(1)" 2>&1]]
 f = io.popen(cmd)
-isnt(f:read'*l', nil, "-l lpeg")
+not_equals(f:read'*l', nil, "-l lpeg")
 f:close()
 
 cmd = lua .. [[ -l no_lib hello-241.lua 2>&1]]
 f = io.popen(cmd)
-like(f:read'*l', "^[^:]+: module 'no_lib' not found:", "-l no lib")
+matches(f:read'*l', "^[^:]+: module 'no_lib' not found:", "-l no lib")
 f:close()
 
 if has_opt_W then
     cmd = lua .. [[ -W -e "warn'foo'" 2>&1]]
     f = io.popen(cmd)
-    is(f:read'*l', 'Lua warning: foo', "-W")
-    is(f:read'*l', nil)
+    equals(f:read'*l', 'Lua warning: foo', "-W")
+    equals(f:read'*l', nil)
     f:close()
 else
     diag("no -W")
diff --git a/test/lua-Harness-tests/242-luac.t b/test/lua-Harness-tests/242-luac.t
index a95a334a..9efabd01 100755
--- a/test/lua-Harness-tests/242-luac.t
+++ b/test/lua-Harness-tests/242-luac.t
@@ -2,7 +2,7 @@
 --
 -- lua-Harness : <https://fperrad.frama.io/lua-Harness/>
 --
--- Copyright (C) 2010-2020, Perrad Francois
+-- Copyright (C) 2010-2021, Perrad Francois
 --
 -- This code is licensed under the terms of the MIT/X11 license,
 -- like Lua itself.
@@ -79,67 +79,67 @@ end
 do -- luac -v
     local cmd = luac .. [[ -v 2>&1]]
     local f = io.popen(cmd)
-    like(f:read'*l', '^Lua', "-v")
+    matches(f:read'*l', '^Lua', "-v")
     f:close()
 end
 
 do -- luac -v --
     local cmd = luac .. [[ -v -- 2>&1]]
     local f = io.popen(cmd)
-    like(f:read'*l', '^Lua', "-v --")
+    matches(f:read'*l', '^Lua', "-v --")
     f:close()
 end
 
 do -- luac -u
     local cmd = luac .. [[ -u 2>&1]]
     local f = io.popen(cmd)
-    like(f:read'*l', "^[^:]+: unrecognized option '%-u'", "unknown option")
-    like(f:read'*l', "^usage:")
+    matches(f:read'*l', "^[^:]+: unrecognized option '%-u'", "unknown option")
+    matches(f:read'*l', "^usage:")
     f:close()
 end
 
 do -- luac --u
     local cmd = luac .. [[ --u 2>&1]]
     local f = io.popen(cmd)
-    like(f:read'*l', "^[^:]+: unrecognized option '%-%-u'", "unknown option")
-    like(f:read'*l', "^usage:")
+    matches(f:read'*l', "^[^:]+: unrecognized option '%-%-u'", "unknown option")
+    matches(f:read'*l', "^usage:")
     f:close()
 end
 
 do -- luac -p hello-242.lua
     local cmd = luac .. [[ -p hello-242.lua 2>&1]]
     local f = io.popen(cmd)
-    is(f:read'*l', nil)
+    equals(f:read'*l', nil)
     f:close()
 end
 
 do -- luac -p - < hello-242.lua
     local cmd = luac .. [[ -p - < hello-242.lua 2>&1]]
     local f = io.popen(cmd)
-    is(f:read'*l', nil)
+    equals(f:read'*l', nil)
     f:close()
 end
 
 do -- luac -p no_file-242.lua
     local cmd = luac .. [[ -p no_file-242.lua 2>&1]]
     local f = io.popen(cmd)
-    like(f:read'*l', "^[^:]+: cannot open no_file%-242%.lua", "no file")
+    matches(f:read'*l', "^[^:]+: cannot open no_file%-242%.lua", "no file")
     f:close()
 end
 
 do -- luac -o
     local cmd = luac .. [[ -o 2>&1]]
     local f = io.popen(cmd)
-    like(f:read'*l', "^[^:]+: '%-o' needs argument", "-o needs argument")
+    matches(f:read'*l', "^[^:]+: '%-o' needs argument", "-o needs argument")
     f:close()
 end
 
 do -- luac -v -l -l hello-242.lua
     local cmd = luac .. [[ -v -l -l hello-242.lua]]
     local f = io.popen(cmd)
-    like(f:read'*l', '^Lua', "-v -l -l")
-    is(f:read'*l', '')
-    like(f:read'*l', "^main")
+    matches(f:read'*l', '^Lua', "-v -l -l")
+    equals(f:read'*l', '')
+    matches(f:read'*l', "^main")
     f:close()
 end
 
@@ -148,24 +148,24 @@ os.remove('hello-242.lua') -- clean up
 do -- luac -l luac.out
     local cmd = luac .. [[ -l luac.out]]
     local f = io.popen(cmd)
-    is(f:read'*l', '', "-l luac.out")
-    like(f:read'*l', "^main")
+    equals(f:read'*l', '', "-l luac.out")
+    matches(f:read'*l', "^main")
     f:close()
 end
 
 do -- luac -l
     local cmd = luac .. [[ -l]]
     local f = io.popen(cmd)
-    is(f:read'*l', '', "-l")
-    like(f:read'*l', "^main")
+    equals(f:read'*l', '', "-l")
+    matches(f:read'*l', "^main")
     f:close()
 end
 
 do -- luac -l - < luac.out
     local cmd = luac .. [[ -l - < luac.out]]
     local f = io.popen(cmd)
-    is(f:read'*l', '', "-l -")
-    like(f:read'*l', "^main")
+    equals(f:read'*l', '', "-l -")
+    matches(f:read'*l', "^main")
     f:close()
 end
 
@@ -176,9 +176,9 @@ if _VERSION ~= 'Lua 5.1' then
     local cmd = luac .. [[ luac.out 2>&1]]
     f = io.popen(cmd)
     if _VERSION <= 'Lua 5.3' then
-        like(f:read'*l', "truncated precompiled chunk")
+        matches(f:read'*l', "truncated precompiled chunk")
     else
-        like(f:read'*l', "bad binary format %(truncated chunk%)")
+        matches(f:read'*l', "bad binary format %(truncated chunk%)")
     end
     f:close()
 end
@@ -190,9 +190,9 @@ if _VERSION ~= 'Lua 5.1' then -- bad signature
     local cmd = luac .. [[ luac.out 2>&1]]
     f = io.popen(cmd)
     if _VERSION <= 'Lua 5.3' then
-        like(f:read'*l', "not a precompiled chunk", "bad signature")
+        matches(f:read'*l', "not a precompiled chunk", "bad signature")
     else
-        like(f:read'*l', "bad binary format %(not a binary chunk%)", "bad signature")
+        matches(f:read'*l', "bad binary format %(not a binary chunk%)", "bad signature")
     end
     f:close()
 end
@@ -204,9 +204,9 @@ if _VERSION ~= 'Lua 5.1' then -- bad version
     local cmd = luac .. [[ luac.out 2>&1]]
     f = io.popen(cmd)
     if _VERSION <= 'Lua 5.3' then
-        like(f:read'*l', "version mismatch in precompiled chunk", "bad version")
+        matches(f:read'*l', "version mismatch in precompiled chunk", "bad version")
     else
-        like(f:read'*l', "bad binary format %(version mismatch%)", "bad version")
+        matches(f:read'*l', "bad binary format %(version mismatch%)", "bad version")
     end
     f:close()
 end
@@ -218,11 +218,11 @@ if _VERSION ~= 'Lua 5.1' then -- bad format
     local cmd = luac .. [[ luac.out 2>&1]]
     f = io.popen(cmd)
     if _VERSION == 'Lua 5.2' then
-        like(f:read'*l', "version mismatch in precompiled chunk", "bad format")
+        matches(f:read'*l', "version mismatch in precompiled chunk", "bad format")
     elseif _VERSION == 'Lua 5.3' then
-        like(f:read'*l', "format mismatch in precompiled chunk", "bad format")
+        matches(f:read'*l', "format mismatch in precompiled chunk", "bad format")
     else
-        like(f:read'*l', "bad binary format %(format mismatch%)", "bad format")
+        matches(f:read'*l', "bad binary format %(format mismatch%)", "bad format")
     end
     f:close()
 end
@@ -233,7 +233,7 @@ if _VERSION == 'Lua 5.2' then -- bad sizes
     f:close()
     local cmd = luac .. [[ luac.out 2>&1]]
     f = io.popen(cmd)
-    like(f:read'*l', "incompatible precompiled chunk", "incompatible 5.2")
+    matches(f:read'*l', "incompatible precompiled chunk", "incompatible 5.2")
     f:close()
 end
 
@@ -244,7 +244,7 @@ if _VERSION == 'Lua 5.2' then -- bad data / tail
     f:close()
     local cmd = luac .. [[ luac.out 2>&1]]
     f = io.popen(cmd)
-    like(f:read'*l', "corrupted precompiled chunk", "corrupted 5.2")
+    matches(f:read'*l', "corrupted precompiled chunk", "corrupted 5.2")
     f:close()
 end
 
@@ -254,7 +254,7 @@ if _VERSION == 'Lua 5.3' then -- bad data
     f:close()
     local cmd = luac .. [[ luac.out 2>&1]]
     f = io.popen(cmd)
-    like(f:read'*l', "corrupted precompiled chunk", "corrupted")
+    matches(f:read'*l', "corrupted precompiled chunk", "corrupted")
     f:close()
 end
 
@@ -264,7 +264,7 @@ if _VERSION == 'Lua 5.3' then -- bad sizes
     f:close()
     local cmd = luac .. [[ luac.out 2>&1]]
     f = io.popen(cmd)
-    like(f:read'*l', "int size mismatch in precompiled chunk", "bad sizes")
+    matches(f:read'*l', "int size mismatch in precompiled chunk", "bad sizes")
     f:close()
 end
 
@@ -274,7 +274,7 @@ if _VERSION == 'Lua 5.3' then -- bad endianess
     f:close()
     local cmd = luac .. [[ luac.out 2>&1]]
     f = io.popen(cmd)
-    like(f:read'*l', "endianness mismatch in precompiled chunk", "bad endian")
+    matches(f:read'*l', "endianness mismatch in precompiled chunk", "bad endian")
     f:close()
 end
 
@@ -285,7 +285,7 @@ if _VERSION == 'Lua 5.3' then -- bad float format
     f:close()
     local cmd = luac .. [[ luac.out 2>&1]]
     f = io.popen(cmd)
-    like(f:read'*l', "float format mismatch in precompiled chunk")
+    matches(f:read'*l', "float format mismatch in precompiled chunk")
     f:close()
 end
 
@@ -312,19 +312,19 @@ s = nil
 
     local cmd = luac .. [[ -o cover-242.out cover-242.lua 2>&1]]
     f = io.popen(cmd)
-    is(f:read'*l', nil, "-o cover-242.out cover-242.lua")
+    equals(f:read'*l', nil, "-o cover-242.out cover-242.lua")
     f:close()
 
     cmd = luac .. [[ -l cover-242.out]]
     f = io.popen(cmd)
-    is(f:read'*l', '', "-l cover-242.out")
-    like(f:read'*l', "^main")
+    equals(f:read'*l', '', "-l cover-242.out")
+    matches(f:read'*l', "^main")
     f:close()
 
     cmd = luac .. [[ -l -l cover-242.out]]
     f = io.popen(cmd)
-    is(f:read'*l', '', "-l -l cover-242.out")
-    like(f:read'*l', "^main")
+    equals(f:read'*l', '', "-l -l cover-242.out")
+    matches(f:read'*l', "^main")
     f:close()
 end
 
diff --git a/test/lua-Harness-tests/301-basic.t b/test/lua-Harness-tests/301-basic.t
index a4bb09ff..415cc497 100755
--- a/test/lua-Harness-tests/301-basic.t
+++ b/test/lua-Harness-tests/301-basic.t
@@ -2,7 +2,7 @@
 --
 -- lua-Harness : <https://fperrad.frama.io/lua-Harness/>
 --
--- Copyright (C) 2009-2020, Perrad Francois
+-- Copyright (C) 2009-2021, Perrad Francois
 --
 -- This code is licensed under the terms of the MIT/X11 license,
 -- like Lua itself.
@@ -54,32 +54,32 @@ plan'no_plan'
 
 do -- assert
     local v, msg = assert('text', "assert string")
-    is(v, 'text', "function assert")
-    is(msg, "assert string")
+    equals(v, 'text', "function assert")
+    equals(msg, "assert string")
     v, msg = assert({}, "assert table")
-    is(msg, "assert table")
+    equals(msg, "assert table")
 
-    error_like(function () assert(false, "ASSERTION TEST") end,
-               "^[^:]+:%d+: ASSERTION TEST",
-               "function assert(false, msg)")
+    error_matches(function () assert(false, "ASSERTION TEST") end,
+            "^[^:]+:%d+: ASSERTION TEST",
+            "function assert(false, msg)")
 
-    error_like(function () assert(false) end,
-               "^[^:]+:%d+: assertion failed!",
-               "function assert(false)")
+    error_matches(function () assert(false) end,
+            "^[^:]+:%d+: assertion failed!",
+            "function assert(false)")
 
     if has_error53 then
         v, msg = pcall(function() assert(false, 42) end)
-        is(msg, 42, "function assert(false, 42)")
+        equals(msg, 42, "function assert(false, 42)")
     else
-        error_like(function () assert(false, 42) end,
-                   "^[^:]+:%d+: 42",
-                   "function assert(false, 42)")
+        error_matches(function () assert(false, 42) end,
+                "^[^:]+:%d+: 42",
+                "function assert(false, 42)")
     end
 
     if has_error53 then
         local obj = {}
         v, msg = pcall(function() assert(false, obj) end)
-        is(msg, obj, "function assert(false, {})")
+        equals(msg, obj, "function assert(false, {})")
     else
         diag("no assert with table")
     end
@@ -87,71 +87,71 @@ end
 
 -- collectgarbage
 if jit then
-    is(collectgarbage('stop'), 0, "function collectgarbage 'stop/restart/collect'")
-    is(collectgarbage('step'), false)
-    is(collectgarbage('restart'), 0)
-    is(collectgarbage('step'), false)
-    is(collectgarbage('collect'), 0)
-    is(collectgarbage('setpause', 10), 200)
-    is(collectgarbage('setstepmul', 200), 200)
-    is(collectgarbage(), 0)
+    equals(collectgarbage('stop'), 0, "function collectgarbage 'stop/restart/collect'")
+    equals(collectgarbage('step'), false)
+    equals(collectgarbage('restart'), 0)
+    equals(collectgarbage('step'), false)
+    equals(collectgarbage('collect'), 0)
+    equals(collectgarbage('setpause', 10), 200)
+    equals(collectgarbage('setstepmul', 200), 200)
+    equals(collectgarbage(), 0)
 elseif _VERSION == 'Lua 5.1' then
-    is(collectgarbage('stop'), 0, "function collectgarbage 'stop/restart/collect'")
-    is(collectgarbage('restart'), 0)
-    is(collectgarbage('step'), false)
-    is(collectgarbage('collect'), 0)
-    is(collectgarbage(), 0)
+    equals(collectgarbage('stop'), 0, "function collectgarbage 'stop/restart/collect'")
+    equals(collectgarbage('restart'), 0)
+    equals(collectgarbage('step'), false)
+    equals(collectgarbage('collect'), 0)
+    equals(collectgarbage(), 0)
 elseif _VERSION == 'Lua 5.2' then
-    is(collectgarbage('stop'), 0, "function collectgarbage 'stop/restart/collect'")
-    is(collectgarbage('isrunning'), false)
-    is(collectgarbage('step'), false)
-    is(collectgarbage('restart'), 0)
-    is(collectgarbage('isrunning'), true)
-    is(collectgarbage('step'), false)
-    is(collectgarbage('collect'), 0)
-    is(collectgarbage('setpause', 10), 200)
-    is(collectgarbage('setstepmul', 200), 200)
-    is(collectgarbage(), 0)
-    is(collectgarbage('generational'), 0)
-    is(collectgarbage('step'), false)
-    is(collectgarbage('incremental'), 0)
-    is(collectgarbage('setmajorinc'), 200)
+    equals(collectgarbage('stop'), 0, "function collectgarbage 'stop/restart/collect'")
+    equals(collectgarbage('isrunning'), false)
+    equals(collectgarbage('step'), false)
+    equals(collectgarbage('restart'), 0)
+    equals(collectgarbage('isrunning'), true)
+    equals(collectgarbage('step'), false)
+    equals(collectgarbage('collect'), 0)
+    equals(collectgarbage('setpause', 10), 200)
+    equals(collectgarbage('setstepmul', 200), 200)
+    equals(collectgarbage(), 0)
+    equals(collectgarbage('generational'), 0)
+    equals(collectgarbage('step'), false)
+    equals(collectgarbage('incremental'), 0)
+    equals(collectgarbage('setmajorinc'), 200)
 elseif _VERSION == 'Lua 5.3' then
-    is(collectgarbage('stop'), 0, "function collectgarbage 'stop/restart/collect'")
-    is(collectgarbage('isrunning'), false)
-    --is(collectgarbage('step'), false)
-    type_ok(collectgarbage('step'), 'boolean')
-    is(collectgarbage('restart'), 0)
-    is(collectgarbage('isrunning'), true)
-    is(collectgarbage('step'), false)
-    is(collectgarbage('collect'), 0)
-    is(collectgarbage('setpause', 10), 200)
-    is(collectgarbage('setstepmul', 200), 200)
-    is(collectgarbage(), 0)
-    is(collectgarbage('step'), false)
+    equals(collectgarbage('stop'), 0, "function collectgarbage 'stop/restart/collect'")
+    equals(collectgarbage('isrunning'), false)
+    --equals(collectgarbage('step'), false)
+    is_boolean(collectgarbage('step'))
+    equals(collectgarbage('restart'), 0)
+    equals(collectgarbage('isrunning'), true)
+    equals(collectgarbage('step'), false)
+    equals(collectgarbage('collect'), 0)
+    equals(collectgarbage('setpause', 10), 200)
+    equals(collectgarbage('setstepmul', 200), 200)
+    equals(collectgarbage(), 0)
+    equals(collectgarbage('step'), false)
 elseif _VERSION == 'Lua 5.4' then
-    is(collectgarbage('stop'), 0, "function collectgarbage 'stop/restart/collect'")
-    is(collectgarbage('isrunning'), false)
-    is(collectgarbage('generational'), 'generational')
-    is(collectgarbage('incremental'), 'generational')
-    is(collectgarbage('incremental'), 'incremental')
-    is(collectgarbage('generational'), 'incremental')
-    is(collectgarbage('step'), false)
-    is(collectgarbage('restart'), 0)
-    is(collectgarbage('isrunning'), true)
-    is(collectgarbage('step'), false)
-    is(collectgarbage('collect'), 0)
-    is(collectgarbage('setpause', 10), 200)
-    is(collectgarbage('setstepmul', 200), 100)
-    is(collectgarbage(), 0)
-    is(collectgarbage('step'), false)
-end
-
-type_ok(collectgarbage('count'), 'number', "function collectgarbage 'count'")
-
-error_like(function () collectgarbage('unknown') end,
-           "^[^:]+:%d+: bad argument #1 to 'collectgarbage' %(invalid option 'unknown'%)",
-           "function collectgarbage (invalid)")
+    equals(collectgarbage('stop'), 0, "function collectgarbage 'stop/restart/collect'")
+    equals(collectgarbage('isrunning'), false)
+    equals(collectgarbage('generational'), 'generational')
+    equals(collectgarbage('incremental'), 'generational')
+    equals(collectgarbage('incremental'), 'incremental')
+    equals(collectgarbage('generational'), 'incremental')
+    equals(collectgarbage('step'), false)
+    equals(collectgarbage('restart'), 0)
+    equals(collectgarbage('isrunning'), true)
+    equals(collectgarbage('step'), false)
+    equals(collectgarbage('collect'), 0)
+    equals(collectgarbage('setpause', 10), 200)
+    equals(collectgarbage('setstepmul', 200), 100)
+    equals(collectgarbage(), 0)
+    equals(collectgarbage('step'), false)
+end
+
+is_number(collectgarbage('count'), "function collectgarbage 'count'")
+
+error_matches(function () collectgarbage('unknown') end,
+        "^[^:]+:%d+: bad argument #1 to 'collectgarbage' %(invalid option 'unknown'%)",
+        "function collectgarbage (invalid)")
 
 do -- dofile
     local f = io.open('lib-301.lua', 'w')
@@ -167,91 +167,91 @@ end
     f:close()
     dofile('lib-301.lua')
     local n = norm(3.4, 1.0)
-    like(twice(n), '^7%.088', "function dofile")
+    matches(twice(n), '^7%.088', "function dofile")
 
     os.remove('lib-301.lua') -- clean up
 
-    error_like(function () dofile('no_file-301.lua') end,
-               "cannot open no_file%-301%.lua: No such file or directory",
-               "function dofile (no file)")
+    error_matches(function () dofile('no_file-301.lua') end,
+            "cannot open no_file%-301%.lua: No such file or directory",
+            "function dofile (no file)")
 
     f = io.open('foo-301.lua', 'w')
     f:write[[?syntax error?]]
     f:close()
-    error_like(function () dofile('foo-301.lua') end,
-               "^foo%-301%.lua:%d+:",
-               "function dofile (syntax error)")
+    error_matches(function () dofile('foo-301.lua') end,
+            "^foo%-301%.lua:%d+:",
+            "function dofile (syntax error)")
 
     os.remove('foo-301.lua') -- clean up
 end
 
 do -- error
-    error_like(function () error("ERROR TEST") end,
-               "^[^:]+:%d+: ERROR TEST",
-               "function error(msg)")
+    error_matches(function () error("ERROR TEST") end,
+            "^[^:]+:%d+: ERROR TEST",
+            "function error(msg)")
 
-    error_is(function () error("ERROR TEST", 0) end,
-             "ERROR TEST",
-             "function error(msg, 0)")
+    error_equals(function () error("ERROR TEST", 0) end,
+            "ERROR TEST",
+            "function error(msg, 0)")
 
     if has_error53 then
         local v, msg = pcall(function() error(42) end)
-        is(msg, 42, "function error(42)")
+        equals(msg, 42, "function error(42)")
     else
-        error_like(function () error(42) end,
-                   "^[^:]+:%d+: 42",
-                   "function error(42)")
+        error_matches(function () error(42) end,
+                "^[^:]+:%d+: 42",
+                "function error(42)")
     end
 
     local obj = {}
     local v, msg = pcall(function() error(obj) end)
-    is(msg, obj, "function error({})")
+    equals(msg, obj, "function error({})")
 
     v, msg = pcall(function() error() end)
-    is(msg, nil, "function error()")
+    equals(msg, nil, "function error()")
 end
 
 -- gcinfo
 if has_gcinfo then
-    type_ok(gcinfo(), 'number', "function gcinfo")
+    is_number(gcinfo(), "function gcinfo")
 else
-    is(gcinfo, nil, "no gcinfo (removed)")
+    is_nil(gcinfo, "no gcinfo (removed)")
 end
 
 -- getfenv
 if has_getfenv then
-    type_ok(getfenv(0), 'table', "function getfenv")
-    is(getfenv(0), _G)
-    is(getfenv(1), _G)
-    is(getfenv(), _G)
+    is_table(getfenv(0), "function getfenv")
+    equals(getfenv(0), _G)
+    equals(getfenv(1), _G)
+    equals(getfenv(), _G)
     local function f () end
-    type_ok(getfenv(f), 'table')
-    is(getfenv(f), _G)
-    type_ok(getfenv(print), 'table')
-    is(getfenv(print), _G)
-
-    error_like(function () getfenv(-3) end,
-               "^[^:]+:%d+: bad argument #1 to 'getfenv' %(.-level.-%)",
-              "function getfenv (negative)")
-
-    error_like(function () getfenv(12) end,
-               "^[^:]+:%d+: bad argument #1 to 'getfenv' %(invalid level%)",
-               "function getfenv (too depth)")
+    is_table(getfenv(f))
+    equals(getfenv(f), _G)
+    is_table(getfenv(print))
+    equals(getfenv(print), _G)
+
+    error_matches(function () getfenv(-3) end,
+            "^[^:]+:%d+: bad argument #1 to 'getfenv' %(.-level.-%)",
+            "function getfenv (negative)")
+
+    error_matches(function () getfenv(12) end,
+            "^[^:]+:%d+: bad argument #1 to 'getfenv' %(invalid level%)",
+            "function getfenv (too depth)")
 else
-    is(getfenv, nil, "no getfenv")
+    is_nil(getfenv, "no getfenv")
 end
 
 do -- getmetatable
-    is(getmetatable(true), nil, "boolean has no metatable by default")
-    is(getmetatable(getmetatable), nil, "function has no metatable by default")
-    is(getmetatable(nil), nil, "nil has no metatable by default")
-    is(getmetatable(3.14), nil, "number has no metatable by default")
-    is(getmetatable({}), nil, "table has no metatable by default")
+    equals(getmetatable(true), nil, "boolean has no metatable by default")
+    equals(getmetatable(getmetatable), nil, "function has no metatable by default")
+    equals(getmetatable(nil), nil, "nil has no metatable by default")
+    equals(getmetatable(3.14), nil, "number has no metatable by default")
+    equals(getmetatable({}), nil, "table has no metatable by default")
     local co = coroutine.create(function () return 1 end)
-    is(getmetatable(co), nil, "thread has no metatable by default")
+    equals(getmetatable(co), nil, "thread has no metatable by default")
 
-    type_ok(getmetatable('ABC'), 'table', "string has a metatable")
-    is(getmetatable('ABC'), getmetatable('abc'), "string has a shared metatable")
+    is_table(getmetatable('ABC'), "string has a metatable")
+    equals(getmetatable('ABC'), getmetatable('abc'), "string has a shared metatable")
 end
 
 do -- ipairs
@@ -267,21 +267,21 @@ do -- ipairs
         })
     end
     local f, v, s = ipairs(a)
-    type_ok(f, 'function', "function ipairs")
-    type_ok(v, 'table')
-    is(s, 0)
+    is_function(f, "function ipairs")
+    is_table(v)
+    equals(s, 0)
     s, v = f(a, s)
-    is(s, 1)
-    is(v, 'a')
+    equals(s, 1)
+    equals(v, 'a')
     s, v = f(a, s)
-    is(s, 2)
-    is(v, 'b')
+    equals(s, 2)
+    equals(v, 'b')
     s, v = f(a, s)
-    is(s, 3)
-    is(v, 'c')
+    equals(s, 3)
+    equals(v, 'c')
     s, v = f(a, s)
-    is(s, nil)
-    is(v, nil)
+    equals(s, nil)
+    equals(v, nil)
 end
 
 do -- load
@@ -299,10 +299,10 @@ end
     if msg then
         diag(msg)
     end
-    type_ok(f, 'function', "function load(reader)")
-    is(bar, nil)
+    is_function(f, "function load(reader)")
+    equals(bar, nil)
     f()
-    is(bar('ok'), 'ok')
+    equals(bar('ok'), 'ok')
     bar = nil
 
     t = { [[
@@ -319,25 +319,25 @@ end
     if msg then
         diag(msg)
     end
-    type_ok(f, 'function', "function load(pathological reader)")
+    is_function(f, "function load(pathological reader)")
     f()
     if _VERSION == 'Lua 5.1' and not jit then
         todo("not with 5.1")
     end
-    is(baz, nil)
+    equals(baz, nil)
 
     t = { [[?syntax error?]] }
     i = 0
     f, msg = load(reader, "errorchunk")
-    is(f, nil, "function load(syntax error)")
-    like(msg, "^%[string \"errorchunk\"%]:%d+:")
+    is_nil(f, "function load(syntax error)")
+    matches(msg, "^%[string \"errorchunk\"%]:%d+:")
 
     f = load(function () return nil end)
-    type_ok(f, 'function', "when reader returns nothing")
+    is_function(f, "when reader returns nothing")
 
     f, msg = load(function () return {} end)
-    is(f, nil, "reader function must return a string")
-    like(msg, "reader function must return a string")
+    is_nil(f, "reader function must return a string")
+    matches(msg, "reader function must return a string")
 
     if has_load52 then
         f = load([[
@@ -345,9 +345,9 @@ function bar (x)
     return x
 end
 ]])
-        is(bar, nil, "function load(str)")
+        equals(bar, nil, "function load(str)")
         f()
-        is(bar('ok'), 'ok')
+        equals(bar('ok'), 'ok')
         bar = nil
 
         local env = {}
@@ -356,21 +356,21 @@ function bar (x)
     return x
 end
 ]], "from string", 't', env)
-        is(env.bar, nil, "function load(str)")
+        equals(env.bar, nil, "function load(str)")
         f()
-        is(env.bar('ok'), 'ok')
+        equals(env.bar('ok'), 'ok')
 
         f, msg = load([[?syntax error?]], "errorchunk")
-        is(f, nil, "function load(syntax error)")
-        like(msg, "^%[string \"errorchunk\"%]:%d+:")
+        is_nil(f, "function load(syntax error)")
+        matches(msg, "^%[string \"errorchunk\"%]:%d+:")
 
         f, msg = load([[print 'ok']], "chunk txt", 'b')
-        like(msg, "attempt to load")
-        is(f, nil, "mode")
+        matches(msg, "attempt to load")
+        is_nil(f, "mode")
 
         f, msg = load("\x1bLua", "chunk bin", 't')
-        like(msg, "attempt to load")
-        is(f, nil, "mode")
+        matches(msg, "attempt to load")
+        is_nil(f, "mode")
     else
        diag("no load with string")
     end
@@ -388,21 +388,21 @@ end
 ]]
     f:close()
     f = loadfile('foo-301.lua')
-    is(foo, nil, "function loadfile")
+    equals(foo, nil, "function loadfile")
     f()
-    is(foo('ok'), 'ok')
+    equals(foo('ok'), 'ok')
 
     if has_loadfile52 then
         local msg
         f, msg = loadfile('foo-301.lua', 'b')
-        like(msg, "attempt to load")
-        is(f, nil, "mode")
+        matches(msg, "attempt to load")
+        is_nil(f, "mode")
 
         local env = {}
         f = loadfile('foo-301.lua', 't', env)
-        is(env.foo, nil, "function loadfile")
+        equals(env.foo, nil, "function loadfile")
         f()
-        is(env.foo('ok'), 'ok')
+        equals(env.foo('ok'), 'ok')
     else
         diag("no loadfile with mode & env")
     end
@@ -411,15 +411,15 @@ end
 
     local msg
     f, msg = loadfile('no_file-301.lua')
-    is(f, nil, "function loadfile (no file)")
-    is(msg, "cannot open no_file-301.lua: No such file or directory")
+    is_nil(f, "function loadfile (no file)")
+    equals(msg, "cannot open no_file-301.lua: No such file or directory")
 
     f = io.open('foo-301.lua', 'w')
     f:write[[?syntax error?]]
     f:close()
     f, msg = loadfile('foo-301.lua')
-    is(f, nil, "function loadfile (syntax error)")
-    like(msg, '^foo%-301%.lua:%d+:')
+    is_nil(f, "function loadfile (syntax error)")
+    matches(msg, '^foo%-301%.lua:%d+:')
     os.remove('foo-301.lua') -- clean up
 end
 
@@ -428,187 +428,187 @@ if has_loadstring then
     local f = loadstring([[i = i + 1]])
     i = 0
     f()
-    is(i, 1, "function loadstring")
+    equals(i, 1, "function loadstring")
     f()
-    is(i, 2)
+    equals(i, 2)
 
     i = 32
     local i = 0
     f = loadstring([[i = i + 1; return i]])
     local g = function () i = i + 1; return i end
-    is(f(), 33, "function loadstring")
-    is(g(), 1)
+    equals(f(), 33, "function loadstring")
+    equals(g(), 1)
 
     local msg
     f, msg = loadstring([[?syntax error?]])
-    is(f, nil, "function loadstring (syntax error)")
-    like(msg, '^%[string "%?syntax error%?"%]:%d+:')
+    is_nil(f, "function loadstring (syntax error)")
+    matches(msg, '^%[string "%?syntax error%?"%]:%d+:')
 elseif has_alias_loadstring then
-    is(loadstring, load, "alias loadstring")
+    equals(loadstring, load, "alias loadstring")
 else
-    is(loadstring, nil, "no loadstring")
+    is_nil(loadstring, "no loadstring")
 end
 
 -- newproxy
 if has_newproxy then
     local proxy = newproxy(false)
-    type_ok(proxy, 'userdata', "function newproxy(false)")
-    is(getmetatable(proxy), nil, "without metatable")
+    is_userdata(proxy, "function newproxy(false)")
+    is_nil(getmetatable(proxy), "without metatable")
     proxy = newproxy(true)
-    type_ok(proxy, 'userdata', "function newproxy(true)")
-    type_ok(getmetatable(proxy), 'table', "with metatable")
+    is_userdata(proxy, "function newproxy(true)")
+    is_table(getmetatable(proxy), "with metatable")
 
     local proxy2 = newproxy(proxy)
-    type_ok(proxy, 'userdata', "function newproxy(proxy)")
-    is(getmetatable(proxy2), getmetatable(proxy))
+    is_userdata(proxy, "function newproxy(proxy)")
+    equals(getmetatable(proxy2), getmetatable(proxy))
 
-    error_like(function () newproxy({}) end,
-               "^[^:]+:%d+: bad argument #1 to 'newproxy' %(boolean or proxy expected%)",
-               "function newproxy({})")
+    error_matches(function () newproxy({}) end,
+            "^[^:]+:%d+: bad argument #1 to 'newproxy' %(boolean or proxy expected%)",
+            "function newproxy({})")
 else
-    is(newproxy, nil, "no newproxy")
+    is_nil(newproxy, "no newproxy")
 end
 
 do -- next
     local t = {'a','b','c'}
     local a = next(t, nil)
-    is(a, 1, "function next (array)")
+    equals(a, 1, "function next (array)")
     a = next(t, 1)
-    is(a, 2)
+    equals(a, 2)
     a = next(t, 2)
-    is(a, 3)
+    equals(a, 3)
     a = next(t, 3)
-    is(a, nil)
+    equals(a, nil)
 
-    error_like(function () a = next() end,
-               "^[^:]+:%d+: bad argument #1 to 'next' %(table expected, got no value%)",
-               "function next (no arg)")
+    error_matches(function () a = next() end,
+            "^[^:]+:%d+: bad argument #1 to 'next' %(table expected, got no value%)",
+            "function next (no arg)")
 
-    error_like(function () a = next(t, 6) end,
-               "invalid key to 'next'",
-               "function next (invalid key)")
+    error_matches(function () a = next(t, 6) end,
+            "invalid key to 'next'",
+            "function next (invalid key)")
 
     t = {'a','b','c'}
     a = next(t, 2)
-    is(a, 3, "function next (unorderer)")
+    equals(a, 3, "function next (unorderer)")
     a = next(t, 1)
-    is(a, 2)
+    equals(a, 2)
     a = next(t, 3)
-    is(a, nil)
+    equals(a, nil)
 
     t = {}
     a = next(t, nil)
-    is(a, nil, "function next (empty table)")
+    equals(a, nil, "function next (empty table)")
 end
 
 do -- pairs
     local a = {'a','b','c'}
     local f, v, s = pairs(a)
-    type_ok(f, 'function', "function pairs")
-    type_ok(v, 'table')
-    is(s, nil)
+    is_function(f, "function pairs")
+    is_table(v)
+    equals(s, nil)
     s = f(v, s)
-    is(s, 1)
+    equals(s, 1)
     s = f(v, s)
-    is(s, 2)
+    equals(s, 2)
     s = f(v, s)
-    is(s, 3)
+    equals(s, 3)
     s = f(v, s)
-    is(s, nil)
+    equals(s, nil)
 end
 
 do -- pcall
     local status, result = pcall(assert, 1)
-    is(status, true, "function pcall")
-    is(result, 1)
+    is_true(status, "function pcall")
+    equals(result, 1)
     status, result = pcall(assert, false, 'catched')
-    is(status, false)
-    is(result, 'catched')
+    is_false(status)
+    equals(result, 'catched')
     status = pcall(assert)
-    is(status, false)
+    is_false(status)
 end
 
 do -- rawequal
     local t = {}
     local a = t
-    is(rawequal(nil, nil), true, "function rawequal -> true")
-    is(rawequal(false, false), true)
-    is(rawequal(3, 3), true)
-    is(rawequal('text', 'text'), true)
-    is(rawequal(t, a), true)
-    is(rawequal(print, print), true)
-
-    is(rawequal(nil, 2), false, "function rawequal -> false")
-    is(rawequal(false, true), false)
-    is(rawequal(false, 2), false)
-    is(rawequal(3, 2), false)
-    is(rawequal(3, '2'), false)
-    is(rawequal('text', '2'), false)
-    is(rawequal('text', 2), false)
-    is(rawequal(t, {}), false)
-    is(rawequal(t, 2), false)
-    is(rawequal(print, type), false)
-    is(rawequal(print, 2), false)
+    is_true(rawequal(nil, nil), "function rawequal -> true")
+    is_true(rawequal(false, false))
+    is_true(rawequal(3, 3))
+    is_true(rawequal('text', 'text'))
+    is_true(rawequal(t, a))
+    is_true(rawequal(print, print))
+
+    is_false(rawequal(nil, 2), "function rawequal -> false")
+    is_false(rawequal(false, true))
+    is_false(rawequal(false, 2))
+    is_false(rawequal(3, 2))
+    is_false(rawequal(3, '2'))
+    is_false(rawequal('text', '2'))
+    is_false(rawequal('text', 2))
+    is_false(rawequal(t, {}))
+    is_false(rawequal(t, 2))
+    is_false(rawequal(print, type))
+    is_false(rawequal(print, 2))
 end
 
 -- rawlen
 if has_rawlen then
-    is(rawlen("text"), 4, "function rawlen (string)")
-    is(rawlen({ 'a', 'b', 'c'}), 3, "function rawlen (table)")
-    error_like(function () local a = rawlen(true) end,
-               "^[^:]+:%d+: bad argument #1 to 'rawlen' %(table ",
-               "function rawlen (bad arg)")
+    equals(rawlen("text"), 4, "function rawlen (string)")
+    equals(rawlen({ 'a', 'b', 'c'}), 3, "function rawlen (table)")
+    error_matches(function () local a = rawlen(true) end,
+            "^[^:]+:%d+: bad argument #1 to 'rawlen' %(table ",
+            "function rawlen (bad arg)")
 else
-    is(rawlen, nil, "no rawlen")
+    is_nil(rawlen, "no rawlen")
 end
 
 do -- rawget
     local t = {a = 'letter a', b = 'letter b'}
-    is(rawget(t, 'a'), 'letter a', "function rawget")
+    equals(rawget(t, 'a'), 'letter a', "function rawget")
 end
 
 do -- rawset
     local t = {}
-    is(rawset(t, 'a', 'letter a'), t, "function rawset")
-    is(t.a, 'letter a')
+    equals(rawset(t, 'a', 'letter a'), t, "function rawset")
+    equals(t.a, 'letter a')
 
-    error_like(function () t = {}; rawset(t, nil, 42) end,
-               "^table index is nil",
-               "function rawset (table index is nil)")
+    error_matches(function () t = {}; rawset(t, nil, 42) end,
+            "^table index is nil",
+            "function rawset (table index is nil)")
 end
 
 do -- select
-    is(select('#'), 0, "function select")
-    is(select('#','a','b','c'), 3)
-    eq_array({select(1,'a','b','c')}, {'a','b','c'})
-    eq_array({select(3,'a','b','c')}, {'c'})
-    eq_array({select(5,'a','b','c')}, {})
-    eq_array({select(-1,'a','b','c')}, {'c'})
-    eq_array({select(-2,'a','b','c')}, {'b', 'c'})
-    eq_array({select(-3,'a','b','c')}, {'a', 'b', 'c'})
+    equals(select('#'), 0, "function select")
+    equals(select('#','a','b','c'), 3)
+    array_equals({select(1,'a','b','c')}, {'a','b','c'})
+    array_equals({select(3,'a','b','c')}, {'c'})
+    array_equals({select(5,'a','b','c')}, {})
+    array_equals({select(-1,'a','b','c')}, {'c'})
+    array_equals({select(-2,'a','b','c')}, {'b', 'c'})
+    array_equals({select(-3,'a','b','c')}, {'a', 'b', 'c'})
 
-    error_like(function () select(0,'a','b','c') end,
-               "^[^:]+:%d+: bad argument #1 to 'select' %(index out of range%)",
-               "function select (out of range)")
+    error_matches(function () select(0,'a','b','c') end,
+            "^[^:]+:%d+: bad argument #1 to 'select' %(index out of range%)",
+            "function select (out of range)")
 
-    error_like(function () select(-4,'a','b','c') end,
-               "^[^:]+:%d+: bad argument #1 to 'select' %(index out of range%)",
-               "function select (out of range)")
+    error_matches(function () select(-4,'a','b','c') end,
+            "^[^:]+:%d+: bad argument #1 to 'select' %(index out of range%)",
+            "function select (out of range)")
 end
 
 -- setfenv
 if has_getfenv then
     local t = {}
     local function f () end
-    is(setfenv(f, t), f, "function setfenv")
-    type_ok(getfenv(f), 'table')
-    is(getfenv(f), t)
+    equals(setfenv(f, t), f, "function setfenv")
+    is_table(getfenv(f))
+    equals(getfenv(f), t)
 
     save = getfenv(1)
     a = 1
     setfenv(1, {g = _G})
-    g.is(a, nil, "function setfenv")
-    g.is(g.a, 1)
+    g.equals(a, nil, "function setfenv")
+    g.equals(g.a, 1)
     g.setfenv(1, g.save) -- restore
 
     save = getfenv(1)
@@ -616,12 +616,12 @@ if has_getfenv then
     local newgt = {}        -- create new environment
     setmetatable(newgt, {__index = _G})
     setfenv(1, newgt)       -- set it
-    is(a, 1, "function setfenv")
+    equals(a, 1, "function setfenv")
     a = 10
-    is(a, 10)
-    is(_G.a, 1)
+    equals(a, 10)
+    equals(_G.a, 1)
     _G.a = 20
-    is(_G.a, 20)
+    equals(_G.a, 20)
     setfenv(1, save) -- restore
 
     save = getfenv(1)
@@ -633,165 +633,165 @@ if has_getfenv then
     a = 3
     local f1 = factory()
     local f2 = factory()
-    is(f1(), 3, "function setfenv")
-    is(f2(), 3)
+    equals(f1(), 3, "function setfenv")
+    equals(f2(), 3)
     setfenv(f1, {a = 10})
-    is(f1(), 10)
-    is(f2(), 3)
+    equals(f1(), 10)
+    equals(f2(), 3)
     setfenv(1, save) -- restore
 
-    is(setfenv(0, _G), nil, "function setfenv(0)")
+    equals(setfenv(0, _G), nil, "function setfenv(0)")
 
-    error_like(function () setfenv(-3, {}) end,
-               "^[^:]+:%d+: bad argument #1 to 'setfenv' %(.-level.-%)",
-               "function setfenv (negative)")
+    error_matches(function () setfenv(-3, {}) end,
+            "^[^:]+:%d+: bad argument #1 to 'setfenv' %(.-level.-%)",
+            "function setfenv (negative)")
 
-    error_like(function () setfenv(12, {}) end,
-               "^[^:]+:%d+: bad argument #1 to 'setfenv' %(invalid level%)",
-               "function setfenv (too depth)")
+    error_matches(function () setfenv(12, {}) end,
+            "^[^:]+:%d+: bad argument #1 to 'setfenv' %(invalid level%)",
+            "function setfenv (too depth)")
 
     t = {}
-    error_like(function () setfenv(t, {}) end,
-               "^[^:]+:%d+: bad argument #1 to 'setfenv' %(number expected, got table%)",
-               "function setfenv (bad arg)")
+    error_matches(function () setfenv(t, {}) end,
+            "^[^:]+:%d+: bad argument #1 to 'setfenv' %(number expected, got table%)",
+            "function setfenv (bad arg)")
 
-    error_like(function () setfenv(print, {}) end,
-               "^[^:]+:%d+: 'setfenv' cannot change environment of given object",
-               "function setfenv (forbidden)")
+    error_matches(function () setfenv(print, {}) end,
+            "^[^:]+:%d+: 'setfenv' cannot change environment of given object",
+            "function setfenv (forbidden)")
 else
-    is(setfenv, nil, "no setfenv")
+    is_nil(setfenv, "no setfenv")
 end
 
 do -- setmetatable
     local mt = {}
     local t = {}
-    is(t, setmetatable(t, mt), "setmetatable")
-    is(getmetatable(t), mt)
-    is(t, setmetatable(t, nil))
-    is(getmetatable(t), nil)
+    equals(t, setmetatable(t, mt), "setmetatable")
+    equals(getmetatable(t), mt)
+    equals(t, setmetatable(t, nil))
+    equals(getmetatable(t), nil)
 
-    error_like(function () setmetatable(t, true) end,
-               "^[^:]+:%d+: bad argument #2 to 'setmetatable' %(nil or table expected",
-               "function setmetatable (bad arg)")
-    error_like(function () setmetatable(true, mt) end,
-               "^[^:]+:%d+: bad argument #1 to 'setmetatable' %(table expected, got boolean%)",
-               "function setmetatable (bad arg)")
+    error_matches(function () setmetatable(t, true) end,
+            "^[^:]+:%d+: bad argument #2 to 'setmetatable' %(nil or table expected",
+            "function setmetatable (bad arg)")
+    error_matches(function () setmetatable(true, mt) end,
+            "^[^:]+:%d+: bad argument #1 to 'setmetatable' %(table expected, got boolean%)",
+            "function setmetatable (bad arg)")
 end
 
 do -- type
-    is(type("Hello world"), 'string', "function type")
-    is(type(10.4*3), 'number')
-    is(type(print), 'function')
-    is(type(type), 'function')
-    is(type(true), 'boolean')
-    is(type(nil), 'nil')
-    is(type(io.stdin), 'userdata')
-    is(type(type(X)), 'string')
+    equals(type("Hello world"), 'string', "function type")
+    equals(type(10.4*3), 'number')
+    equals(type(print), 'function')
+    equals(type(type), 'function')
+    equals(type(true), 'boolean')
+    equals(type(nil), 'nil')
+    equals(type(io.stdin), 'userdata')
+    equals(type(type(X)), 'string')
 
     local a = nil
-    is(type(a), 'nil', "function type")
+    equals(type(a), 'nil', "function type")
     a = 10
-    is(type(a), 'number')
+    equals(type(a), 'number')
     a = "a string!!"
-    is(type(a), 'string')
+    equals(type(a), 'string')
     a = print
-    is(type(a), 'function')
-    is(type(function () end), 'function')
+    equals(type(a), 'function')
+    equals(type(function () end), 'function')
 
-    error_like(function () type() end,
-               "^[^:]+:%d+: bad argument #1 to 'type' %(value expected%)",
-               "function type (no arg)")
+    error_matches(function () type() end,
+            "^[^:]+:%d+: bad argument #1 to 'type' %(value expected%)",
+            "function type (no arg)")
 end
 
 do -- tonumber
-    is(tonumber('text12'), nil, "function tonumber")
-    is(tonumber('12text'), nil)
-    is(tonumber(3.14), 3.14)
-    is(tonumber('3.14'), 3.14)
-    is(tonumber('  3.14  '), 3.14)
-    is(tonumber(tostring(111), 2), 7)
-    is(tonumber('111', 2), 7)
-    is(tonumber('  111  ', 2), 7)
+    equals(tonumber('text12'), nil, "function tonumber")
+    equals(tonumber('12text'), nil)
+    equals(tonumber(3.14), 3.14)
+    equals(tonumber('3.14'), 3.14)
+    equals(tonumber('  3.14  '), 3.14)
+    equals(tonumber(tostring(111), 2), 7)
+    equals(tonumber('111', 2), 7)
+    equals(tonumber('  111  ', 2), 7)
     local a = {}
-    is(tonumber(a), nil)
+    equals(tonumber(a), nil)
 
-    error_like(function () tonumber() end,
-               "^[^:]+:%d+: bad argument #1 to 'tonumber' %(value expected%)",
-               "function tonumber (no arg)")
+    error_matches(function () tonumber() end,
+            "^[^:]+:%d+: bad argument #1 to 'tonumber' %(value expected%)",
+            "function tonumber (no arg)")
 
-    error_like(function () tonumber('111', 200) end,
-               "^[^:]+:%d+: bad argument #2 to 'tonumber' %(base out of range%)",
-               "function tonumber (bad base)")
+    error_matches(function () tonumber('111', 200) end,
+            "^[^:]+:%d+: bad argument #2 to 'tonumber' %(base out of range%)",
+            "function tonumber (bad base)")
 end
 
 do -- tostring
-    is(tostring('text'), 'text', "function tostring")
-    is(tostring(3.14), '3.14')
-    is(tostring(nil), 'nil')
-    is(tostring(true), 'true')
-    is(tostring(false), 'false')
-    like(tostring({}), '^table: 0?[Xx]?%x+$')
-    like(tostring(print), '^function: 0?[Xx]?[builtin]*#?%x+$')
+    equals(tostring('text'), 'text', "function tostring")
+    equals(tostring(3.14), '3.14')
+    equals(tostring(nil), 'nil')
+    equals(tostring(true), 'true')
+    equals(tostring(false), 'false')
+    matches(tostring({}), '^table: 0?[Xx]?%x+$')
+    matches(tostring(print), '^function: 0?[Xx]?[builtin]*#?%x+$')
 
-    error_like(function () tostring() end,
-               "^[^:]+:%d+: bad argument #1 to 'tostring' %(value expected%)",
-               "function tostring (no arg)")
+    error_matches(function () tostring() end,
+            "^[^:]+:%d+: bad argument #1 to 'tostring' %(value expected%)",
+            "function tostring (no arg)")
 end
 
 -- unpack
 if has_unpack then
-    eq_array({unpack({})}, {}, "function unpack")
-    eq_array({unpack({'a'})}, {'a'})
-    eq_array({unpack({'a','b','c'})}, {'a','b','c'})
-    eq_array({(unpack({'a','b','c'}))}, {'a'})
-    eq_array({unpack({'a','b','c','d','e'},2,4)}, {'b','c','d'})
-    eq_array({unpack({'a','b','c'},2,4)}, {'b','c'})
+    array_equals({unpack({})}, {}, "function unpack")
+    array_equals({unpack({'a'})}, {'a'})
+    array_equals({unpack({'a','b','c'})}, {'a','b','c'})
+    array_equals({(unpack({'a','b','c'}))}, {'a'})
+    array_equals({unpack({'a','b','c','d','e'},2,4)}, {'b','c','d'})
+    array_equals({unpack({'a','b','c'},2,4)}, {'b','c'})
 elseif has_alias_unpack then
-    is(unpack, table.unpack, "alias unpack")
+    equals(unpack, table.unpack, "alias unpack")
 else
-    is(unpack, nil, "no unpack")
+    is_nil(unpack, "no unpack")
 end
 
 -- warn
 if has_warn then
-    is(warn('foo'), nil, "function warn")
+    equals(warn('foo'), nil, "function warn")
 
     local r, f = pcall(io.popen, lua .. [[ -W -e "warn'foo'" 2>&1]])
     if r then
-        is(f:read'*l', 'Lua warning: foo', "warn called with popen")
-        is(f:read'*l', nil)
-        is(f:close(), true)
+        equals(f:read'*l', 'Lua warning: foo', "warn called with popen")
+        equals(f:read'*l', nil)
+        equals(f:close(), true)
     else
         diag("io.popen not supported")
     end
 
     r, f = pcall(io.popen, lua .. [[ -e "warn'@on'; warn'foo'" 2>&1]])
     if r then
-        is(f:read'*l', 'Lua warning: foo', "warn called with popen")
-        is(f:read'*l', nil)
-        is(f:close(), true)
+        equals(f:read'*l', 'Lua warning: foo', "warn called with popen")
+        equals(f:read'*l', nil)
+        equals(f:close(), true)
     else
         diag("io.popen not supported")
     end
 
     r, f = pcall(io.popen, lua .. [[ -e "warn'@on'; warn('foo', 'bar')" 2>&1]])
     if r then
-        is(f:read'*l', 'Lua warning: foobar', "warn called with popen")
-        is(f:read'*l', nil)
-        is(f:close(), true)
+        equals(f:read'*l', 'Lua warning: foobar', "warn called with popen")
+        equals(f:read'*l', nil)
+        equals(f:close(), true)
     else
         diag("io.popen not supported")
     end
 
-    error_like(function () warn('foo', warn) end,
-               "^[^:]+:%d+: bad argument #2 to 'warn' %(string expected, got function%)",
-               "function warn (no arg)")
+    error_matches(function () warn('foo', warn) end,
+            "^[^:]+:%d+: bad argument #2 to 'warn' %(string expected, got function%)",
+            "function warn (no arg)")
 
-    error_like(function () warn() end,
-               "^[^:]+:%d+: bad argument #1 to 'warn' %(string expected, got no value%)",
-               "function warn (no arg)")
+    error_matches(function () warn() end,
+            "^[^:]+:%d+: bad argument #1 to 'warn' %(string expected, got no value%)",
+            "function warn (no arg)")
 else
-    is(warn, nil, "no warn")
+    is_nil(warn, "no warn")
 end
 
 do -- xpcall
@@ -804,41 +804,41 @@ do -- xpcall
     end
 
     local status, result = xpcall(function () return assert(1) end, err)
-    is(status, true, "function xpcall")
-    is(result, 1)
+    is_true(status, "function xpcall")
+    equals(result, 1)
     status, result = xpcall(function () return assert(false, 'catched') end, err)
-    is(status, false)
+    is_false(status)
     if jit then
-        is(result, 'catched')
+        equals(result, 'catched')
     else
-        like(result, ':%d+: catched')
+        matches(result, ':%d+: catched')
     end
     status, result = xpcall(function () return assert(false, 'catched') end, backtrace)
-    is(status, false)
-    is(result, 'not a back trace')
+    is_false(status)
+    equals(result, 'not a back trace')
 
     if has_xpcall52 then
         status, result = xpcall(assert, err, 1)
-        is(status, true, "function xpcall with args")
-        is(result, 1)
+        is_true(status, "function xpcall with args")
+        equals(result, 1)
         status, result = xpcall(assert, err, false, 'catched')
-        is(status, false)
-        is(result, 'catched')
+        is_false(status)
+        equals(result, 'catched')
         status, result = xpcall(assert, backtrace, false, 'catched')
-        is(status, false)
-        is(result, 'not a back trace')
+        is_false(status)
+        equals(result, 'not a back trace')
     end
 
-    error_like(function () xpcall(assert) end,
-               "bad argument #2 to 'xpcall' %(.-",
-               "function xpcall")
+    error_matches(function () xpcall(assert) end,
+            "bad argument #2 to 'xpcall' %(.-",
+            "function xpcall")
 
     if has_xpcall53 then
-        error_like(function () xpcall(assert, 1) end,
-                   "bad argument #2 to 'xpcall' %(function expected, got number%)",
-                  "function xpcall")
+        error_matches(function () xpcall(assert, 1) end,
+                "bad argument #2 to 'xpcall' %(function expected, got number%)",
+                "function xpcall")
     else
-        is(xpcall(assert, nil), false, "function xpcall")
+        is_false(xpcall(assert, nil), "function xpcall")
     end
 end
 
diff --git a/test/lua-Harness-tests/303-package.t b/test/lua-Harness-tests/303-package.t
index 7e5216d8..1a1d7e05 100755
--- a/test/lua-Harness-tests/303-package.t
+++ b/test/lua-Harness-tests/303-package.t
@@ -2,7 +2,7 @@
 --
 -- lua-Harness : <https://fperrad.frama.io/lua-Harness/>
 --
--- Copyright (C) 2009-2020, Perrad Francois
+-- Copyright (C) 2009-2021, Perrad Francois
 --
 -- This code is licensed under the terms of the MIT/X11 license,
 -- like Lua itself.
@@ -45,45 +45,45 @@ local has_require54 = _VERSION >= 'Lua 5.4'
 plan'no_plan'
 
 
-type_ok(package.config, 'string')
+is_string(package.config)
 
-type_ok(package.cpath, 'string')
+is_string(package.cpath)
 
-type_ok(package.path, 'string')
+is_string(package.path)
 
 if has_loaders then
-    type_ok(package.loaders, 'table', "table package.loaders")
+    is_table(package.loaders, "table package.loaders")
 elseif has_alias_loaders then
-    is(package.loaders, package.searchers, "alias package.loaders")
+    equals(package.loaders, package.searchers, "alias package.loaders")
 else
-    is(package.loaders, nil, "no package.loaders")
+    is_nil(package.loaders, "no package.loaders")
 end
 
 if has_searchers then
-    type_ok(package.searchers, 'table', "table package.searchers")
+    is_table(package.searchers, "table package.searchers")
 elseif has_alias_searchers then
-    is(package.searchers, package.loaders, "alias package.searchers")
+    equals(package.searchers, package.loaders, "alias package.searchers")
 else
-    is(package.searchers, nil, "no package.searchers")
+    is_nil(package.searchers, "no package.searchers")
 end
 
 do -- loaded
-    ok(package.loaded._G, "table package.loaded")
-    ok(package.loaded.coroutine)
-    ok(package.loaded.io)
-    ok(package.loaded.math)
-    ok(package.loaded.os)
-    ok(package.loaded.package)
-    ok(package.loaded.string)
-    ok(package.loaded.table)
+    truthy(package.loaded._G, "table package.loaded")
+    truthy(package.loaded.coroutine)
+    truthy(package.loaded.io)
+    truthy(package.loaded.math)
+    truthy(package.loaded.os)
+    truthy(package.loaded.package)
+    truthy(package.loaded.string)
+    truthy(package.loaded.table)
 
     local m = require'os'
-    is(m, package.loaded['os'])
+    equals(m, package.loaded['os'])
 end
 
 do -- preload
-    type_ok(package.preload, 'table', "table package.preload")
-    is(# package.preload, 0)
+    is_table(package.preload, "table package.preload")
+    equals(# package.preload, 0)
 
     local foo = {}
     foo.bar = 1234
@@ -93,35 +93,35 @@ do -- preload
     package.preload.foo = foo_loader
     local m = require 'foo'
     assert(m == foo)
-    is(m.bar, 1234, "function require & package.preload")
+    equals(m.bar, 1234, "function require & package.preload")
 end
 
 do -- loadlib
     local path_lpeg = package.searchpath and package.searchpath('lpeg', package.cpath)
 
     local f, msg = package.loadlib('libbar', 'baz')
-    is(f, nil, "loadlib")
-    type_ok(msg, 'string')
+    is_nil(f, "loadlib")
+    is_string(msg)
 
     if path_lpeg then
         f, msg = package.loadlib(path_lpeg, 'baz')
-        is(f, nil, "loadlib")
-        like(msg, 'undefined symbol')
+        is_nil(f, "loadlib")
+        matches(msg, 'undefined symbol')
 
         f = package.loadlib(path_lpeg, 'luaopen_lpeg')
-        type_ok(f, 'function', "loadlib ok")
+        is_function(f, "loadlib ok")
     else
         skip("no lpeg path")
     end
 
     if has_loadlib52 then
         f, msg = package.loadlib('libbar', '*')
-        is(f, nil, "loadlib '*'")
-        type_ok(msg, 'string')
+        is_nil(f, "loadlib '*'")
+        is_string(msg)
 
         if path_lpeg then
             f = package.loadlib(path_lpeg, '*')
-            is(f, true, "loadlib '*'")
+            is_true(f, "loadlib '*'")
         else
             skip("no lpeg path")
         end
@@ -131,11 +131,12 @@ end
 -- searchpath
 if has_searcherpath then
     local p = package.searchpath('tap', package.path)
-    type_ok(p, 'string', "searchpath")
+    is_string(p, "searchpath")
+    matches(p, "tap.lua$", "searchpath")
     p = package.searchpath('tap', 'bad path')
-    is(p, nil)
+    is_nil(p)
 else
-    is(package.searchpath, nil, "no package.searchpath")
+    is_nil(package.searchpath, "no package.searchpath")
 end
 
 do -- require
@@ -175,31 +176,31 @@ return complex
     f:close()
     if has_require54 then
         local m1, path1 = require 'complex'
-        is(m1, complex, "function require")
-        is(path1, './complex.lua')
+        equals(m1, complex, "function require")
+        equals(path1, './complex.lua')
         local m2, path2 = require 'complex'
-        is(m1, m2)
-        is(path2, nil)
+        equals(m1, m2)
+        equals(path2, nil)
     else
         local m1 = require 'complex'
-        is(m1, complex, "function require")
+        equals(m1, complex, "function require")
         local m2 = require 'complex'
-        is(m1, m2)
+        equals(m1, m2)
     end
-    is(complex.i.r, 0)
-    is(complex.i.i, 1)
+    equals(complex.i.r, 0)
+    equals(complex.i.i, 1)
     os.remove('complex.lua') -- clean up
 
-    error_like(function () require('no_module') end,
-               "^[^:]+:%d+: module 'no_module' not found:",
-               "function require (no module)")
+    error_matches(function () require('no_module') end,
+            "^[^:]+:%d+: module 'no_module' not found:",
+            "function require (no module)")
 
     f = io.open('syntax.lua', 'w')
     f:write [[?syntax error?]]
     f:close()
-    error_like(function () require('syntax') end,
-               "^error loading module 'syntax' from file '%.[/\\]syntax%.lua':",
-               "function require (syntax error)")
+    error_matches(function () require('syntax') end,
+            "^error loading module 'syntax' from file '%.[/\\]syntax%.lua':",
+            "function require (syntax error)")
     os.remove('syntax.lua') -- clean up
 
     f = io.open('bar.lua', 'w')
@@ -210,7 +211,7 @@ return complex
     f:close()
     a = nil
     require 'bar'
-    is(a, 'bar', "function require (arg)")
+    equals(a, 'bar', "function require (arg)")
     os.remove('bar.lua') -- clean up
 
     f = io.open('cplx.lua', 'w')
@@ -253,8 +254,8 @@ return cplx
 ]]
     f:close()
     require 'cplx'
-    is(cplx.i.r, 0, "function require & module")
-    is(cplx.i.i, 1)
+    equals(cplx.i.r, 0, "function require & module")
+    equals(cplx.i.i, 1)
     os.remove('cplx.lua') -- clean up
 end
 
@@ -263,21 +264,21 @@ local done_testing = done_testing
 if has_module then
     m = {}
     package.seeall(m)
-    m.pass("function package.seeall")
+    m.passes("function package.seeall")
 
-    is(mod, nil, "function module & seeall")
+    is_nil(mod, "function module & seeall")
     module('mod', package.seeall)
-    type_ok(mod, 'table')
-    is(mod, package.loaded.mod)
+    is_table(mod)
+    equals(mod, package.loaded.mod)
 
-    is(modz, nil, "function module")
+    is_nil(modz, "function module")
     local _G = _G
     module('modz')
-    _G.type_ok(_G.modz, 'table')
-    _G.is(_G.modz, _G.package.loaded.modz)
+    _G.is_table(_G.modz)
+    _G.equals(_G.modz, _G.package.loaded.modz)
 else
-    is(package.seeall, nil, "package.seeall (removed)")
-    is(module, nil, "module (removed)")
+    is_nil(package.seeall, "package.seeall (removed)")
+    is_nil(module, "module (removed)")
 end
 
 done_testing()
diff --git a/test/lua-Harness-tests/304-string.t b/test/lua-Harness-tests/304-string.t
index 991600a7..7011a88e 100755
--- a/test/lua-Harness-tests/304-string.t
+++ b/test/lua-Harness-tests/304-string.t
@@ -2,7 +2,7 @@
 --
 -- lua-Harness : <https://fperrad.frama.io/lua-Harness/>
 --
--- Copyright (C) 2009-2020, Perrad Francois
+-- Copyright (C) 2009-2021, Perrad Francois
 --
 -- This code is licensed under the terms of the MIT/X11 license,
 -- like Lua itself.
@@ -49,79 +49,79 @@ plan'no_plan'
 
 do -- metatable
     local mt = getmetatable('ABC')
-    type_ok(mt, 'table', "metatable")
-    type_ok(mt.__index, 'table')
+    is_table(mt, "metatable")
+    is_table(mt.__index)
 
     if not profile.nocvts2n and _VERSION >= 'Lua 5.4' then
-        type_ok(mt.__add, 'function')
-        type_ok(mt.__div, 'function')
-        type_ok(mt.__idiv, 'function')
-        type_ok(mt.__mul, 'function')
-        type_ok(mt.__mod, 'function')
-        type_ok(mt.__pow, 'function')
-        type_ok(mt.__sub, 'function')
-        type_ok(mt.__unm, 'function')
+        is_function(mt.__add)
+        is_function(mt.__div)
+        is_function(mt.__idiv)
+        is_function(mt.__mul)
+        is_function(mt.__mod)
+        is_function(mt.__pow)
+        is_function(mt.__sub)
+        is_function(mt.__unm)
     else
-        is(mt.__add, nil)
-        is(mt.__div, nil)
-        is(mt.__idiv, nil)
-        is(mt.__mul, nil)
-        is(mt.__mod, nil)
-        is(mt.__pow, nil)
-        is(mt.__sub, nil)
-        is(mt.__unm, nil)
+        is_nil(mt.__add)
+        is_nil(mt.__div)
+        is_nil(mt.__idiv)
+        is_nil(mt.__mul)
+        is_nil(mt.__mod)
+        is_nil(mt.__pow)
+        is_nil(mt.__sub)
+        is_nil(mt.__unm)
     end
 
-    is(mt.__index.byte, string.byte)
-    is(mt.__index.char, string.char)
-    is(mt.__index.dump, string.dump)
-    is(mt.__index.find, string.find)
-    is(mt.__index.format, string.format)
-    is(mt.__index.gmatch, string.gmatch)
-    is(mt.__index.gsub, string.gsub)
-    is(mt.__index.len, string.len)
-    is(mt.__index.lower, string.lower)
-    is(mt.__index.match, string.match)
-    is(mt.__index.rep, string.rep)
-    is(mt.__index.reverse, string.reverse)
-    is(mt.__index.sub, string.sub)
-    is(mt.__index.upper, string.upper)
+    equals(mt.__index.byte, string.byte)
+    equals(mt.__index.char, string.char)
+    equals(mt.__index.dump, string.dump)
+    equals(mt.__index.find, string.find)
+    equals(mt.__index.format, string.format)
+    equals(mt.__index.gmatch, string.gmatch)
+    equals(mt.__index.gsub, string.gsub)
+    equals(mt.__index.len, string.len)
+    equals(mt.__index.lower, string.lower)
+    equals(mt.__index.match, string.match)
+    equals(mt.__index.rep, string.rep)
+    equals(mt.__index.reverse, string.reverse)
+    equals(mt.__index.sub, string.sub)
+    equals(mt.__index.upper, string.upper)
 
     if has_pack then
-        is(mt.__index.pack, string.pack)
-        is(mt.__index.packsize, string.packsize)
-        is(mt.__index.unpack, string.unpack)
+        equals(mt.__index.pack, string.pack)
+        equals(mt.__index.packsize, string.packsize)
+        equals(mt.__index.unpack, string.unpack)
     else
-        is(mt.__index.pack, nil)
-        is(mt.__index.packsize, nil)
-        is(mt.__index.unpack, nil)
+        is_nil(mt.__index.pack)
+        is_nil(mt.__index.packsize)
+        is_nil(mt.__index.unpack)
     end
 end
 
 do -- byte
-    is(string.byte('ABC'), 65, "function byte")
-    is(string.byte('ABC', 2), 66)
-    is(string.byte('ABC', -1), 67)
-    is(string.byte('ABC', 4), nil)
-    is(string.byte('ABC', 0), nil)
-    eq_array({string.byte('ABC', 1, 3)}, {65, 66, 67})
-    eq_array({string.byte('ABC', 1, 4)}, {65, 66, 67})
+    equals(string.byte('ABC'), 65, "function byte")
+    equals(string.byte('ABC', 2), 66)
+    equals(string.byte('ABC', -1), 67)
+    equals(string.byte('ABC', 4), nil)
+    equals(string.byte('ABC', 0), nil)
+    array_equals({string.byte('ABC', 1, 3)}, {65, 66, 67})
+    array_equals({string.byte('ABC', 1, 4)}, {65, 66, 67})
 
     local s = "ABC"
-    is(s:byte(2), 66, "method s:byte")
+    equals(s:byte(2), 66, "method s:byte")
 end
 
 do -- char
-    is(string.char(65, 66, 67), 'ABC', "function char")
-    is(string.char(), '')
+    equals(string.char(65, 66, 67), 'ABC', "function char")
+    equals(string.char(), '')
 
-    error_like(function () string.char(0, 'bad') end,
-               "^[^:]+:%d+: bad argument #2 to 'char' %(number expected, got string%)",
-               "function char (bad arg)")
+    error_matches(function () string.char(0, 'bad') end,
+            "^[^:]+:%d+: bad argument #2 to 'char' %(number expected, got string%)",
+            "function char (bad arg)")
 
-    error_like(function () string.char(0, 9999) end,
-               "^[^:]+:%d+: bad argument #2 to 'char' %(.-value.-%)",
-               "function char (invalid)")
+    error_matches(function () string.char(0, 9999) end,
+            "^[^:]+:%d+: bad argument #2 to 'char' %(.-value.-%)",
+            "function char (invalid)")
 end
 
 do -- dump
@@ -139,176 +139,176 @@ do -- dump
     end
 
     local d = string.dump(add)
-    type_ok(d, 'string', "function dump")
+    is_string(d, "function dump")
     local f = loadstring(d)
-    type_ok(f, 'function')
-    is(f(1, 2), 3)
+    is_function(f)
+    equals(f(1, 2), 3)
 
     if signature then
         local sig = d:sub(1, #signature)
-        is(sig, signature)
+        equals(sig, signature)
     end
 
     if has_dump53 then
         local d2 = string.dump(add, true)
-        type_ok(d2, 'string', "function dump with strip")
+        is_string(d2, "function dump with strip")
         f = loadstring(d2)
-        type_ok(f, 'function')
-        is(f(1, 2), 3)
-        isnt(d2:len(), d:len())
+        is_function(f)
+        equals(f(1, 2), 3)
+        not_equals(d2:len(), d:len())
 
         if signature then
             local sig = d2:sub(1, #signature)
-            is(sig, signature)
+            equals(sig, signature)
         end
     end
 
-    error_like(function () string.dump(print) end,
-               "^[^:]+:%d+: unable to dump given function",
-               "function dump (C function)")
+    error_matches(function () string.dump(print) end,
+            "^[^:]+:%d+: unable to dump given function",
+            "function dump (C function)")
 end
 
 do -- find
     local s = "hello world"
-    eq_array({string.find(s, "hello")}, {1, 5}, "function find (mode plain)")
-    eq_array({string.find(s, "hello", 1, true)}, {1, 5})
-    eq_array({string.find(s, "hello", 1)}, {1, 5})
-    is(string.sub(s, 1, 5), "hello")
-    eq_array({string.find(s, "world")}, {7, 11})
-    eq_array({string.find(s, "l")}, {3, 3})
-    is(string.find(s, "lll"), nil)
-    is(string.find(s, "hello", 2, true), nil)
-    eq_array({string.find(s, "world", 2, true)}, {7, 11})
-    is(string.find(s, "hello", 20), nil)
+    array_equals({string.find(s, "hello")}, {1, 5}, "function find (mode plain)")
+    array_equals({string.find(s, "hello", 1, true)}, {1, 5})
+    array_equals({string.find(s, "hello", 1)}, {1, 5})
+    equals(string.sub(s, 1, 5), "hello")
+    array_equals({string.find(s, "world")}, {7, 11})
+    array_equals({string.find(s, "l")}, {3, 3})
+    equals(string.find(s, "lll"), nil)
+    equals(string.find(s, "hello", 2, true), nil)
+    array_equals({string.find(s, "world", 2, true)}, {7, 11})
+    equals(string.find(s, "hello", 20), nil)
 
     s = "hello world"
-    eq_array({string.find(s, "^h.ll.")}, {1, 5}, "function find (with regex & captures)")
-    eq_array({string.find(s, "w.rld", 2)}, {7, 11})
-    is(string.find(s, "W.rld"), nil)
-    eq_array({string.find(s, "^(h.ll.)")}, {1, 5, 'hello'})
-    eq_array({string.find(s, "^(h.)l(l.)")}, {1, 5, 'he', 'lo'})
+    array_equals({string.find(s, "^h.ll.")}, {1, 5}, "function find (with regex & captures)")
+    array_equals({string.find(s, "w.rld", 2)}, {7, 11})
+    equals(string.find(s, "W.rld"), nil)
+    array_equals({string.find(s, "^(h.ll.)")}, {1, 5, 'hello'})
+    array_equals({string.find(s, "^(h.)l(l.)")}, {1, 5, 'he', 'lo'})
     s = "Deadline is 30/05/1999, firm"
     local date = "%d%d/%d%d/%d%d%d%d"
-    is(string.sub(s, string.find(s, date)), "30/05/1999")
+    equals(string.sub(s, string.find(s, date)), "30/05/1999")
     date = "%f[%S]%d%d/%d%d/%d%d%d%d"
-    is(string.sub(s, string.find(s, date)), "30/05/1999")
+    equals(string.sub(s, string.find(s, date)), "30/05/1999")
 
-    error_like(function () string.find(s, '%f') end,
-               "^[^:]+:%d+: missing '%[' after '%%f' in pattern",
-               "function find (invalid frontier)")
+    error_matches(function () string.find(s, '%f') end,
+            "^[^:]+:%d+: missing '%[' after '%%f' in pattern",
+            "function find (invalid frontier)")
 end
 
 do -- format
-    is(string.format("pi = %.4f", math.pi), 'pi = 3.1416', "function format")
+    equals(string.format("pi = %.4f", math.pi), 'pi = 3.1416', "function format")
     local d = 5; local m = 11; local y = 1990
-    is(string.format("%02d/%02d/%04d", d, m, y), "05/11/1990")
-    is(string.format("%X %x", 126, 126), "7E 7e")
+    equals(string.format("%02d/%02d/%04d", d, m, y), "05/11/1990")
+    equals(string.format("%X %x", 126, 126), "7E 7e")
     local tag, title = "h1", "a title"
-    is(string.format("<%s>%s</%s>", tag, title, tag), "<h1>a title</h1>")
+    equals(string.format("<%s>%s</%s>", tag, title, tag), "<h1>a title</h1>")
 
-    is(string.format('%q', 'a string with "quotes" and \n new line'), [["a string with \"quotes\" and \
+    equals(string.format('%q', 'a string with "quotes" and \n new line'), [["a string with \"quotes\" and \
  new line"]], "function format %q")
 
     if has_format_q52 then
-        is(string.format('%q', 'a string with \0 and \r.'), [["a string with \0 and \13."]], "function format %q")
-        is(string.format('%q', 'a string with \b and \b2'), [["a string with \8 and \0082"]], "function format %q")
+        equals(string.format('%q', 'a string with \0 and \r.'), [["a string with \0 and \13."]], "function format %q")
+        equals(string.format('%q', 'a string with \b and \b2'), [["a string with \8 and \0082"]], "function format %q")
     else
-        is(string.format('%q', 'a string with \0 and \r.'), [["a string with \000 and \r."]], "function format %q")
-        is(string.format('%q', 'a string with \b and \b2'), '"a string with \b and \b2"', "function format %q")
+        equals(string.format('%q', 'a string with \0 and \r.'), [["a string with \000 and \r."]], "function format %q")
+        equals(string.format('%q', 'a string with \b and \b2'), '"a string with \b and \b2"', "function format %q")
     end
 
     if has_format_q53 then
-        is(string.format('%q', 1.5), '0x1.8p+0', "function format %q")
-        is(string.format('%q', 7), '7', "function format %q")
+        equals(string.format('%q', 1.5), '0x1.8p+0', "function format %q")
+        equals(string.format('%q', 7), '7', "function format %q")
     else
-        is(string.format('%q', 1.5), [["1.5"]], "function format %q")
-        is(string.format('%q', 7), [["7"]], "function format %q")
+        equals(string.format('%q', 1.5), [["1.5"]], "function format %q")
+        equals(string.format('%q', 7), [["7"]], "function format %q")
     end
 
     if has_format_q53 then
-        is(string.format('%q', nil), 'nil', "function format ('%q', nil)")
+        equals(string.format('%q', nil), 'nil', "function format ('%q', nil)")
     elseif luajit21 then
-        is(string.format('%q', nil), [["nil"]], "function format ('%q', nil)")
+        equals(string.format('%q', nil), [["nil"]], "function format ('%q', nil)")
     else
-        error_like(function () string.format("%q", nil) end,
-                   "^[^:]+:%d+: bad argument #2 to 'format' %(",
-                   "function format ('%q', nil)")
+        error_matches(function () string.format("%q", nil) end,
+                "^[^:]+:%d+: bad argument #2 to 'format' %(",
+                "function format ('%q', nil)")
     end
 
     if has_format_q54 then
-        is(string.format('%q', 0/0), '(0/0)', "function format ('%q', NaN)")
-        is(string.format('%q', 1/0), '1e9999', "function format ('%q', +Inf)")
-        is(string.format('%q', -1/0), '-1e9999', "function format ('%q', -Inf)")
+        equals(string.format('%q', 0/0), '(0/0)', "function format ('%q', NaN)")
+        equals(string.format('%q', 1/0), '1e9999', "function format ('%q', +Inf)")
+        equals(string.format('%q', -1/0), '-1e9999', "function format ('%q', -Inf)")
 
-        error_like(function () string.format("%-q", 0) end,
-                   "^[^:]+:%d+: specifier '%%q' cannot have modifiers",
-                   "function format '%-q'")
+        error_matches(function () string.format("%-q", 0) end,
+                "^[^:]+:%d+: specifier '%%q' cannot have modifiers",
+                "function format '%-q'")
     end
 
     if luajit21 then
-        like(string.format('%q', {}), [[^"table: ]], "function format ('%q', {})")
+        matches(string.format('%q', {}), [[^"table: ]], "function format ('%q', {})")
     else
-        error_like(function () string.format("%q", {}) end,
-                   "^[^:]+:%d+: bad argument #2 to 'format' %(",
-                   "function format ('%q', {})")
+        error_matches(function () string.format("%q", {}) end,
+                "^[^:]+:%d+: bad argument #2 to 'format' %(",
+                "function format ('%q', {})")
     end
 
     if has_format_a then
-        is(string.format('%a', 1.5), '0x1.8p+0', "function format %a")
+        equals(string.format('%a', 1.5), '0x1.8p+0', "function format %a")
     end
 
     if has_format_p then
-        is(string.format('table: %p', string), tostring(string), "function format %p")
+        equals(string.format('table: %p', string), tostring(string), "function format %p")
     end
 
-    is(string.format("%5s", 'foo'), '  foo', "function format (%5s)")
+    equals(string.format("%5s", 'foo'), '  foo', "function format (%5s)")
 
     if _VERSION >= 'Lua 5.3' then
-        error_like(function () string.format("%5s", "foo\0bar") end,
-                   "^[^:]+:%d+: bad argument #2 to 'format' %(string contains zeros%)",
-                   "function format format (%5s with \\0)")
+        error_matches(function () string.format("%5s", "foo\0bar") end,
+                "^[^:]+:%d+: bad argument #2 to 'format' %(string contains zeros%)",
+                "function format format (%5s with \\0)")
     end
 
-    is(string.format("%s %s", 1, 2, 3), '1 2', "function format (too many arg)")
+    equals(string.format("%s %s", 1, 2, 3), '1 2', "function format (too many arg)")
 
-    is(string.format("%% %c %%", 65), '% A %', "function format (%%)")
+    equals(string.format("%% %c %%", 65), '% A %', "function format (%%)")
 
     local r = string.rep("ab", 100)
-    is(string.format("%s %d", r, r:len()), r .. " 200")
+    equals(string.format("%s %d", r, r:len()), r .. " 200")
 
-    error_like(function () string.format("%s %s", 1) end,
-               "^[^:]+:%d+: bad argument #3 to 'format' %(.-no value%)",
-               "function format (too few arg)")
+    error_matches(function () string.format("%s %s", 1) end,
+            "^[^:]+:%d+: bad argument #3 to 'format' %(.-no value%)",
+            "function format (too few arg)")
 
-    error_like(function () string.format('%d', 'toto') end,
-               "^[^:]+:%d+: bad argument #2 to 'format' %(number expected, got string%)",
-               "function format (bad arg)")
+    error_matches(function () string.format('%d', 'toto') end,
+            "^[^:]+:%d+: bad argument #2 to 'format' %(number expected, got string%)",
+            "function format (bad arg)")
 
-    error_like(function () string.format('%k', 'toto') end,
-               "^[^:]+:%d+: invalid .- '%%k' to 'format'",
-               "function format (invalid conversion)")
+    error_matches(function () string.format('%k', 'toto') end,
+            "^[^:]+:%d+: invalid .- '%%k' to 'format'",
+            "function format (invalid conversion)")
 
     if luajit21 then
-        error_like(function () string.format('%111s', 'toto') end,
-                   "^[^:]+:%d+: invalid option '%%111' to 'format'",
-                   "function format (invalid format)")
+        error_matches(function () string.format('%111s', 'toto') end,
+                "^[^:]+:%d+: invalid option '%%111' to 'format'",
+                "function format (invalid format)")
     else
-        error_like(function () string.format('%111s', 'toto') end,
-                   "^[^:]+:%d+: invalid format %(width or precision too long%)",
-                   "function format (invalid format)")
+        error_matches(function () string.format('%111s', 'toto') end,
+                "^[^:]+:%d+: invalid format %(width or precision too long%)",
+                "function format (invalid format)")
 
-        error_like(function () string.format('%------s', 'toto') end,
-                   "^[^:]+:%d+: invalid format %(repeated flags%)",
-                   "function format (invalid format)")
+        error_matches(function () string.format('%------s', 'toto') end,
+                "^[^:]+:%d+: invalid format %(repeated flags%)",
+                "function format (invalid format)")
     end
 
-    error_like(function () string.format('pi = %.123f', math.pi) end,
-               "^[^:]+:%d+: invalid ",
-               "function format (invalid format)")
+    error_matches(function () string.format('pi = %.123f', math.pi) end,
+            "^[^:]+:%d+: invalid ",
+            "function format (invalid format)")
 
-    error_like(function () string.format('% 123s', 'toto') end,
-               "^[^:]+:%d+: invalid ",
-               "function format (invalid format)")
+    error_matches(function () string.format('% 123s', 'toto') end,
+            "^[^:]+:%d+: invalid ",
+            "function format (invalid format)")
 end
 
 do -- gmatch
@@ -317,99 +317,99 @@ do -- gmatch
     for c in string.gmatch(s, '..') do
         table.insert(output, c)
     end
-    eq_array(output, {'he', 'll'}, "function gmatch")
+    array_equals(output, {'he', 'll'}, "function gmatch")
     if has_gmatch54 then
         output = {}
         for c in string.gmatch(s, '..', 2) do
             table.insert(output, c)
         end
-        eq_array(output, {'el', 'lo'})
+        array_equals(output, {'el', 'lo'})
     end
     output = {}
     for c1, c2 in string.gmatch(s, '(.)(.)') do
         table.insert(output, c1)
         table.insert(output, c2)
     end
-    eq_array(output, {'h', 'e', 'l', 'l'})
+    array_equals(output, {'h', 'e', 'l', 'l'})
     s = "hello world from Lua"
     output = {}
     for w in string.gmatch(s, '%a+') do
         table.insert(output, w)
     end
-    eq_array(output, {'hello', 'world', 'from', 'Lua'})
+    array_equals(output, {'hello', 'world', 'from', 'Lua'})
     s = "from=world, to=Lua"
     output = {}
     for k, v in string.gmatch(s, '(%w+)=(%w+)') do
         table.insert(output, k)
         table.insert(output, v)
     end
-    eq_array(output, {'from', 'world', 'to', 'Lua'})
+    array_equals(output, {'from', 'world', 'to', 'Lua'})
 end
 
 do -- gsub
-    is(string.gsub("hello world", "(%w+)", "%1 %1"), "hello hello world world", "function gsub")
-    is(string.gsub("hello world", "%w+", "%0 %0", 1), "hello hello world")
-    is(string.gsub("hello world from Lua", "(%w+)%s*(%w+)", "%2 %1"), "world hello Lua from")
+    equals(string.gsub("hello world", "(%w+)", "%1 %1"), "hello hello world world", "function gsub")
+    equals(string.gsub("hello world", "%w+", "%0 %0", 1), "hello hello world")
+    equals(string.gsub("hello world from Lua", "(%w+)%s*(%w+)", "%2 %1"), "world hello Lua from")
     if _VERSION == 'Lua 5.1' then
         todo("not with 5.1")
     end
-    error_like(function () string.gsub("hello world", "%w+", "%e") end,
-               "^[^:]+:%d+: invalid use of '%%' in replacement string",
-               "function gsub (invalid replacement string)")
-    is(string.gsub("home = $HOME, user = $USER", "%$(%w+)", string.reverse), "home = EMOH, user = RESU")
-    is(string.gsub("4+5 = $return 4+5$", "%$(.-)%$", function (s) return tostring(loadstring(s)()) end), "4+5 = 9")
+    error_matches(function () string.gsub("hello world", "%w+", "%e") end,
+            "^[^:]+:%d+: invalid use of '%%' in replacement string",
+            "function gsub (invalid replacement string)")
+    equals(string.gsub("home = $HOME, user = $USER", "%$(%w+)", string.reverse), "home = EMOH, user = RESU")
+    equals(string.gsub("4+5 = $return 4+5$", "%$(.-)%$", function (s) return tostring(loadstring(s)()) end), "4+5 = 9")
     local t = {name='lua', version='5.1'}
-    is(string.gsub("$name-$version.tar.gz", "%$(%w+)", t), "lua-5.1.tar.gz")
+    equals(string.gsub("$name-$version.tar.gz", "%$(%w+)", t), "lua-5.1.tar.gz")
 
-    is(string.gsub("Lua is cute", 'cute', 'great'), "Lua is great")
-    is(string.gsub("all lii", 'l', 'x'), "axx xii")
-    is(string.gsub("Lua is great", '^Sol', 'Sun'), "Lua is great")
-    is(string.gsub("all lii", 'l', 'x', 1), "axl lii")
-    is(string.gsub("all lii", 'l', 'x', 2), "axx lii")
-    is(select(2, string.gsub("string with 3 spaces", ' ', ' ')), 3)
+    equals(string.gsub("Lua is cute", 'cute', 'great'), "Lua is great")
+    equals(string.gsub("all lii", 'l', 'x'), "axx xii")
+    equals(string.gsub("Lua is great", '^Sol', 'Sun'), "Lua is great")
+    equals(string.gsub("all lii", 'l', 'x', 1), "axl lii")
+    equals(string.gsub("all lii", 'l', 'x', 2), "axx lii")
+    equals(select(2, string.gsub("string with 3 spaces", ' ', ' ')), 3)
 
-    eq_array({string.gsub("hello, up-down!", '%A', '.')}, {"hello..up.down.", 4})
-    eq_array({string.gsub("hello, up-down!", '%A', '%%')}, {"hello%%up%down%", 4})
+    array_equals({string.gsub("hello, up-down!", '%A', '.')}, {"hello..up.down.", 4})
+    array_equals({string.gsub("hello, up-down!", '%A', '%%')}, {"hello%%up%down%", 4})
     local text = "hello world"
     local nvow = select(2, string.gsub(text, '[AEIOUaeiou]', ''))
-    is(nvow, 3)
-    eq_array({string.gsub("one, and two; and three", '%a+', 'word')}, {"word, word word; word word", 5})
+    equals(nvow, 3)
+    array_equals({string.gsub("one, and two; and three", '%a+', 'word')}, {"word, word word; word word", 5})
     local test = "int x; /* x */  int y; /* y */"
-    eq_array({string.gsub(test, "/%*.*%*/", '<COMMENT>')}, {"int x; <COMMENT>", 1})
-    eq_array({string.gsub(test, "/%*.-%*/", '<COMMENT>')}, {"int x; <COMMENT>  int y; <COMMENT>", 2})
+    array_equals({string.gsub(test, "/%*.*%*/", '<COMMENT>')}, {"int x; <COMMENT>", 1})
+    array_equals({string.gsub(test, "/%*.-%*/", '<COMMENT>')}, {"int x; <COMMENT>  int y; <COMMENT>", 2})
     local s = "a (enclosed (in) parentheses) line"
-    eq_array({string.gsub(s, '%b()', '')}, {"a  line", 1})
+    array_equals({string.gsub(s, '%b()', '')}, {"a  line", 1})
 
-    error_like(function () string.gsub(s, '%b(', '') end,
-               "^[^:]+:%d+: .- pattern",
-               "function gsub (malformed pattern)")
+    error_matches(function () string.gsub(s, '%b(', '') end,
+            "^[^:]+:%d+: .- pattern",
+            "function gsub (malformed pattern)")
 
-    eq_array({string.gsub("hello Lua!", "%a", "%0-%0")}, {"h-he-el-ll-lo-o L-Lu-ua-a!", 8})
-    eq_array({string.gsub("hello Lua", "(.)(.)", "%2%1")}, {"ehll ouLa", 4})
+    array_equals({string.gsub("hello Lua!", "%a", "%0-%0")}, {"h-he-el-ll-lo-o L-Lu-ua-a!", 8})
+    array_equals({string.gsub("hello Lua", "(.)(.)", "%2%1")}, {"ehll ouLa", 4})
 
     local function expand (str)
         return (string.gsub(str, '$(%w+)', _G))
     end
     name = 'Lua'; status= 'great'
-    is(expand("$name is $status, isn't it?"), "Lua is great, isn't it?")
-    is(expand("$othername is $status, isn't it?"), "$othername is great, isn't it?")
+    equals(expand("$name is $status, isn't it?"), "Lua is great, isn't it?")
+    equals(expand("$othername is $status, isn't it?"), "$othername is great, isn't it?")
 
     function expand (str)
         return (string.gsub(str, '$(%w+)', function (n)
                                             return tostring(_G[n]), 1
                                        end))
     end
-    like(expand("print = $print; a = $a"), "^print = function: [0]?[Xx]?[builtin]*#?%x+; a = nil")
+    matches(expand("print = $print; a = $a"), "^print = function: [0]?[Xx]?[builtin]*#?%x+; a = nil")
 
-    error_like(function () string.gsub("hello world", '(%w+)', '%2 %2') end,
-               "^[^:]+:%d+: invalid capture index",
-               "function gsub (invalid index)")
+    error_matches(function () string.gsub("hello world", '(%w+)', '%2 %2') end,
+            "^[^:]+:%d+: invalid capture index",
+            "function gsub (invalid index)")
 
-    error_like(function () string.gsub("hello world", '(%w+)', true) end,
-               "^[^:]+:%d+: bad argument #3 to 'gsub' %(string/function/table expected",
-               "function gsub (bad type)")
+    error_matches(function () string.gsub("hello world", '(%w+)', true) end,
+            "^[^:]+:%d+: bad argument #3 to 'gsub' %(string/function/table expected",
+            "function gsub (bad type)")
 
-    error_like(function ()
+    error_matches(function ()
         function expand (str)
            return (string.gsub(str, '$(%w+)', _G))
         end
@@ -423,204 +423,204 @@ do -- gsub
     local function trim (str)
         return (str:gsub('^%s*(.-)%s*$', '%1'))
     end
-    is(trim('foo'), 'foo', "gsub trim")
-    is(trim('   foo  bar  '), 'foo  bar')
+    equals(trim('foo'), 'foo', "gsub trim")
+    equals(trim('   foo  bar  '), 'foo  bar')
 end
 
 do -- len
-    is(string.len(''), 0, "function len")
-    is(string.len('test'), 4)
-    is(string.len("a\000b\000c"), 5)
-    is(string.len('"'), 1)
+    equals(string.len(''), 0, "function len")
+    equals(string.len('test'), 4)
+    equals(string.len("a\000b\000c"), 5)
+    equals(string.len('"'), 1)
 end
 
 do -- lower
-    is(string.lower('Test'), 'test', "function lower")
-    is(string.lower('TeSt'), 'test')
+    equals(string.lower('Test'), 'test', "function lower")
+    equals(string.lower('TeSt'), 'test')
 end
 
 do -- match
     local s = "hello world"
-    is(string.match(s, '^hello'), 'hello', "function match")
-    is(string.match(s, 'world', 2), 'world')
-    is(string.match(s, 'World'), nil)
-    eq_array({string.match(s, '^(h.ll.)')}, {'hello'})
-    eq_array({string.match(s, '^(h.)l(l.)')}, {'he', 'lo'})
+    equals(string.match(s, '^hello'), 'hello', "function match")
+    equals(string.match(s, 'world', 2), 'world')
+    equals(string.match(s, 'World'), nil)
+    array_equals({string.match(s, '^(h.ll.)')}, {'hello'})
+    array_equals({string.match(s, '^(h.)l(l.)')}, {'he', 'lo'})
     local date = "Today is 17/7/1990"
-    is(string.match(date, '%d+/%d+/%d+'), '17/7/1990')
-    eq_array({string.match(date, '(%d+)/(%d+)/(%d+)')}, {'17', '7', '1990'})
-    is(string.match("The number 1298 is even", '%d+'), '1298')
+    equals(string.match(date, '%d+/%d+/%d+'), '17/7/1990')
+    array_equals({string.match(date, '(%d+)/(%d+)/(%d+)')}, {'17', '7', '1990'})
+    equals(string.match("The number 1298 is even", '%d+'), '1298')
     local pair = "name = Anna"
-    eq_array({string.match(pair, '(%a+)%s*=%s*(%a+)')}, {'name', 'Anna'})
+    array_equals({string.match(pair, '(%a+)%s*=%s*(%a+)')}, {'name', 'Anna'})
 
     s = [[then he said: "it's all right"!]]
-    eq_array({string.match(s, "([\"'])(.-)%1")}, {'"', "it's all right"}, "function match (back ref)")
+    array_equals({string.match(s, "([\"'])(.-)%1")}, {'"', "it's all right"}, "function match (back ref)")
     local p = "%[(=*)%[(.-)%]%1%]"
     s = "a = [=[[[ something ]] ]==]x]=]; print(a)"
-    eq_array({string.match(s, p)}, {'=', '[[ something ]] ]==]x'})
+    array_equals({string.match(s, p)}, {'=', '[[ something ]] ]==]x'})
 
     if has_class_g then
-        is(string.match(s, "%g"), "a", "match graphic char")
+        equals(string.match(s, "%g"), "a", "match graphic char")
     end
 
-    error_like(function () string.match("hello world", "%1") end,
-               "^[^:]+:%d+: invalid capture index",
-               "function match invalid capture")
+    error_matches(function () string.match("hello world", "%1") end,
+            "^[^:]+:%d+: invalid capture index",
+            "function match invalid capture")
 
-    error_like(function () string.match("hello world", "%w)") end,
-               "^[^:]+:%d+: invalid pattern capture",
-               "function match invalid capture")
+    error_matches(function () string.match("hello world", "%w)") end,
+            "^[^:]+:%d+: invalid pattern capture",
+            "function match invalid capture")
 end
 
 -- pack
 if has_pack then
-    is(string.pack('b', 0x31), '\x31', "function pack")
-    is(string.pack('>b', 0x31), '\x31')
-    is(string.pack('=b', 0x31), '\x31')
-    is(string.pack('<b', 0x31), '\x31')
-    is(string.pack('>B', 0x91), '\x91')
-    is(string.pack('=B', 0x91), '\x91')
-    is(string.pack('<B', 0x91), '\x91')
-    is(string.byte(string.pack('<h', 1)), 1)
-    is(string.byte(string.pack('>h', 1):reverse()), 1)
-    is(string.byte(string.pack('<H', 1)), 1)
-    is(string.byte(string.pack('>H', 1):reverse()), 1)
-    is(string.byte(string.pack('<l', 1)), 1)
-    is(string.byte(string.pack('>l', 1):reverse()), 1)
-    is(string.byte(string.pack('<L', 1)), 1)
-    is(string.byte(string.pack('>L', 1):reverse()), 1)
-    is(string.byte(string.pack('<j', 1)), 1)
-    is(string.byte(string.pack('>j', 1):reverse()), 1)
-    is(string.byte(string.pack('<J', 1)), 1)
-    is(string.byte(string.pack('>J', 1):reverse()), 1)
-    is(string.byte(string.pack('<T', 1)), 1)
-    is(string.byte(string.pack('>T', 1):reverse()), 1)
-    is(string.byte(string.pack('<i', 1)), 1)
-    is(string.byte(string.pack('>i', 1):reverse()), 1)
-    is(string.byte(string.pack('<I', 1)), 1)
-    is(string.byte(string.pack('>I', 1):reverse()), 1)
-    is(string.pack('i1', 0):len(), 1)
-    is(string.pack('i2', 0):len(), 2)
-    is(string.pack('i4', 0):len(), 4)
-    is(string.pack('i8', 0):len(), 8)
-    is(string.pack('i16', 0):len(), 16)
-    error_like(function () string.pack('i20', 0) end,
-               "^[^:]+:%d+: integral size %(20%) out of limits %[1,16%]",
-               "function pack out limit")
-
-    is(string.pack('!2 i1 i4', 0, 0):len(), 6)
-    is(string.pack('i1 Xb i1', 0, 0):len(), 2)
-    is(string.pack('i1 x x i1', 0, 0):len(), 4)
-
-    is(string.pack('c3', 'foo'), 'foo')
-    is(string.pack('z', 'foo'), 'foo\0')
-    is(string.pack('c4', 'foo'), 'foo\0')   -- padding
-
-    error_like(function () string.pack('w', 0) end,
-               "^[^:]+:%d+: invalid format option 'w'",
-               "function pack invalid format")
-
-    error_like(function () string.pack('i1 Xz i1', 0, 0) end,
-               "^[^:]+:%d+: bad argument #1 to 'pack' %(invalid next option for option 'X'%)",
-               "function pack invalid next")
-
-    error_like(function () string.pack('i', 'foo') end,
-               "^[^:]+:%d+: bad argument #2 to 'pack' %(number expected, got string%)",
-              "function pack bad arg")
+    equals(string.pack('b', 0x31), '\x31', "function pack")
+    equals(string.pack('>b', 0x31), '\x31')
+    equals(string.pack('=b', 0x31), '\x31')
+    equals(string.pack('<b', 0x31), '\x31')
+    equals(string.pack('>B', 0x91), '\x91')
+    equals(string.pack('=B', 0x91), '\x91')
+    equals(string.pack('<B', 0x91), '\x91')
+    equals(string.byte(string.pack('<h', 1)), 1)
+    equals(string.byte(string.pack('>h', 1):reverse()), 1)
+    equals(string.byte(string.pack('<H', 1)), 1)
+    equals(string.byte(string.pack('>H', 1):reverse()), 1)
+    equals(string.byte(string.pack('<l', 1)), 1)
+    equals(string.byte(string.pack('>l', 1):reverse()), 1)
+    equals(string.byte(string.pack('<L', 1)), 1)
+    equals(string.byte(string.pack('>L', 1):reverse()), 1)
+    equals(string.byte(string.pack('<j', 1)), 1)
+    equals(string.byte(string.pack('>j', 1):reverse()), 1)
+    equals(string.byte(string.pack('<J', 1)), 1)
+    equals(string.byte(string.pack('>J', 1):reverse()), 1)
+    equals(string.byte(string.pack('<T', 1)), 1)
+    equals(string.byte(string.pack('>T', 1):reverse()), 1)
+    equals(string.byte(string.pack('<i', 1)), 1)
+    equals(string.byte(string.pack('>i', 1):reverse()), 1)
+    equals(string.byte(string.pack('<I', 1)), 1)
+    equals(string.byte(string.pack('>I', 1):reverse()), 1)
+    equals(string.pack('i1', 0):len(), 1)
+    equals(string.pack('i2', 0):len(), 2)
+    equals(string.pack('i4', 0):len(), 4)
+    equals(string.pack('i8', 0):len(), 8)
+    equals(string.pack('i16', 0):len(), 16)
+    error_matches(function () string.pack('i20', 0) end,
+            "^[^:]+:%d+: integral size %(20%) out of limits %[1,16%]",
+            "function pack out limit")
+
+    equals(string.pack('!2 i1 i4', 0, 0):len(), 6)
+    equals(string.pack('i1 Xb i1', 0, 0):len(), 2)
+    equals(string.pack('i1 x x i1', 0, 0):len(), 4)
+
+    equals(string.pack('c3', 'foo'), 'foo')
+    equals(string.pack('z', 'foo'), 'foo\0')
+    equals(string.pack('c4', 'foo'), 'foo\0')   -- padding
+
+    error_matches(function () string.pack('w', 0) end,
+            "^[^:]+:%d+: invalid format option 'w'",
+            "function pack invalid format")
+
+    error_matches(function () string.pack('i1 Xz i1', 0, 0) end,
+            "^[^:]+:%d+: bad argument #1 to 'pack' %(invalid next option for option 'X'%)",
+            "function pack invalid next")
+
+    error_matches(function () string.pack('i', 'foo') end,
+            "^[^:]+:%d+: bad argument #2 to 'pack' %(number expected, got string%)",
+            "function pack bad arg")
 else
-    is(string.pack, nil, "no string.pack");
+    is_nil(string.pack, "no string.pack");
 end
 
 -- packsize
 if has_pack then
-    is(string.packsize('b'), 1, "function packsize")
+    equals(string.packsize('b'), 1, "function packsize")
 
-    is(string.packsize(''), 0, "function packsize empty")
+    equals(string.packsize(''), 0, "function packsize empty")
 
-    error_like(function () string.packsize('z') end,
-               "^[^:]+:%d+: bad argument #1 to 'packsize' %(variable%-length format%)",
-               "function packsize bad arg")
+    error_matches(function () string.packsize('z') end,
+            "^[^:]+:%d+: bad argument #1 to 'packsize' %(variable%-length format%)",
+            "function packsize bad arg")
 else
-    is(string.packsize, nil, "no string.packsize");
+    is_nil(string.packsize, "no string.packsize");
 end
 
 do -- rep
-    is(string.rep('ab', 3), 'ababab', "function rep")
-    is(string.rep('ab', 0), '')
-    is(string.rep('ab', -1), '')
-    is(string.rep('', 5), '')
+    equals(string.rep('ab', 3), 'ababab', "function rep")
+    equals(string.rep('ab', 0), '')
+    equals(string.rep('ab', -1), '')
+    equals(string.rep('', 5), '')
     if has_rep52 then
-        is(string.rep('ab', 3, ','), 'ab,ab,ab', "with sep")
+        equals(string.rep('ab', 3, ','), 'ab,ab,ab', "with sep")
         local n = 1e6
-        is(string.rep('a', n), string.rep('', n + 1, 'a'))
+        equals(string.rep('a', n), string.rep('', n + 1, 'a'))
     else
         diag("no rep with separator")
     end
 
     if _VERSION >= 'Lua 5.3' then
-        error_like(function () string.rep('foo', 1e9) end,
-                   "^[^:]+:%d+: resulting string too large",
-                   "too large")
+        error_matches(function () string.rep('foo', 1e9) end,
+                "^[^:]+:%d+: resulting string too large",
+                "too large")
     elseif luajit21 then
-        error_is(function () string.rep('foo', 1e9) end,
-                 "not enough memory",
-                 "too large")
+        error_equals(function () string.rep('foo', 1e9) end,
+                "not enough memory",
+                "too large")
     end
 
     if _VERSION >= 'Lua 5.4' or jit then
-        is(string.rep('', 1e8), '', "rep ''")
+        equals(string.rep('', 1e8), '', "rep ''")
     else
         diag('too slow')
     end
 end
 
 do -- reverse
-    is(string.reverse('abcde'), 'edcba', "function reverse")
-    is(string.reverse('abcd'), 'dcba')
-    is(string.reverse(''), '')
+    equals(string.reverse('abcde'), 'edcba', "function reverse")
+    equals(string.reverse('abcd'), 'dcba')
+    equals(string.reverse(''), '')
 end
 
 do -- sub
-    is(string.sub('abcde', 1, 2), 'ab', "function sub")
-    is(string.sub('abcde', 3, 4), 'cd')
-    is(string.sub('abcde', -2), 'de')
-    is(string.sub('abcde', 3, 2), '')
+    equals(string.sub('abcde', 1, 2), 'ab', "function sub")
+    equals(string.sub('abcde', 3, 4), 'cd')
+    equals(string.sub('abcde', -2), 'de')
+    equals(string.sub('abcde', 3, 2), '')
 end
 
 do -- upper
-    is(string.upper('Test'), 'TEST', "function upper")
-    is(string.upper('TeSt'), 'TEST')
-    is(string.upper(string.rep('Test', 10000)), string.rep('TEST', 10000))
+    equals(string.upper('Test'), 'TEST', "function upper")
+    equals(string.upper('TeSt'), 'TEST')
+    equals(string.upper(string.rep('Test', 10000)), string.rep('TEST', 10000))
 end
 
 -- unpack
 if has_pack then
-    is(string.unpack('<h', string.pack('>h', 1):reverse()), 1, "function unpack")
-    is(string.unpack('<H', string.pack('>H', 1):reverse()), 1)
-    is(string.unpack('<l', string.pack('>l', 1):reverse()), 1)
-    is(string.unpack('<L', string.pack('>L', 1):reverse()), 1)
-    is(string.unpack('<j', string.pack('>j', 1):reverse()), 1)
-    is(string.unpack('<J', string.pack('>J', 1):reverse()), 1)
-    is(string.unpack('<T', string.pack('>T', 1):reverse()), 1)
-    is(string.unpack('<i', string.pack('>i', 1):reverse()), 1)
-    is(string.unpack('<I', string.pack('>I', 1):reverse()), 1)
-    is(string.unpack('<f', string.pack('>f', 1.0):reverse()), 1.0)
-    is(string.unpack('<d', string.pack('>d', 1.0):reverse()), 1.0)
-    is(string.unpack('<n', string.pack('>n', 1.0):reverse()), 1.0)
-
-    is(string.unpack('c3', string.pack('c3', 'foo')), 'foo')
-    is(string.unpack('z', string.pack('z', 'foo')), 'foo')
-    is(string.unpack('s', string.pack('s', 'foo')), 'foo')
-
-    error_like(function () string.unpack('c4', 'foo') end,
-               "^[^:]+:%d+: bad argument #2 to 'unpack' %(data string too short%)",
-               "function unpack data too short")
-
-    error_like(function () string.unpack('c', 'foo') end,
-               "^[^:]+:%d+: missing size for format option 'c'",
-               "function unpack missing size")
+    equals(string.unpack('<h', string.pack('>h', 1):reverse()), 1, "function unpack")
+    equals(string.unpack('<H', string.pack('>H', 1):reverse()), 1)
+    equals(string.unpack('<l', string.pack('>l', 1):reverse()), 1)
+    equals(string.unpack('<L', string.pack('>L', 1):reverse()), 1)
+    equals(string.unpack('<j', string.pack('>j', 1):reverse()), 1)
+    equals(string.unpack('<J', string.pack('>J', 1):reverse()), 1)
+    equals(string.unpack('<T', string.pack('>T', 1):reverse()), 1)
+    equals(string.unpack('<i', string.pack('>i', 1):reverse()), 1)
+    equals(string.unpack('<I', string.pack('>I', 1):reverse()), 1)
+    equals(string.unpack('<f', string.pack('>f', 1.0):reverse()), 1.0)
+    equals(string.unpack('<d', string.pack('>d', 1.0):reverse()), 1.0)
+    equals(string.unpack('<n', string.pack('>n', 1.0):reverse()), 1.0)
+
+    equals(string.unpack('c3', string.pack('c3', 'foo')), 'foo')
+    equals(string.unpack('z', string.pack('z', 'foo')), 'foo')
+    equals(string.unpack('s', string.pack('s', 'foo')), 'foo')
+
+    error_matches(function () string.unpack('c4', 'foo') end,
+            "^[^:]+:%d+: bad argument #2 to 'unpack' %(data string too short%)",
+            "function unpack data too short")
+
+    error_matches(function () string.unpack('c', 'foo') end,
+            "^[^:]+:%d+: missing size for format option 'c'",
+            "function unpack missing size")
 else
-    is(string.unpack, nil, "no string.unpack");
+    is_nil(string.unpack, "no string.unpack");
 end
 
 done_testing()
diff --git a/test/lua-Harness-tests/305-utf8.t b/test/lua-Harness-tests/305-utf8.t
index 6c125388..be0ace6e 100755
--- a/test/lua-Harness-tests/305-utf8.t
+++ b/test/lua-Harness-tests/305-utf8.t
@@ -2,7 +2,7 @@
 --
 -- lua-Harness : <https://fperrad.frama.io/lua-Harness/>
 --
--- Copyright (C) 2014-2020, Perrad Francois
+-- Copyright (C) 2014-2021, Perrad Francois
 --
 -- This code is licensed under the terms of the MIT/X11 license,
 -- like Lua itself.
@@ -37,7 +37,7 @@ local has_utf8 = _VERSION >= 'Lua 5.3' or (jit and jit.version:match'moonjit') o
 
 if not utf8 then
     plan(1)
-    nok(has_utf8, "no has_utf8")
+    falsy(has_utf8, "no has_utf8")
 else
     plan'no_plan'
     make_specific_checks'lexico53/utf8.t'
diff --git a/test/lua-Harness-tests/306-table.t b/test/lua-Harness-tests/306-table.t
index 98366556..c57947f6 100755
--- a/test/lua-Harness-tests/306-table.t
+++ b/test/lua-Harness-tests/306-table.t
@@ -2,7 +2,7 @@
 --
 -- lua-Harness : <https://fperrad.frama.io/lua-Harness/>
 --
--- Copyright (C) 2009-2020, Perrad Francois
+-- Copyright (C) 2009-2021, Perrad Francois
 --
 -- This code is licensed under the terms of the MIT/X11 license,
 -- like Lua itself.
@@ -48,62 +48,62 @@ plan'no_plan'
 
 do -- concat
     local t = {'a','b','c','d','e'}
-    is(table.concat(t), 'abcde', "function concat")
-    is(table.concat(t, ','), 'a,b,c,d,e')
-    is(table.concat(t, ',',2), 'b,c,d,e')
-    is(table.concat(t, ',', 2, 4), 'b,c,d')
-    is(table.concat(t, ',', 4, 2), '')
+    equals(table.concat(t), 'abcde', "function concat")
+    equals(table.concat(t, ','), 'a,b,c,d,e')
+    equals(table.concat(t, ',',2), 'b,c,d,e')
+    equals(table.concat(t, ',', 2, 4), 'b,c,d')
+    equals(table.concat(t, ',', 4, 2), '')
 
     t = {'a','b',3,'d','e'}
     if nocvtn2s then
-        error_like(function () table.concat(t,',') end,
-               "^[^:]+:%d+: invalid value %(number%) at index 3 in table for 'concat'",
-               "function concat (number no conv)")
+        error_matches(function () table.concat(t,',') end,
+            "^[^:]+:%d+: invalid value %(number%) at index 3 in table for 'concat'",
+            "function concat (number no conv)")
     else
-        is(table.concat(t,','), 'a,b,3,d,e', "function concat (number)")
+        equals(table.concat(t,','), 'a,b,3,d,e', "function concat (number)")
     end
 
     t = {'a','b','c','d','e'}
-    error_like(function () table.concat(t, ',', 2, 7) end,
-               "^[^:]+:%d+: invalid value %(nil%) at index 6 in table for 'concat'",
-               "function concat (out of range)")
+    error_matches(function () table.concat(t, ',', 2, 7) end,
+            "^[^:]+:%d+: invalid value %(nil%) at index 6 in table for 'concat'",
+            "function concat (out of range)")
 
     t = {'a','b',true,'d','e'}
-    error_like(function () table.concat(t, ',') end,
-               "^[^:]+:%d+: invalid value %(boolean%) at index 3 in table for 'concat'",
-               "function concat (non-string)")
+    error_matches(function () table.concat(t, ',') end,
+            "^[^:]+:%d+: invalid value %(boolean%) at index 3 in table for 'concat'",
+            "function concat (non-string)")
 end
 
 do -- insert
     local a = {'10', '20', '30'}
     table.insert(a, 1, '15')
-    is(table.concat(a,','), '15,10,20,30', "function insert")
+    equals(table.concat(a,','), '15,10,20,30', "function insert")
     local t = {}
     table.insert(t, 'a')
-    is(table.concat(t, ','), 'a')
+    equals(table.concat(t, ','), 'a')
     table.insert(t, 'b')
-    is(table.concat(t, ','), 'a,b')
+    equals(table.concat(t, ','), 'a,b')
     table.insert(t, 1, 'c')
-    is(table.concat(t, ','), 'c,a,b')
+    equals(table.concat(t, ','), 'c,a,b')
     table.insert(t, 2, 'd')
-    is(table.concat(t, ','), 'c,d,a,b')
+    equals(table.concat(t, ','), 'c,d,a,b')
     table.insert(t, 5, 'e')
-    is(table.concat(t, ','), 'c,d,a,b,e')
+    equals(table.concat(t, ','), 'c,d,a,b,e')
 
     if _VERSION == 'Lua 5.1' then
         todo("not with 5.1", 2)
     end
-    error_like(function () table.insert(t, 7, 'f') end,
-               "^[^:]+:%d+: bad argument #2 to 'insert' %(position out of bounds%)",
-               "function insert (out of bounds)")
+    error_matches(function () table.insert(t, 7, 'f') end,
+            "^[^:]+:%d+: bad argument #2 to 'insert' %(position out of bounds%)",
+            "function insert (out of bounds)")
 
-    error_like(function () table.insert(t, -9, 'f') end,
-               "^[^:]+:%d+: bad argument #2 to 'insert' %(position out of bounds%)",
-               "function insert (out of bounds)")
+    error_matches(function () table.insert(t, -9, 'f') end,
+            "^[^:]+:%d+: bad argument #2 to 'insert' %(position out of bounds%)",
+            "function insert (out of bounds)")
 
-    error_like(function () table.insert(t, 2, 'g', 'h')  end,
-               "^[^:]+:%d+: wrong number of arguments to 'insert'",
-               "function insert (too many arg)")
+    error_matches(function () table.insert(t, 2, 'g', 'h')  end,
+            "^[^:]+:%d+: wrong number of arguments to 'insert'",
+            "function insert (too many arg)")
 end
 
 -- foreach 5.0
@@ -111,7 +111,7 @@ if has_foreach then
     local t = {a=10, b=100}
     local output = {}
     table.foreach(t, function (k, v) output[k] = v end)
-    eq_array(output, t, "function foreach (hash)")
+    array_equals(output, t, "function foreach (hash)")
 
     t = {'a','b','c'}
     output = {}
@@ -119,9 +119,9 @@ if has_foreach then
         table.insert(output, k)
         table.insert(output, v)
     end)
-    eq_array(output, {1, 'a', 2, 'b', 3, 'c'}, "function foreach (array)")
+    array_equals(output, {1, 'a', 2, 'b', 3, 'c'}, "function foreach (array)")
 else
-    is(table.foreach, nil, "no table.foreach");
+    is_nil(table.foreach, "no table.foreach");
 end
 
 -- foreachi 5.0
@@ -132,33 +132,33 @@ if has_foreachi then
         table.insert(output, i)
         table.insert(output, v)
     end)
-    eq_array(output, {1, 'a', 2, 'b', 3, 'c'}, "function foreachi")
+    array_equals(output, {1, 'a', 2, 'b', 3, 'c'}, "function foreachi")
 else
-    is(table.foreachi, nil, "no table.foreachi");
+    is_nil(table.foreachi, "no table.foreachi");
 end
 
 if has_getn then
-    is(table.getn{10,2,4}, 3, "function getn")
-    is(table.getn{10,2,nil}, 2)
+    equals(table.getn{10,2,4}, 3, "function getn")
+    equals(table.getn{10,2,nil}, 2)
 else
-    is(table.getn, nil, "no table.getn");
+    is_nil(table.getn, "no table.getn");
 end
 
 -- maxn
 if has_maxn then
     local t = {}
-    is(table.maxn(t), 0, "function maxn")
+    equals(table.maxn(t), 0, "function maxn")
     t[1] = 'a'
     t[2] = 'b'
-    is(table.maxn(t), 2)
+    equals(table.maxn(t), 2)
     t[6] = 'g'
-    is(table.maxn(t), 6)
+    equals(table.maxn(t), 6)
 
     local a = {}
     a[10000] = 1
-    is(table.maxn(a), 10000)
+    equals(table.maxn(a), 10000)
 else
-    is(table.maxn, nil, "no table.maxn");
+    is_nil(table.maxn, "no table.maxn");
 end
 
 -- move
@@ -166,78 +166,78 @@ if has_move then
     local a = {'a', 'b', 'c'}
     local t = { 1, 2, 3, 4}
     table.move(a, 1, 3, 1, t)
-    eq_array(t, {'a', 'b', 'c', 4}, "function move")
+    array_equals(t, {'a', 'b', 'c', 4}, "function move")
     table.move(a, 1, 3, 3, t)
-    eq_array(t, {'a', 'b', 'a', 'b', 'c'})
+    array_equals(t, {'a', 'b', 'a', 'b', 'c'})
 
     table.move(a, 1, 3, 1)
-    eq_array(a, {'a', 'b', 'c'})
+    array_equals(a, {'a', 'b', 'c'})
     table.move(a, 1, 3, 3)
-    eq_array(a, {'a', 'b', 'a', 'b', 'c'})
+    array_equals(a, {'a', 'b', 'a', 'b', 'c'})
 
-    error_like(function () table.move(a, 1, 2, 1, 2) end,
-               "^[^:]+:%d+: bad argument #5 to 'move' %(table expected",
-               "function move (bad arg)")
+    error_matches(function () table.move(a, 1, 2, 1, 2) end,
+            "^[^:]+:%d+: bad argument #5 to 'move' %(table expected",
+            "function move (bad arg)")
 
-    error_like(function () table.move(a, 1, 2) end,
-               "^[^:]+:%d+: bad argument #4 to 'move' %(number expected, got .-%)",
-               "function move (bad arg)")
+    error_matches(function () table.move(a, 1, 2) end,
+            "^[^:]+:%d+: bad argument #4 to 'move' %(number expected, got .-%)",
+            "function move (bad arg)")
 
-    error_like(function () table.move(a, 1) end,
-               "^[^:]+:%d+: bad argument #3 to 'move' %(number expected, got .-%)",
-               "function move (bad arg)")
+    error_matches(function () table.move(a, 1) end,
+            "^[^:]+:%d+: bad argument #3 to 'move' %(number expected, got .-%)",
+            "function move (bad arg)")
 else
-    is(table.move, nil, "no table.move");
+    is_nil(table.move, "no table.move");
 end
 
 -- pack
 if has_pack then
     local t = table.pack("abc", "def", "ghi")
-    eq_array(t, {
+    array_equals(t, {
         "abc",
         "def",
         "ghi"
     }, "function pack")
-    is(t.n, 3)
+    equals(t.n, 3)
 
     t = table.pack()
-    eq_array(t, {}, "function pack (no element)")
-    is(t.n, 0)
+    array_equals(t, {}, "function pack (no element)")
+    equals(t.n, 0)
 else
-    is(table.pack, nil, "no table.pack");
+    is_nil(table.pack, "no table.pack");
 end
 
 do -- remove
     local t = {}
     local a = table.remove(t)
-    is(a, nil, "function remove")
+    equals(a, nil, "function remove")
     t = {'a','b','c','d','e'}
     a = table.remove(t)
-    is(a, 'e')
-    is(table.concat(t, ','), 'a,b,c,d')
+    equals(a, 'e')
+    equals(table.concat(t, ','), 'a,b,c,d')
     a = table.remove(t,3)
-    is(a, 'c')
-    is(table.concat(t, ','), 'a,b,d')
+    equals(a, 'c')
+    equals(table.concat(t, ','), 'a,b,d')
     a = table.remove(t,1)
-    is(a, 'a')
-    is(table.concat(t, ','), 'b,d')
+    equals(a, 'a')
+    equals(table.concat(t, ','), 'b,d')
 
     if _VERSION == 'Lua 5.1' then
         todo("not with 5.1", 1)
     end
-    error_like(function () table.remove(t,7) end,
-               "^[^:]+:%d+: bad argument #1 to 'remove' %(position out of bounds%)",
-               "function remove (out of bounds)")
+    error_matches(function () table.remove(t,7) end,
+            "^[^:]+:%d+: bad argument #1 to 'remove' %(position out of bounds%)",
+            "function remove (out of bounds)")
 end
 
 -- setn obsolete
 if has_setn_obsolete then
     local a = {}
-    error_like(function () table.setn(a, 10000) end,
-               "^[^:]+:%d+: 'setn' is obsolete",
-               "function setn")
+    error_matches(function () table.setn(a, 10000) end,
+            "^[^:]+:%d+: 'setn' is obsolete",
+            "function setn")
 else
-    is(table.setn, nil, "no table.setn");
+    is_nil(table.setn, "no table.setn");
 end
 
 do -- sort
@@ -255,7 +255,7 @@ do -- sort
         for _, n in ipairs(a) do
             table.insert(output, n)
         end
-        eq_array(output, {'luaH_get', 'luaH_present', 'luaH_set'}, "function sort")
+        array_equals(output, {'luaH_get', 'luaH_present', 'luaH_set'}, "function sort")
     end
 
     do
@@ -275,14 +275,14 @@ do -- sort
             table.insert(output, name)
             table.insert(output, line)
         end
-        eq_array(output, {'luaH_get', 24, 'luaH_present', 48, 'luaH_set', 10}, "function sort")
+        array_equals(output, {'luaH_get', 24, 'luaH_present', 48, 'luaH_set', 10}, "function sort")
 
         output = {}
         for name, line in pairsByKeys(lines, function (a, b) return a < b end) do
             table.insert(output, name)
             table.insert(output, line)
         end
-        eq_array(output, {'luaH_get', 24, 'luaH_present', 48, 'luaH_set', 10}, "function sort")
+        array_equals(output, {'luaH_get', 24, 'luaH_present', 48, 'luaH_set', 10}, "function sort")
     end
 
     do
@@ -326,7 +326,7 @@ do -- sort
             table.insert(output, n)
         end
 
-        eq_array(output, {
+        array_equals(output, {
             'a', 1,
             'a b', 2,
             'a b c', 6,
@@ -340,26 +340,26 @@ do -- sort
     if _VERSION == 'Lua 5.1' and not jit then
         todo("not with 5.1")
     end
-    error_like(function ()
+    error_matches(function ()
                    local t = { 1 }
                    table.sort( { t, t, t, t, }, function (a, b) return a[1] == b[1] end )
-               end,
-               "^[^:]+:%d+: invalid order function for sorting",
-               "function sort (bad func)")
+            end,
+            "^[^:]+:%d+: invalid order function for sorting",
+            "function sort (bad func)")
 end
 
 -- unpack
 if has_unpack then
-    eq_array({table.unpack({})}, {}, "function unpack")
-    eq_array({table.unpack({'a'})}, {'a'})
-    eq_array({table.unpack({'a','b','c'})}, {'a','b','c'})
-    eq_array({(table.unpack({'a','b','c'}))}, {'a'})
-    eq_array({table.unpack({'a','b','c','d','e'},2,4)}, {'b','c','d'})
-    eq_array({table.unpack({'a','b','c'},2,4)}, {'b','c'})
+    array_equals({table.unpack({})}, {}, "function unpack")
+    array_equals({table.unpack({'a'})}, {'a'})
+    array_equals({table.unpack({'a','b','c'})}, {'a','b','c'})
+    array_equals({(table.unpack({'a','b','c'}))}, {'a'})
+    array_equals({table.unpack({'a','b','c','d','e'},2,4)}, {'b','c','d'})
+    array_equals({table.unpack({'a','b','c'},2,4)}, {'b','c'})
 elseif has_alias_unpack then
-    is(table.unpack, unpack, "alias table.unpack");
+    equals(table.unpack, unpack, "alias table.unpack");
 else
-    is(table.unpack, nil, "no table.unpack");
+    is_nil(table.unpack, "no table.unpack");
 end
 
 done_testing()
diff --git a/test/lua-Harness-tests/307-math.t b/test/lua-Harness-tests/307-math.t
index 8b51ed16..b50e449f 100755
--- a/test/lua-Harness-tests/307-math.t
+++ b/test/lua-Harness-tests/307-math.t
@@ -2,7 +2,7 @@
 --
 -- lua-Harness : <https://fperrad.frama.io/lua-Harness/>
 --
--- Copyright (C) 2009-2020, Perrad Francois
+-- Copyright (C) 2009-2021, Perrad Francois
 --
 -- This code is licensed under the terms of the MIT/X11 license,
 -- like Lua itself.
@@ -43,91 +43,91 @@ local nocvts2n = profile.nocvts2n or jit
 plan'no_plan'
 
 do -- abs
-    is(math.abs(-12.34), 12.34, "function abs (float)")
-    is(math.abs(12.34), 12.34)
+    equals(math.abs(-12.34), 12.34, "function abs (float)")
+    equals(math.abs(12.34), 12.34)
     if math.type then
-        is(math.type(math.abs(-12.34)), 'float')
+        equals(math.type(math.abs(-12.34)), 'float')
     end
-    is(math.abs(-12), 12, "function abs (integer)")
-    is(math.abs(12), 12)
+    equals(math.abs(-12), 12, "function abs (integer)")
+    equals(math.abs(12), 12)
     if math.type then
-        is(math.type(math.abs(-12)), 'integer')
+        equals(math.type(math.abs(-12)), 'integer')
     end
 end
 
 do -- acos
-    like(math.acos(0.5), '^1%.047', "function acos")
+    matches(math.acos(0.5), '^1%.047', "function acos")
 end
 
 do -- asin
-    like(math.asin(0.5), '^0%.523', "function asin")
+    matches(math.asin(0.5), '^0%.523', "function asin")
 end
 
 do -- atan
-    like(math.atan(0.5), '^0%.463', "function atan")
+    matches(math.atan(0.5), '^0%.463', "function atan")
 end
 
 -- atan2
 if has_mathx then
-    like(math.atan2(1.0, 2.0), '^0%.463', "function atan2")
+    matches(math.atan2(1.0, 2.0), '^0%.463', "function atan2")
 else
-    is(math.atan2, nil, "function atan2 (removed)")
+    is_nil(math.atan2, "function atan2 (removed)")
 end
 
 do -- ceil
-    is(math.ceil(12.34), 13, "function ceil")
-    is(math.ceil(-12.34), -12)
-    is(math.ceil(-12), -12)
+    equals(math.ceil(12.34), 13, "function ceil")
+    equals(math.ceil(-12.34), -12)
+    equals(math.ceil(-12), -12)
     if math.type then
-        is(math.type(math.ceil(-12.34)), 'integer')
+        equals(math.type(math.ceil(-12.34)), 'integer')
     end
 end
 
 do -- cos
-    like(math.cos(1.0), '^0%.540', "function cos")
+    matches(math.cos(1.0), '^0%.540', "function cos")
 end
 
 -- cosh
 if has_mathx then
-    like(math.cosh(1.0), '^1%.543', "function cosh")
+    matches(math.cosh(1.0), '^1%.543', "function cosh")
 else
-    is(math.cosh, nil, "function cosh (removed)")
+    is_nil(math.cosh, "function cosh (removed)")
 end
 
 do -- deg
-    is(math.deg(math.pi), 180, "function deg")
+    equals(math.deg(math.pi), 180, "function deg")
 end
 
 do -- exp
-    like(math.exp(1.0), '^2%.718', "function exp")
+    matches(math.exp(1.0), '^2%.718', "function exp")
 end
 
 do -- floor
-    is(math.floor(12.34), 12, "function floor")
-    is(math.floor(-12.34), -13)
-    is(math.floor(-12), -12)
+    equals(math.floor(12.34), 12, "function floor")
+    equals(math.floor(-12.34), -13)
+    equals(math.floor(-12), -12)
     if math.type then
-        is(math.type(math.floor(-12.34)), 'integer')
+        equals(math.type(math.floor(-12.34)), 'integer')
     end
 end
 
 do -- fmod
-    like(math.fmod(7.0001, 0.3), '^0%.100', "function fmod (float)")
-    like(math.fmod(-7.0001, 0.3), '^-0%.100')
-    like(math.fmod(-7.0001, -0.3), '^-0%.100')
+    matches(math.fmod(7.0001, 0.3), '^0%.100', "function fmod (float)")
+    matches(math.fmod(-7.0001, 0.3), '^-0%.100')
+    matches(math.fmod(-7.0001, -0.3), '^-0%.100')
     if math.type then
-        is(math.type(math.fmod(7.0, 0.3)), 'float')
+        equals(math.type(math.fmod(7.0, 0.3)), 'float')
     end
-    is(math.fmod(7, 3), 1, "function fmod (integer)")
-    is(math.fmod(-7, 3), -1)
-    is(math.fmod(-7, -1), 0)
+    equals(math.fmod(7, 3), 1, "function fmod (integer)")
+    equals(math.fmod(-7, 3), -1)
+    equals(math.fmod(-7, -1), 0)
     if math.type then
-        is(math.type(math.fmod(7, 3)), 'integer')
+        equals(math.type(math.fmod(7, 3)), 'integer')
     end
     if _VERSION >= 'Lua 5.3' then
-        error_like(function () math.fmod(7, 0) end,
-                   "^[^:]+:%d+: bad argument #2 to 'fmod' %(zero%)",
-                   "function fmod 0")
+        error_matches(function () math.fmod(7, 0) end,
+                "^[^:]+:%d+: bad argument #2 to 'fmod' %(zero%)",
+                "function fmod 0")
     else
         diag"fmod by zero -> nan"
     end
@@ -135,151 +135,151 @@ end
 
 -- frexp
 if has_mathx then
-    eq_array({math.frexp(1.5)}, {0.75, 1}, "function frexp")
+    array_equals({math.frexp(1.5)}, {0.75, 1}, "function frexp")
 else
-    is(math.frexp, nil, "function frexp (removed)")
+    is_nil(math.frexp, "function frexp (removed)")
 end
 
 do -- huge
-    type_ok(math.huge, 'number', "variable huge")
+    is_number(math.huge, "variable huge")
     if math.type then
-        is(math.type(math.huge), 'float')
+        equals(math.type(math.huge), 'float')
     end
 end
 
 -- ldexp
 if has_mathx then
-    is(math.ldexp(1.2, 3), 9.6, "function ldexp")
+    equals(math.ldexp(1.2, 3), 9.6, "function ldexp")
 else
-    is(math.ldexp, nil, "function ldexp (removed)")
+    is_nil(math.ldexp, "function ldexp (removed)")
 end
 
 do -- log
-    like(math.log(47), '^3%.85', "function log")
+    matches(math.log(47), '^3%.85', "function log")
     if has_log_with_base then
-        like(math.log(47, math.exp(1)), '^3%.85', "function log (base e)")
-        like(math.log(47, 2), '^5%.554', "function log (base 2)")
-        like(math.log(47, 10), '^1%.672', "function log (base 10)")
+        matches(math.log(47, math.exp(1)), '^3%.85', "function log (base e)")
+        matches(math.log(47, 2), '^5%.554', "function log (base 2)")
+        matches(math.log(47, 10), '^1%.672', "function log (base 10)")
     end
 end
 
 -- log10
 if has_log10 then
-    like(math.log10(47.0), '^1%.672', "function log10")
+    matches(math.log10(47.0), '^1%.672', "function log10")
 else
-    is(math.log10, nil, "function log10 (removed)")
+    is_nil(math.log10, "function log10 (removed)")
 end
 
 do --max
-    is(math.max(1), 1, "function max")
-    is(math.max(1, 2), 2)
-    is(math.max(1, 2, 3, -4), 3)
+    equals(math.max(1), 1, "function max")
+    equals(math.max(1, 2), 2)
+    equals(math.max(1, 2, 3, -4), 3)
 
-    error_like(function () math.max() end,
-               "^[^:]+:%d+: bad argument #1 to 'max' %(.- expected",
-               "function max 0")
+    error_matches(function () math.max() end,
+            "^[^:]+:%d+: bad argument #1 to 'max' %(.- expected",
+            "function max 0")
 end
 
 -- maxinteger
 if has_integer then
-    type_ok(math.maxinteger, 'number', "variable maxinteger")
+    is_number(math.maxinteger, "variable maxinteger")
     if math.type then
-        is(math.type(math.maxinteger), 'integer')
+        equals(math.type(math.maxinteger), 'integer')
     end
 else
-    is(math.maxinteger, nil, "no maxinteger")
+    is_nil(math.maxinteger, "no maxinteger")
 end
 
 do --min
-    is(math.min(1), 1, "function min")
-    is(math.min(1, 2), 1)
-    is(math.min(1, 2, 3, -4), -4)
+    equals(math.min(1), 1, "function min")
+    equals(math.min(1, 2), 1)
+    equals(math.min(1, 2, 3, -4), -4)
 
-    error_like(function () math.min() end,
-               "^[^:]+:%d+: bad argument #1 to 'min' %(.- expected",
-               "function min 0")
+    error_matches(function () math.min() end,
+            "^[^:]+:%d+: bad argument #1 to 'min' %(.- expected",
+            "function min 0")
 end
 
 -- mininteger
 if has_integer then
-    type_ok(math.mininteger, 'number', "variable mininteger")
+    is_number(math.mininteger, "variable mininteger")
     if math.type then
-        is(math.type(math.mininteger), 'integer')
+        equals(math.type(math.mininteger), 'integer')
     end
 else
-    is(math.mininteger, nil, "no mininteger")
+    is_nil(math.mininteger, "no mininteger")
 end
 
 -- mod (compat50)
 if has_mod then
-    is(math.mod, math.fmod, "function mod (alias fmod)")
+    equals(math.mod, math.fmod, "function mod (alias fmod)")
 else
-    is(math.mod, nil, "function mod (alias removed)")
+    is_nil(math.mod, "function mod (alias removed)")
 end
 
 do -- modf
-    eq_array({math.modf(2.25)}, {2, 0.25}, "function modf")
-    eq_array({math.modf(2)}, {2, 0.0})
+    array_equals({math.modf(2.25)}, {2, 0.25}, "function modf")
+    array_equals({math.modf(2)}, {2, 0.0})
 end
 
 do -- pi
-    like(tostring(math.pi), '^3%.14', "variable pi")
+    matches(tostring(math.pi), '^3%.14', "variable pi")
 end
 
 -- pow
 if has_mathx then
-    is(math.pow(-2, 3), -8, "function pow")
+    equals(math.pow(-2, 3), -8, "function pow")
 else
-    is(math.pow, nil, "function pow (removed)")
+    is_nil(math.pow, "function pow (removed)")
 end
 
 do -- rad
-    like(math.rad(180), '^3%.14', "function rad")
+    matches(math.rad(180), '^3%.14', "function rad")
 end
 
 do -- random
-    like(math.random(), '^0%.%d+', "function random no arg")
+    matches(math.random(), '^0%.%d+', "function random no arg")
     if math.type then
-        is(math.type(math.random()), 'float')
+        equals(math.type(math.random()), 'float')
     end
-    like(math.random(9), '^%d$', "function random 1 arg")
+    matches(math.random(9), '^%d$', "function random 1 arg")
     if math.type then
-        is(math.type(math.random(9)), 'integer')
+        equals(math.type(math.random(9)), 'integer')
     end
-    like(math.random(10, 19), '^1%d$', "function random 2 arg")
+    matches(math.random(10, 19), '^1%d$', "function random 2 arg")
     if math.type then
-        is(math.type(math.random(10, 19)), 'integer')
+        equals(math.type(math.random(10, 19)), 'integer')
     end
-    like(math.random(-19, -10), '^-1%d$', "function random 2 arg")
+    matches(math.random(-19, -10), '^-1%d$', "function random 2 arg")
 
     if _VERSION >= 'Lua 5.4' then
-        like(math.random(0), '^%-?%d+$', "function random 0")
+        matches(math.random(0), '^%-?%d+$', "function random 0")
     else
         if jit then
             todo("LuaJIT intentional. Don't check empty interval.")
         end
-        error_like(function () math.random(0) end,
-                   "^[^:]+:%d+: bad argument #1 to 'random' %(interval is empty%)",
-                  "function random empty interval")
+        error_matches(function () math.random(0) end,
+                "^[^:]+:%d+: bad argument #1 to 'random' %(interval is empty%)",
+                "function random empty interval")
     end
 
     if jit then
         todo("LuaJIT intentional. Don't check empty interval.", 2)
     end
-    error_like(function () math.random(-9) end,
-               "^[^:]+:%d+: bad argument #%d to 'random' %(interval is empty%)",
-               "function random empty interval")
+    error_matches(function () math.random(-9) end,
+            "^[^:]+:%d+: bad argument #%d to 'random' %(interval is empty%)",
+            "function random empty interval")
 
-    error_like(function () math.random(19, 10) end,
-               "^[^:]+:%d+: bad argument #%d to 'random' %(interval is empty%)",
-               "function random empty interval")
+    error_matches(function () math.random(19, 10) end,
+            "^[^:]+:%d+: bad argument #%d to 'random' %(interval is empty%)",
+            "function random empty interval")
 
     if jit then
         todo("LuaJIT intentional. Don't care about extra arguments.")
     end
-    error_like(function () math.random(1, 2, 3) end,
-               "^[^:]+:%d+: wrong number of arguments",
-               "function random too many arg")
+    error_matches(function () math.random(1, 2, 3) end,
+            "^[^:]+:%d+: wrong number of arguments",
+            "function random too many arg")
 end
 
 do -- randomseed
@@ -287,82 +287,82 @@ do -- randomseed
     local a = math.random()
     math.randomseed(42)
     local b = math.random()
-    is(a, b, "function randomseed")
+    equals(a, b, "function randomseed")
 end
 
 do -- sin
-    like(math.sin(1.0), '^0%.841', "function sin")
+    matches(math.sin(1.0), '^0%.841', "function sin")
 end
 
 -- sinh
 if has_mathx then
-    like(math.sinh(1), '^1%.175', "function sinh")
+    matches(math.sinh(1), '^1%.175', "function sinh")
 else
-    is(math.sinh, nil, "function sinh (removed)")
+    is_nil(math.sinh, "function sinh (removed)")
 end
 
 do -- sqrt
-    like(math.sqrt(2), '^1%.414', "function sqrt")
+    matches(math.sqrt(2), '^1%.414', "function sqrt")
 end
 
 do -- tan
-    like(math.tan(1.0), '^1%.557', "function tan")
+    matches(math.tan(1.0), '^1%.557', "function tan")
 end
 
 -- tanh
 if has_mathx then
-    like(math.tanh(1), '^0%.761', "function tanh")
+    matches(math.tanh(1), '^0%.761', "function tanh")
 else
-    is(math.tanh, nil, "function tanh (removed)")
+    is_nil(math.tanh, "function tanh (removed)")
 end
 
 -- tointeger
 if has_integer then
-    is(math.tointeger(-12), -12, "function tointeger (number)")
-    is(math.tointeger(-12.0), -12)
-    is(math.tointeger(-12.34), nil)
+    equals(math.tointeger(-12), -12, "function tointeger (number)")
+    equals(math.tointeger(-12.0), -12)
+    equals(math.tointeger(-12.34), nil)
     if nocvts2n then
-        is(math.tointeger('-12'), nil, "function tointeger (string)")
-        is(math.tointeger('-12.0'), nil)
+        equals(math.tointeger('-12'), nil, "function tointeger (string)")
+        equals(math.tointeger('-12.0'), nil)
     else
-        is(math.tointeger('-12'), -12, "function tointeger (string)")
-        is(math.tointeger('-12.0'), -12)
+        equals(math.tointeger('-12'), -12, "function tointeger (string)")
+        equals(math.tointeger('-12.0'), -12)
     end
-    is(math.tointeger('-12.34'), nil)
-    is(math.tointeger('bad'), nil)
-    is(math.tointeger(true), nil, "function tointeger (boolean)")
-    is(math.tointeger({}), nil, "function tointeger (table)")
+    equals(math.tointeger('-12.34'), nil)
+    equals(math.tointeger('bad'), nil)
+    equals(math.tointeger(true), nil, "function tointeger (boolean)")
+    equals(math.tointeger({}), nil, "function tointeger (table)")
 else
-    is(math.tointeger, nil, "no math.tointeger")
+    is_nil(math.tointeger, "no math.tointeger")
 end
 
 -- type
 if has_integer then
-    is(math.type(3), 'integer', "function type")
-    is(math.type(3.14), 'float')
-    is(math.type('3.14'), nil)
+    equals(math.type(3), 'integer', "function type")
+    equals(math.type(3.14), 'float')
+    equals(math.type('3.14'), nil)
 else
-    is(math.type, nil, "no math.type")
+    is_nil(math.type, "no math.type")
 end
 
 -- ult
 if has_integer then
-    is(math.ult(2, 3), true, "function ult")
-    is(math.ult(2, 2), false)
-    is(math.ult(2, 1), false)
-
-    error_like(function () math.ult(3.14) end,
-               "^%S+ bad argument #1 to 'ult' %(number has no integer representation%)",
-               "function ult (float)")
-    error_like(function () math.ult(2, 3.14) end,
-               "^%S+ bad argument #2 to 'ult' %(number has no integer representation%)")
-    error_like(function () math.ult(true) end,
-               "^[^:]+:%d+: bad argument #1 to 'ult' %(number expected, got boolean%)",
-               "function ult (boolean)")
-    error_like(function () math.ult(2, true) end,
-               "^[^:]+:%d+: bad argument #2 to 'ult' %(number expected, got boolean%)")
+    equals(math.ult(2, 3), true, "function ult")
+    equals(math.ult(2, 2), false)
+    equals(math.ult(2, 1), false)
+
+    error_matches(function () math.ult(3.14) end,
+            "^%S+ bad argument #1 to 'ult' %(number has no integer representation%)",
+            "function ult (float)")
+    error_matches(function () math.ult(2, 3.14) end,
+            "^%S+ bad argument #2 to 'ult' %(number has no integer representation%)")
+    error_matches(function () math.ult(true) end,
+            "^[^:]+:%d+: bad argument #1 to 'ult' %(number expected, got boolean%)",
+            "function ult (boolean)")
+    error_matches(function () math.ult(2, true) end,
+            "^[^:]+:%d+: bad argument #2 to 'ult' %(number expected, got boolean%)")
 else
-    is(math.ult, nil, "no math.ult")
+    is_nil(math.ult, "no math.ult")
 end
 
 done_testing()
diff --git a/test/lua-Harness-tests/308-io.t b/test/lua-Harness-tests/308-io.t
index 35d39c02..c126adf2 100755
--- a/test/lua-Harness-tests/308-io.t
+++ b/test/lua-Harness-tests/308-io.t
@@ -2,7 +2,7 @@
 --
 -- lua-Harness : <https://fperrad.frama.io/lua-Harness/>
 --
--- Copyright (C) 2009-2020, Perrad Francois
+-- Copyright (C) 2009-2021, Perrad Francois
 --
 -- This code is licensed under the terms of the MIT/X11 license,
 -- like Lua itself.
@@ -45,142 +45,142 @@ local lua = get_lua_binary_name()
 plan'no_plan'
 
 do -- stdin
-    like(io.stdin, '^file %(0?[Xx]?%x+%)$', "variable stdin")
+    matches(io.stdin, '^file %(0?[Xx]?%x+%)$', "variable stdin")
 end
 
 do -- stdout
-    like(io.stdout, '^file %(0?[Xx]?%x+%)$', "variable stdout")
+    matches(io.stdout, '^file %(0?[Xx]?%x+%)$', "variable stdout")
 end
 
 do -- stderr
-    like(io.stderr, '^file %(0?[Xx]?%x+%)$', "variable stderr")
+    matches(io.stderr, '^file %(0?[Xx]?%x+%)$', "variable stderr")
 end
 
 do -- metatable
     local f = io.tmpfile()
     local mt = getmetatable(f)
-    type_ok(mt, 'table', "metatable")
+    is_table(mt, "metatable")
 
-    type_ok(mt.__gc, 'function')
-    type_ok(mt.__tostring, 'function')
-    type_ok(mt.__index, 'table')
+    is_function(mt.__gc)
+    is_function(mt.__tostring)
+    is_table(mt.__index)
 
     if has_meta53 then
-        is(mt.__name, 'FILE*')
+        equals(mt.__name, 'FILE*')
     else
-        is(mt.__name, nil)
+        is_nil(mt.__name)
     end
 
     if has_meta54 then
-        type_ok(mt.__close, 'function')
-        type_ok(mt.__index, 'table')
-        is(mt.close, nil)
-        is(mt.flush, nil)
-        is(mt.lines, nil)
-        is(mt.read, nil)
-        is(mt.seek, nil)
-        is(mt.setvbuf, nil)
-        is(mt.write, nil)
+        is_function(mt.__close)
+        is_table(mt.__index)
+        is_nil(mt.close)
+        is_nil(mt.flush)
+        is_nil(mt.lines)
+        is_nil(mt.read)
+        is_nil(mt.seek)
+        is_nil(mt.setvbuf)
+        is_nil(mt.write)
     else
-        is(mt.__close, nil)
-        is(mt.__index, mt)
-        type_ok(mt.close, 'function')
-        type_ok(mt.flush, 'function')
-        type_ok(mt.lines, 'function')
-        type_ok(mt.read, 'function')
-        type_ok(mt.seek, 'function')
-        type_ok(mt.setvbuf, 'function')
-        type_ok(mt.write, 'function')
+        is_nil(mt.__close)
+        equals(mt.__index, mt)
+        is_function(mt.close)
+        is_function(mt.flush)
+        is_function(mt.lines)
+        is_function(mt.read)
+        is_function(mt.seek)
+        is_function(mt.setvbuf)
+        is_function(mt.write)
     end
 
-    type_ok(mt.__index.close, 'function')
-    type_ok(mt.__index.flush, 'function')
-    type_ok(mt.__index.lines, 'function')
-    type_ok(mt.__index.read, 'function')
-    type_ok(mt.__index.seek, 'function')
-    type_ok(mt.__index.setvbuf, 'function')
-    type_ok(mt.__index.write, 'function')
+    is_function(mt.__index.close)
+    is_function(mt.__index.flush)
+    is_function(mt.__index.lines)
+    is_function(mt.__index.read)
+    is_function(mt.__index.seek)
+    is_function(mt.__index.setvbuf)
+    is_function(mt.__index.write)
 end
 
 do -- close
     local r, msg = io.close(io.stderr)
-    is(r, nil, "close (std)")
-    is(msg, "cannot close standard file")
+    is_nil(r, "close (std)")
+    equals(msg, "cannot close standard file")
 end
 
 do -- flush
-    is(io.flush(), true, "function flush")
+    is_true(io.flush(), "function flush")
 end
 
 do -- open
     os.remove('file-308.no')
     local f, msg = io.open("file-308.no")
-    is(f, nil, "function open")
-    is(msg, "file-308.no: No such file or directory")
+    is_nil(f, "function open")
+    equals(msg, "file-308.no: No such file or directory")
 
     os.remove('file-308.txt')
     f = io.open('file-308.txt', 'w')
     f:write("file with text\n")
     f:close()
     f = io.open('file-308.txt')
-    like(f, '^file %(0?[Xx]?%x+%)$', "function open")
+    matches(f, '^file %(0?[Xx]?%x+%)$', "function open")
 
-    is(io.close(f), true, "function close")
+    is_true(io.close(f), "function close")
 
-    error_like(function () io.close(f) end,
-               "^[^:]+:%d+: attempt to use a closed file",
-               "function close (closed)")
+    error_matches(function () io.close(f) end,
+            "^[^:]+:%d+: attempt to use a closed file",
+            "function close (closed)")
 
     if _VERSION == 'Lua 5.1' then
         todo("not with 5.1")
     end
-    error_like(function () io.open('file-308.txt', 'baz') end,
-               "^[^:]+:%d+: bad argument #2 to 'open' %(invalid mode%)",
-               "function open (bad mode)")
+    error_matches(function () io.open('file-308.txt', 'baz') end,
+            "^[^:]+:%d+: bad argument #2 to 'open' %(invalid mode%)",
+            "function open (bad mode)")
 end
 
 do -- type
-    is(io.type("not a file"), nil, "function type")
+    equals(io.type("not a file"), nil, "function type")
     local f = io.open('file-308.txt')
-    is(io.type(f), 'file')
-    like(tostring(f), '^file %(0?[Xx]?%x+%)$')
+    equals(io.type(f), 'file')
+    matches(tostring(f), '^file %(0?[Xx]?%x+%)$')
     io.close(f)
-    is(io.type(f), 'closed file')
-    is(tostring(f), 'file (closed)')
+    equals(io.type(f), 'closed file')
+    equals(tostring(f), 'file (closed)')
 end
 
 do -- input
-    is(io.stdin, io.input(), "function input")
-    is(io.stdin, io.input(nil))
+    equals(io.stdin, io.input(), "function input")
+    equals(io.stdin, io.input(nil))
     local f = io.stdin
-    like(io.input('file-308.txt'), '^file %(0?[Xx]?%x+%)$')
-    is(f, io.input(f))
+    matches(io.input('file-308.txt'), '^file %(0?[Xx]?%x+%)$')
+    equals(f, io.input(f))
 end
 
 do -- output
-    is(io.output(), io.stdout, "function output")
-    is(io.output(nil), io.stdout)
+    equals(io.output(), io.stdout, "function output")
+    equals(io.output(nil), io.stdout)
     local f = io.stdout
-    like(io.output('output.new'), '^file %(0?[Xx]?%x+%)$')
-    is(f, io.output(f))
+    matches(io.output('output.new'), '^file %(0?[Xx]?%x+%)$')
+    equals(f, io.output(f))
     os.remove('output.new')
 end
 
 do -- popen
     local r, f = pcall(io.popen, lua .. [[ -e "print 'standard output'"]])
     if r then
-        is(io.type(f), 'file', "popen (read)")
-        is(f:read(), "standard output")
-        is(io.close(f), true)
+        equals(io.type(f), 'file', "popen (read)")
+        equals(f:read(), "standard output")
+        is_true(io.close(f))
     else
         diag("io.popen not supported")
     end
 
     r, f = pcall(io.popen, lua .. [[ -e "for line in io.lines() do print((line:gsub('e', 'a'))) end"]], 'w')
     if r then
-        is(io.type(f), 'file', "popen (write)")
+        equals(io.type(f), 'file', "popen (write)")
         f:write("# hello\n") -- not tested : hallo
-        is(io.close(f), true)
+        is_true(io.close(f))
     else
         diag("io.popen not supported")
     end
@@ -188,17 +188,17 @@ end
 
 do -- lines
     for line in io.lines('file-308.txt') do
-        is(line, "file with text", "function lines(filename)")
+        equals(line, "file with text", "function lines(filename)")
     end
 
-    error_like(function () io.lines('file-308.no') end,
-               "No such file or directory",
-               "function lines(no filename)")
+    error_matches(function () io.lines('file-308.no') end,
+            "No such file or directory",
+            "function lines(no filename)")
 end
 
 do -- tmpfile
     local  f = io.tmpfile()
-    is(io.type(f), 'file', "function tmpfile")
+    equals(io.type(f), 'file', "function tmpfile")
     f:write("some text")
     f:close()
 end
@@ -210,57 +210,57 @@ end
 
 do -- :close
     local r, msg = io.stderr:close()
-    is(r, nil, "method close (std)")
-    is(msg, "cannot close standard file")
+    is_nil(r, "method close (std)")
+    equals(msg, "cannot close standard file")
 
     local f = io.open('file-308.txt')
-    is(f:close(), true, "method close")
+    is_true(f:close(), "method close")
 end
 
 do -- :flush
-    is(io.stderr:flush(), true, "method flush")
+    equals(io.stderr:flush(), true, "method flush")
 
     local f = io.open('file-308.txt')
     f:close()
-    error_like(function () f:flush() end,
-               "^[^:]+:%d+: attempt to use a closed file",
-               "method flush (closed)")
+    error_matches(function () f:flush() end,
+            "^[^:]+:%d+: attempt to use a closed file",
+            "method flush (closed)")
 end
 
 do -- :read & :write
     local f = io.open('file-308.txt')
     f:close()
-    error_like(function () f:read() end,
-               "^[^:]+:%d+: attempt to use a closed file",
-               "method read (closed)")
+    error_matches(function () f:read() end,
+            "^[^:]+:%d+: attempt to use a closed file",
+            "method read (closed)")
 
     f = io.open('file-308.txt')
     local s = f:read()
-    is(s:len(), 14, "method read")
-    is(s, "file with text")
+    equals(s:len(), 14, "method read")
+    equals(s, "file with text")
     s = f:read()
-    is(s, nil)
+    equals(s, nil)
     f:close()
 
     f = io.open('file-308.txt')
-    error_like(function () f:read('*z') end,
-               "^[^:]+:%d+: bad argument #1 to 'read' %(invalid %w+%)",
-               "method read (invalid)")
+    error_matches(function () f:read('*z') end,
+            "^[^:]+:%d+: bad argument #1 to 'read' %(invalid %w+%)",
+            "method read (invalid)")
     f:close()
 
     f = io.open('file-308.txt')
     local s1, s2 = f:read('*l', '*l')
-    is(s1:len(), 14, "method read *l")
-    is(s1, "file with text")
-    is(s2, nil)
+    equals(s1:len(), 14, "method read *l")
+    equals(s1, "file with text")
+    equals(s2, nil)
     f:close()
 
     if has_read52 then
         f = io.open('file-308.txt')
         s1, s2 = f:read('*L', '*L')
-        is(s1:len(), 15, "method read *L")
-        is(s1, "file with text\n")
-        is(s2, nil)
+        equals(s1:len(), 15, "method read *L")
+        equals(s1, "file with text\n")
+        equals(s2, nil)
         f:close()
     else
         diag("no read *L")
@@ -268,8 +268,8 @@ do -- :read & :write
 
     f = io.open('file-308.txt')
     local n1, n2 = f:read('*n', '*n')
-    is(n1, nil, "method read *n")
-    is(n2, nil)
+    equals(n1, nil, "method read *n")
+    equals(n2, nil)
     f:close()
 
     f = io.open('file-308.num', 'w')
@@ -280,13 +280,13 @@ do -- :read & :write
 
     f = io.open('file-308.num')
     n1, n2 = f:read('*n', '*n')
-    is(n1, 1, "method read *n")
-    is(n2, 255, "method read *n")
+    equals(n1, 1, "method read *n")
+    equals(n2, 255, "method read *n")
     local n = f:read('*n')
     if _VERSION < 'Lua 5.3' then
-        type_ok(n, 'number')
+        is_number(n)
     else
-        is(n, nil, "method read *n too long")
+        is_nil(n, "method read *n too long")
     end
     f:close()
 
@@ -294,39 +294,39 @@ do -- :read & :write
 
     f = io.open('file-308.txt')
     s = f:read('*a')
-    is(s:len(), 15, "method read *a")
-    is(s, "file with text\n")
+    equals(s:len(), 15, "method read *a")
+    equals(s, "file with text\n")
     f:close()
 
     if has_read53 then
         f = io.open('file-308.txt')
         s = f:read('a')
-        is(s:len(), 15, "method read a")
-        is(s, "file with text\n")
+        equals(s:len(), 15, "method read a")
+        equals(s, "file with text\n")
         f:close()
     else
         diag("* mandatory")
     end
 
     f = io.open('file-308.txt')
-    is(f:read(0), '', "method read number")
-    eq_array({f:read(5, 5, 15)}, {'file ', 'with ', "text\n"})
+    equals(f:read(0), '', "method read number")
+    array_equals({f:read(5, 5, 15)}, {'file ', 'with ', "text\n"})
     f:close()
 end
 
 do -- :lines
     local f = io.open('file-308.txt')
     for line in f:lines() do
-        is(line, "file with text", "method lines")
+        equals(line, "file with text", "method lines")
     end
-    is(io.type(f), 'file')
+    equals(io.type(f), 'file')
     f:close()
-    is(io.type(f), 'closed file')
+    equals(io.type(f), 'closed file')
 
     if has_lines52 then
         f = io.open('file-308.txt')
         for two_char in f:lines(2) do
-            is(two_char, "fi", "method lines (with read option)")
+            equals(two_char, "fi", "method lines (with read option)")
             break
         end
         f:close()
@@ -339,31 +339,31 @@ do -- :seek
     local f = io.open('file-308.txt')
     f:close()
 
-    error_like(function () f:seek('end', 0) end,
-               "^[^:]+:%d+: attempt to use a closed file",
-               "method seek (closed)")
+    error_matches(function () f:seek('end', 0) end,
+            "^[^:]+:%d+: attempt to use a closed file",
+            "method seek (closed)")
 
     f = io.open('file-308.txt')
-    error_like(function () f:seek('bad', 0) end,
-               "^[^:]+:%d+: bad argument #1 to 'seek' %(invalid option 'bad'%)",
-               "method seek (invalid)")
+    error_matches(function () f:seek('bad', 0) end,
+            "^[^:]+:%d+: bad argument #1 to 'seek' %(invalid option 'bad'%)",
+            "method seek (invalid)")
 
     f = io.open('file-308.bin', 'w')
     f:write('ABCDE')
     f:close()
     f = io.open('file-308.bin')
-    is(f:seek('end', 0), 5, "method seek")
+    equals(f:seek('end', 0), 5, "method seek")
     f:close()
     os.remove('file-308.bin') --clean up
 end
 
 do -- :setvbuf
     local  f = io.open('file-308.txt')
-     is(f:setvbuf('no'), true, "method setvbuf 'no'")
+    equals(f:setvbuf('no'), true, "method setvbuf 'no'")
 
-    is(f:setvbuf('full', 4096), true, "method setvbuf 'full'")
+    equals(f:setvbuf('full', 4096), true, "method setvbuf 'full'")
 
-    is(f:setvbuf('line', 132), true, "method setvbuf 'line'")
+    equals(f:setvbuf('line', 132), true, "method setvbuf 'line'")
     f:close()
 end
 
@@ -372,15 +372,15 @@ os.remove('file-308.txt') -- clean up
 do -- :write
     local  f = io.open('file-308.out', 'w')
     f:close()
-    error_like(function () f:write('end') end,
-               "^[^:]+:%d+: attempt to use a closed file",
-               "method write (closed)")
+    error_matches(function () f:write('end') end,
+            "^[^:]+:%d+: attempt to use a closed file",
+            "method write (closed)")
 
     f = io.open('file-308.out', 'w')
     if has_write51 then
-        is(f:write('end'), true, "method write")
+        equals(f:write('end'), true, "method write")
     else
-        is(f:write('end'), f, "method write")
+        equals(f:write('end'), f, "method write")
     end
     f:close()
 
diff --git a/test/lua-Harness-tests/309-os.t b/test/lua-Harness-tests/309-os.t
index a787b147..ff033bbf 100755
--- a/test/lua-Harness-tests/309-os.t
+++ b/test/lua-Harness-tests/309-os.t
@@ -2,7 +2,7 @@
 --
 -- lua-Harness : <https://fperrad.frama.io/lua-Harness/>
 --
--- Copyright (C) 2009-2020, Perrad Francois
+-- Copyright (C) 2009-2021, Perrad Francois
 --
 -- This code is licensed under the terms of the MIT/X11 license,
 -- like Lua itself.
@@ -40,91 +40,91 @@ plan'no_plan'
 
 do -- clock
     local clk = os.clock()
-    type_ok(clk, 'number', "function clock")
-    ok(clk <= os.clock())
+    is_number(clk, "function clock")
+    truthy(clk <= os.clock())
 end
 
 do -- date
     local d = os.date('!*t', 0)
-    is(d.year, 1970, "function date")
-    is(d.month, 1)
-    is(d.day, 1)
-    is(d.hour, 0)
-    is(d.min, 0)
-    is(d.sec, 0)
-    is(d.wday, 5)
-    is(d.yday, 1)
-    is(d.isdst, false)
+    equals(d.year, 1970, "function date")
+    equals(d.month, 1)
+    equals(d.day, 1)
+    equals(d.hour, 0)
+    equals(d.min, 0)
+    equals(d.sec, 0)
+    equals(d.wday, 5)
+    equals(d.yday, 1)
+    equals(d.isdst, false)
 
-    is(os.date('!%d/%m/%y %H:%M:%S', 0), '01/01/70 00:00:00', "function date")
+    equals(os.date('!%d/%m/%y %H:%M:%S', 0), '01/01/70 00:00:00', "function date")
 
-    like(os.date('%H:%M:%S'), '^%d%d:%d%d:%d%d', "function date")
+    matches(os.date('%H:%M:%S'), '^%d%d:%d%d:%d%d', "function date")
 
     if (_VERSION == 'Lua 5.1' and not jit) or luajit20 then
         todo("not with 5.1")
     end
-    is(os.date('%Oy', 0), '70')
+    equals(os.date('%Oy', 0), '70')
 
     if _VERSION == 'Lua 5.1' then
         todo("not with 5.1")
     end
-    error_like(function () os.date('%Ja', 0) end,
-               "^[^:]+:%d+: bad argument #1 to 'date' %(invalid conversion specifier '%%Ja'%)",
-               "function date (invalid)")
+    error_matches(function () os.date('%Ja', 0) end,
+            "^[^:]+:%d+: bad argument #1 to 'date' %(invalid conversion specifier '%%Ja'%)",
+            "function date (invalid)")
 end
 
 do -- difftime
-    is(os.difftime(1234, 1200), 34, "function difftime")
+    equals(os.difftime(1234, 1200), 34, "function difftime")
 end
 
 do -- execute
     if has_execute51 then
         local res = os.execute()
-        is(res, 1, "function execute -> shell is available")
+        equals(res, 1, "function execute -> shell is available")
 
-        ok(os.execute('__IMPROBABLE__') > 0, "function execute __IMPROBABLE__")
+        truthy(os.execute('__IMPROBABLE__') > 0, "function execute __IMPROBABLE__")
 
         local cmd = lua .. [[ -e "print '# hello from external Lua'"]]
-        is(os.execute(cmd), 0, "function execute")
+        equals(os.execute(cmd), 0, "function execute")
     else
         local res = os.execute()
-        is(res, true, "function execute -> shell is available")
+        is_true(res, "function execute -> shell is available")
 
         local r, s, n = os.execute('__IMPROBABLE__')
-        is(r, nil, "function execute __IMPROBABLE__")
-        is(s, 'exit')
-        type_ok(n, 'number')
+        is_nil(r, "function execute __IMPROBABLE__")
+        equals(s, 'exit')
+        is_number(n)
 
         local cmd = lua .. [[ -e "print '# hello from external Lua'"]]
         r, s, n = os.execute(cmd)
-        is(r, true, "function execute")
-        is(s, 'exit')
-        is(n, 0)
+        is_true(r, "function execute")
+        equals(s, 'exit')
+        equals(n, 0)
     end
 end
 
 do -- exit called with execute
     if has_execute51 then
         local cmd = lua .. [[ -e "print '# hello from external Lua'; os.exit(2)"]]
-        ok(os.execute(cmd) > 0, "function exit called with execute")
+        truthy(os.execute(cmd) > 0, "function exit called with execute")
     else
         local cmd = lua .. [[ -e "print '# hello from external Lua'; os.exit(2)"]]
         local r, s, n = os.execute(cmd)
-        is(r, nil, "function exit called with execute")
-        is(s, 'exit')
-        is(n, 2, "exit value")
+        is_nil(r, "function exit called with execute")
+        equals(s, 'exit')
+        equals(n, 2, "exit value")
 
         cmd = lua .. [[ -e "print '# hello from external Lua'; os.exit(false)"]]
         r, s, n = os.execute(cmd)
-        is(r, nil, "function exit called with execute")
-        is(s, 'exit')
-        is(n, 1, "exit value")
+        is_nil(r, "function exit called with execute")
+        equals(s, 'exit')
+        equals(n, 1, "exit value")
 
         cmd = lua .. [[ -e "print '# hello from external Lua'; os.exit(true, true)"]]
         r, s, n = os.execute(cmd)
-        is(r, true, "exit called with execute")
-        is(s, 'exit')
-        is(n, 0, "exit value")
+        is_true(r, "exit called with execute")
+        equals(s, 'exit')
+        equals(n, 0, "exit value")
     end
 end
 
@@ -132,16 +132,16 @@ do -- exit called with popen
     local cmd = lua .. [[ -e "print 'reached'; os.exit(); print 'not reached';"]]
     local res, f = pcall(io.popen, cmd)
     if res then
-        is(f:read'*l', 'reached', "exit called with popen")
-        is(f:read'*l', nil)
+        equals(f:read'*l', 'reached', "exit called with popen")
+        equals(f:read'*l', nil)
         if has_execute51 then
             local code = f:close()
-            is(code, true, "exit code")
+            is_true(code, "exit code")
         else
             local r, s, n = f:close()
-            is(r, true)
-            is(s, 'exit', "exit code")
-            is(n, 0, "exit value")
+            is_true(r)
+            equals(s, 'exit', "exit code")
+            equals(n, 0, "exit value")
         end
     else
         diag("io.popen not supported")
@@ -150,16 +150,16 @@ do -- exit called with popen
     cmd = lua .. [[ -e "print 'reached'; os.exit(3); print 'not reached';"]]
     res, f = pcall(io.popen, cmd)
     if res then
-        is(f:read'*l', 'reached', "exit called with popen")
-        is(f:read'*l', nil)
+        equals(f:read'*l', 'reached', "exit called with popen")
+        equals(f:read'*l', nil)
         if has_execute51 then
             local code = f:close()
-            is(code, true, "exit code")
+            is_true(code, "exit code")
         else
             local r, s, n = f:close()
-            is(r, nil)
-            is(s, 'exit', "exit code")
-            is(n, 3, "exit value")
+            is_nil(r)
+            equals(s, 'exit', "exit code")
+            equals(n, 3, "exit value")
         end
     else
         diag("io.popen not supported")
@@ -167,10 +167,10 @@ do -- exit called with popen
 end
 
 do -- getenv
-    is(os.getenv('__IMPROBABLE__'), nil, "function getenv")
+    equals(os.getenv('__IMPROBABLE__'), nil, "function getenv")
 
     local user = os.getenv('LOGNAME') or os.getenv('USERNAME')
-    type_ok(user, 'string', "function getenv")
+    is_string(user, "function getenv")
 end
 
 do -- remove
@@ -178,12 +178,12 @@ do -- remove
     f:write("file to remove")
     f:close()
     local r = os.remove("file-309.rm")
-    is(r, true, "function remove")
+    is_true(r, "function remove")
 
     local msg
     r, msg = os.remove('file-309.rm')
-    is(r, nil, "function remove")
-    like(msg, '^file%-309%.rm: No such file or directory')
+    is_nil(r, "function remove")
+    matches(msg, '^file%-309%.rm: No such file or directory')
 end
 
 do -- rename
@@ -192,25 +192,25 @@ do -- rename
     f:close()
     os.remove('file-309.new')
     local r = os.rename('file-309.old', 'file-309.new')
-    is(r, true, "function rename")
+    is_true(r, "function rename")
     os.remove('file-309.new') -- clean up
 
     local msg
     r, msg = os.rename('file-309.old', 'file-309.new')
-    is(r, nil, "function rename")
-    like(msg, 'No such file or directory')
+    is_nil(r, "function rename")
+    matches(msg, 'No such file or directory')
 end
 
 do -- setlocale
-    is(os.setlocale('C', 'all'), 'C', "function setlocale")
-    is(os.setlocale(), 'C')
-    is(os.setlocale('unk_loc', 'all'), nil, "function setlocale (unknown locale)")
+    equals(os.setlocale('C', 'all'), 'C', "function setlocale")
+    equals(os.setlocale(), 'C')
+    equals(os.setlocale('unk_loc', 'all'), nil, "function setlocale (unknown locale)")
 end
 
 do -- time
-    like(os.time(), '^%d+%.?%d*$', "function time")
-    like(os.time(nil), '^%d+%.?%d*$', "function time")
-    like(os.time({
+    matches(os.time(), '^%d+%.?%d*$', "function time")
+    matches(os.time(nil), '^%d+%.?%d*$', "function time")
+    matches(os.time({
         sec = 0,
         min = 0,
         hour = 0,
@@ -220,20 +220,20 @@ do -- time
         isdst = false,
     }), '^946%d+$', "function time")
 
-    error_like(function () os.time{} end,
-               "^[^:]+:%d+: field '%w+' missing in date table",
-               "function time (missing field)")
+    error_matches(function () os.time{} end,
+            "^[^:]+:%d+: field '%w+' missing in date table",
+            "function time (missing field)")
 
-    error_like(function () os.time({ day = 'bad', year = 'bad' }) end,
-               "^[^:]+:%d+: field '%w+'",
-               "function time (bad field)")
+    error_matches(function () os.time({ day = 'bad', year = 'bad' }) end,
+            "^[^:]+:%d+: field '%w+'",
+            "function time (bad field)")
 
     if _VERSION < 'Lua 5.3' then
         todo("only with integer")
     end
-    error_like(function () os.time({ day = 1.5, year = 1.5 }) end,
-               "^[^:]+:%d+: field '%w+' is not an integer",
-               "function time (not integer)")
+    error_matches(function () os.time({ day = 1.5, year = 1.5 }) end,
+            "^[^:]+:%d+: field '%w+' is not an integer",
+            "function time (not integer)")
 
     if string.packsize and string.packsize('l') == 8 then
         skip('64bit platforms')
@@ -241,7 +241,7 @@ do -- time
         if _VERSION < 'Lua 5.3' then
             todo"only with 5.3"
         end
-        error_like(function () os.time({
+        error_matches(function () os.time({
             sec = 0,
             min = 0,
             hour = 0,
@@ -250,15 +250,15 @@ do -- time
             year = 1000,
             isdst = false,
         }) end,
-                   "^[^:]+:%d+: time result cannot be represented in this installation",
-                   "function time (invalid)")
+                "^[^:]+:%d+: time result cannot be represented in this installation",
+                "function time (invalid)")
     end
 end
 
 do -- tmpname
     local fname = os.tmpname()
-    type_ok(fname, 'string', "function tmpname")
-    ok(fname ~= os.tmpname())
+    is_string(fname, "function tmpname")
+    truthy(fname ~= os.tmpname())
 end
 
 done_testing()
diff --git a/test/lua-Harness-tests/310-debug.t b/test/lua-Harness-tests/310-debug.t
index f78af03f..4ec970fb 100755
--- a/test/lua-Harness-tests/310-debug.t
+++ b/test/lua-Harness-tests/310-debug.t
@@ -2,7 +2,7 @@
 --
 -- lua-Harness : <https://fperrad.frama.io/lua-Harness/>
 --
--- Copyright (C) 2009-2020, Perrad Francois
+-- Copyright (C) 2009-2021, Perrad Francois
 --
 -- This code is licensed under the terms of the MIT/X11 license,
 -- like Lua itself.
@@ -52,57 +52,57 @@ plan'no_plan'
 
 -- getfenv
 if has_getfenv then
-    is(debug.getfenv(3.14), nil, "function getfenv")
+    equals(debug.getfenv(3.14), nil, "function getfenv")
     local function f () end
-    type_ok(debug.getfenv(f), 'table')
-    is(debug.getfenv(f), _G)
-    type_ok(debug.getfenv(print), 'table')
-    is(debug.getfenv(print), _G)
+    is_table(debug.getfenv(f))
+    equals(debug.getfenv(f), _G)
+    is_table(debug.getfenv(print))
+    equals(debug.getfenv(print), _G)
 
     local a = coroutine.create(function () return 1 end)
-    type_ok(debug.getfenv(a), 'table', "function getfenv (thread)")
-    is(debug.getfenv(a), _G)
+    is_table(debug.getfenv(a), "function getfenv (thread)")
+    equals(debug.getfenv(a), _G)
 else
-    is(debug.getfenv, nil, "no debug.getfenv (removed)")
+    is_nil(debug.getfenv, "no debug.getfenv (removed)")
 end
 
 do -- getinfo
-    local info = debug.getinfo(is)
-    type_ok(info, 'table', "function getinfo (function)")
-    is(info.func, is, " .func")
+    local info = debug.getinfo(equals)
+    is_table(info, "function getinfo (function)")
+    equals(info.func, equals, " .func")
 
-    info = debug.getinfo(is, 'L')
-    type_ok(info, 'table', "function getinfo (function, opt)")
-    type_ok(info.activelines, 'table')
+    info = debug.getinfo(equals, 'L')
+    is_table(info, "function getinfo (function, opt)")
+    is_table(info.activelines)
 
     info = debug.getinfo(1)
-    type_ok(info, 'table', "function getinfo (level)")
-    like(info.func, "^function: [0]?[Xx]?%x+", " .func")
+    is_table(info, "function getinfo (level)")
+    matches(info.func, "^function: [0]?[Xx]?%x+", " .func")
 
-    is(debug.getinfo(12), nil, "function getinfo (too depth)")
+    equals(debug.getinfo(12), nil, "function getinfo (too depth)")
 
-    error_like(function () debug.getinfo('bad') end,
-               "bad argument #1 to 'getinfo' %(.- expected",
-               "function getinfo (bad arg)")
+    error_matches(function () debug.getinfo('bad') end,
+            "bad argument #1 to 'getinfo' %(.- expected",
+            "function getinfo (bad arg)")
 
-    error_like(function () debug.getinfo(is, 'X') end,
-               "bad argument #2 to 'getinfo' %(invalid option%)",
-               "function getinfo (bad opt)")
+    error_matches(function () debug.getinfo(equals, 'X') end,
+            "bad argument #2 to 'getinfo' %(invalid option%)",
+            "function getinfo (bad opt)")
 end
 
 do -- getlocal
     local name, value = debug.getlocal(0, 1)
-    type_ok(name, 'string', "function getlocal (level)")
-    is(value, 0)
+    is_string(name, "function getlocal (level)")
+    equals(value, 0)
 
-    error_like(function () debug.getlocal(42, 1) end,
-               "bad argument #1 to 'getlocal' %(level out of range%)",
-               "function getlocal (out of range)")
+    error_matches(function () debug.getlocal(42, 1) end,
+            "bad argument #1 to 'getlocal' %(level out of range%)",
+            "function getlocal (out of range)")
 
     if has_getlocal52 then
-        name, value = debug.getlocal(like, 1)
-        type_ok(name, 'string', "function getlocal (func)")
-        is(value, nil)
+        name, value = debug.getlocal(matches, 1)
+        is_string(name, "function getlocal (func)")
+        equals(value, nil)
     else
         diag("no getlocal with function")
     end
@@ -110,31 +110,31 @@ end
 
 do -- getmetatable
     local t = {}
-    is(debug.getmetatable(t), nil, "function getmetatable")
+    equals(debug.getmetatable(t), nil, "function getmetatable")
     local t1 = {}
     debug.setmetatable(t, t1)
-    is(debug.getmetatable(t), t1)
+    equals(debug.getmetatable(t), t1)
 
     local a = true
-    is(debug.getmetatable(a), nil)
+    equals(debug.getmetatable(a), nil)
     debug.setmetatable(a, t1)
-    is(debug.getmetatable(t), t1)
+    equals(debug.getmetatable(t), t1)
 
     a = 3.14
-    is(debug.getmetatable(a), nil)
+    equals(debug.getmetatable(a), nil)
     debug.setmetatable(a, t1)
-    is(debug.getmetatable(t), t1)
+    equals(debug.getmetatable(t), t1)
 end
 
 do -- getregistry
     local reg = debug.getregistry()
-    type_ok(reg, 'table', "function getregistry")
-    type_ok(reg._LOADED, 'table')
+    is_table(reg, "function getregistry")
+    is_table(reg._LOADED)
 end
 
 do -- getupvalue
     local name = debug.getupvalue(plan, 1)
-    type_ok(name, 'string', "function getupvalue")
+    is_string(name, "function getupvalue")
 end
 
 do -- gethook
@@ -142,156 +142,156 @@ do -- gethook
     local hook, mask, count
     if has_gethook54 then
         hook = debug.gethook()
-        is(hook, nil, "function gethook")
+        equals(hook, nil, "function gethook")
     else
         hook, mask, count = debug.gethook()
-        is(hook, nil, "function gethook")
-        is(mask, '')
-        is(count, 0)
+        equals(hook, nil, "function gethook")
+        equals(mask, '')
+        equals(count, 0)
     end
     local function f () end
     debug.sethook(f, 'c', 42)
     hook , mask, count = debug.gethook()
-    is(hook, f, "function gethook")
-    is(mask, 'c')
-    is(count, 42)
+    equals(hook, f, "function gethook")
+    equals(mask, 'c')
+    equals(count, 42)
 
     local co = coroutine.create(function () print "thread" end)
     hook = debug.gethook(co)
     if jit then
-        type_ok(hook, 'function', "function gethook(thread)")
+        is_function(hook, "function gethook(thread)")
     else
-        is(hook, nil, "function gethook(thread)")
+        is_nil(hook, "function gethook(thread)")
     end
 end
 
 do -- setlocal
     local name = debug.setlocal(0, 1, 0)
-    type_ok(name, 'string', "function setlocal (level)")
+    is_string(name, "function setlocal (level)")
 
     name = debug.setlocal(0, 42, 0)
-    is(name, nil, "function setlocal (level)")
+    equals(name, nil, "function setlocal (level)")
 
-    error_like(function () debug.setlocal(42, 1, true) end,
-               "bad argument #1 to 'setlocal' %(level out of range%)",
-               "function setlocal (out of range)")
+    error_matches(function () debug.setlocal(42, 1, true) end,
+            "bad argument #1 to 'setlocal' %(level out of range%)",
+            "function setlocal (out of range)")
 end
 
 -- setcstacklimit
 if has_setcstacklimit then
-    type_ok(debug.setcstacklimit(200), 'number', "function setcstacklimit")
-    is(debug.setcstacklimit(1000), 200)
+    is_number(debug.setcstacklimit(200), "function setcstacklimit")
+    equals(debug.setcstacklimit(1000), 200)
 
-    error_like(function () debug.setcstacklimit('bad') end,
-               "^[^:]+:%d+: bad argument #1 to 'setcstacklimit' %(number expected, got string%)",
-               "function setcstacklimit (bad arg)")
+    error_matches(function () debug.setcstacklimit('bad') end,
+            "^[^:]+:%d+: bad argument #1 to 'setcstacklimit' %(number expected, got string%)",
+            "function setcstacklimit (bad arg)")
 else
-    is(debug.setcstacklimit, nil, "no debug.setcstacklimit")
+    is_nil(debug.setcstacklimit, "no debug.setcstacklimit")
 end
 
 -- setfenv
 if has_getfenv then
     local t = {}
     local function f () end
-    is(debug.setfenv(f, t), f, "function setfenv")
-    type_ok(debug.getfenv(f), 'table')
-    is(debug.getfenv(f), t)
-    is(debug.setfenv(print, t), print)
-    type_ok(debug.getfenv(print), 'table')
-    is(debug.getfenv(print), t)
+    equals(debug.setfenv(f, t), f, "function setfenv")
+    is_table(debug.getfenv(f))
+    equals(debug.getfenv(f), t)
+    equals(debug.setfenv(print, t), print)
+    is_table(debug.getfenv(print))
+    equals(debug.getfenv(print), t)
 
     t = {}
     local a = coroutine.create(function () return 1 end)
-    is(debug.setfenv(a, t), a, "function setfenv (thread)")
-    type_ok(debug.getfenv(a), 'table')
-    is(debug.getfenv(a), t)
+    equals(debug.setfenv(a, t), a, "function setfenv (thread)")
+    is_table(debug.getfenv(a))
+    equals(debug.getfenv(a), t)
 
-    error_like(function () t = {}; debug.setfenv(t, t) end,
-               "^[^:]+:%d+: 'setfenv' cannot change environment of given object",
-               "function setfenv (forbidden)")
+    error_matches(function () t = {}; debug.setfenv(t, t) end,
+            "^[^:]+:%d+: 'setfenv' cannot change environment of given object",
+            "function setfenv (forbidden)")
 else
-    is(debug.setfenv, nil, "no debug.setfenv (removed)")
+    is_nil(debug.setfenv, "no debug.setfenv (removed)")
 end
 
 do -- setmetatable
     local t = {}
     local t1 = {}
     if has_setmetatable52 then
-        is(debug.setmetatable(t, t1), t, "function setmetatable")
+        equals(debug.setmetatable(t, t1), t, "function setmetatable")
     else
-        is(debug.setmetatable(t, t1), true, "function setmetatable")
+        equals(debug.setmetatable(t, t1), true, "function setmetatable")
     end
-    is(getmetatable(t), t1)
+    equals(getmetatable(t), t1)
 
-    error_like(function () debug.setmetatable(t, true) end,
-               "^[^:]+:%d+: bad argument #2 to 'setmetatable' %(nil or table expected")
+    error_matches(function () debug.setmetatable(t, true) end,
+            "^[^:]+:%d+: bad argument #2 to 'setmetatable' %(nil or table expected")
 end
 
 do -- setupvalue
     local r, tb = pcall(require, 'Test.Builder')
     local value = r and tb:new() or {}
     local name = debug.setupvalue(plan, 1, value)
-    type_ok(name, 'string', "function setupvalue")
+    is_string(name, "function setupvalue")
 
     name = debug.setupvalue(plan, 42, true)
-    is(name, nil)
+    is_nil(name)
 end
 
 -- getuservalue / setuservalue
 if has_getuservalue54 then
     local u = io.tmpfile()      -- lua_newuserdatauv(L, sizeof(LStream), 0);
-    is(debug.getuservalue(u, 0), nil, "function getuservalue")
-    is(debug.getuservalue(true), nil)
+    equals(debug.getuservalue(u, 0), nil, "function getuservalue")
+    equals(debug.getuservalue(true), nil)
 
-    error_like(function () debug.getuservalue(u, 'foo') end,
-               "^[^:]+:%d+: bad argument #2 to 'getuservalue' %(number expected, got string%)")
+    error_matches(function () debug.getuservalue(u, 'foo') end,
+            "^[^:]+:%d+: bad argument #2 to 'getuservalue' %(number expected, got string%)")
 
     local data = {}
-    is(debug.setuservalue(u, data, 42), nil, "function setuservalue")
+    equals(debug.setuservalue(u, data, 42), nil, "function setuservalue")
 
-    error_like(function () debug.setuservalue({}, data) end,
-               "^[^:]+:%d+: bad argument #1 to 'setuservalue' %(userdata expected, got table%)")
+    error_matches(function () debug.setuservalue({}, data) end,
+            "^[^:]+:%d+: bad argument #1 to 'setuservalue' %(userdata expected, got table%)")
 
-    error_like(function () debug.setuservalue(u, data, 'foo') end,
-               "^[^:]+:%d+: bad argument #3 to 'setuservalue' %(number expected, got string%)")
+    error_matches(function () debug.setuservalue(u, data, 'foo') end,
+            "^[^:]+:%d+: bad argument #3 to 'setuservalue' %(number expected, got string%)")
 elseif has_getuservalue then
     local u = io.tmpfile()
     local old = debug.getuservalue(u)
     if jit then
-        type_ok(old, 'table', "function getuservalue")
+        is_table(old, "function getuservalue")
     else
-        is(old, nil, "function getuservalue")
+        is_nil(old, "function getuservalue")
     end
-    is(debug.getuservalue(true), nil)
+    equals(debug.getuservalue(true), nil)
 
     local data = {}
     local r = debug.setuservalue(u, data)
-    is(r, u, "function setuservalue")
-    is(debug.getuservalue(u), data)
+    equals(r, u, "function setuservalue")
+    equals(debug.getuservalue(u), data)
     r = debug.setuservalue(u, old)
-    is(debug.getuservalue(u), old)
+    equals(debug.getuservalue(u), old)
 
-    error_like(function () debug.setuservalue({}, data) end,
-               "^[^:]+:%d+: bad argument #1 to 'setuservalue' %(userdata expected, got table%)")
+    error_matches(function () debug.setuservalue({}, data) end,
+            "^[^:]+:%d+: bad argument #1 to 'setuservalue' %(userdata expected, got table%)")
 else
-    is(debug.getuservalue, nil, "no getuservalue")
-    is(debug.setuservalue, nil, "no setuservalue")
+    is_nil(debug.getuservalue, "no getuservalue")
+    is_nil(debug.setuservalue, "no setuservalue")
 end
 
 do -- traceback
-    like(debug.traceback(), "^stack traceback:\n", "function traceback")
+    matches(debug.traceback(), "^stack traceback:\n", "function traceback")
 
-    like(debug.traceback("message\n"), "^message\n\nstack traceback:\n", "function traceback with message")
+    matches(debug.traceback("message\n"), "^message\n\nstack traceback:\n", "function traceback with message")
 
-    like(debug.traceback(false), "false", "function traceback")
+    matches(debug.traceback(false), "false", "function traceback")
 end
 
 -- upvalueid
 if has_upvalueid then
     local id = debug.upvalueid(plan, 1)
-    type_ok(id, 'userdata', "function upvalueid")
+    is_userdata(id, "function upvalueid")
 else
-    is(debug.upvalueid, nil, "no upvalueid")
+    is_nil(debug.upvalueid, "no upvalueid")
 end
 
 -- upvaluejoin
@@ -299,17 +299,17 @@ if has_upvaluejoin and jit then
     diag("jit upvaluejoin")
     -- TODO
 elseif has_upvaluejoin then
-    debug.upvaluejoin(pass, 1, fail, 1)
+    debug.upvaluejoin(passes, 1, fails, 1)
 
-    error_like(function () debug.upvaluejoin(true, 1, nil, 1) end,
-               "bad argument #1 to 'upvaluejoin' %(function expected, got boolean%)",
-               "function upvaluejoin (bad arg)")
+    error_matches(function () debug.upvaluejoin(true, 1, nil, 1) end,
+            "bad argument #1 to 'upvaluejoin' %(function expected, got boolean%)",
+            "function upvaluejoin (bad arg)")
 
-    error_like(function () debug.upvaluejoin(pass, 1, true, 1) end,
-               "bad argument #3 to 'upvaluejoin' %(function expected, got boolean%)",
-               "function upvaluejoin (bad arg)")
+    error_matches(function () debug.upvaluejoin(passes, 1, true, 1) end,
+            "bad argument #3 to 'upvaluejoin' %(function expected, got boolean%)",
+            "function upvaluejoin (bad arg)")
 else
-    is(debug.upvaluejoin, nil, "no upvaluejoin")
+    is_nil(debug.upvaluejoin, "no upvaluejoin")
 end
 
 done_testing()
diff --git a/test/lua-Harness-tests/311-bit32.t b/test/lua-Harness-tests/311-bit32.t
index 7023906e..b8ccb7ea 100755
--- a/test/lua-Harness-tests/311-bit32.t
+++ b/test/lua-Harness-tests/311-bit32.t
@@ -2,7 +2,7 @@
 --
 -- lua-Harness : <https://fperrad.frama.io/lua-Harness/>
 --
--- Copyright (C) 2010-2018, Perrad Francois
+-- Copyright (C) 2010-2021, Perrad Francois
 --
 -- This code is licensed under the terms of the MIT/X11 license,
 -- like Lua itself.
@@ -35,88 +35,88 @@ local has_bit32 = _VERSION == 'Lua 5.2' or profile.compat52 or profile.has_bit32
 
 if not bit32 then
     plan(1)
-    nok(has_bit32, "no has_bit32")
+    falsy(has_bit32, "no has_bit32")
     os.exit(0)
 end
 
 plan(20)
 
 do -- arshift
-    is(bit32.arshift(0x06, 1), 0x03, "function arshift")
-    is(bit32.arshift(-3, 1), bit32.arshift(-6, 2), "function arshift")
+    equals(bit32.arshift(0x06, 1), 0x03, "function arshift")
+    equals(bit32.arshift(-3, 1), bit32.arshift(-6, 2), "function arshift")
 end
 
 do -- band
-    is(bit32.band(0x01, 0x03, 0x07), 0x01, "function band")
+    equals(bit32.band(0x01, 0x03, 0x07), 0x01, "function band")
 end
 
 do -- bnot
     if string.pack and #string.pack('n', 0) == 4 then
-        is(bit32.bnot(0x03), (-1 - 0x03), "function bnot")
+        equals(bit32.bnot(0x03), (-1 - 0x03), "function bnot")
     else
-        is(bit32.bnot(0x03), (-1 - 0x03) % 2^32, "function bnot")
+        equals(bit32.bnot(0x03), (-1 - 0x03) % 2^32, "function bnot")
     end
 end
 
 do -- bor
-    is(bit32.bor(0x01, 0x03, 0x07), 0x07, "function bor")
+    equals(bit32.bor(0x01, 0x03, 0x07), 0x07, "function bor")
 end
 
 do -- btest
-    is(bit32.btest(0x01), true, "function btest")
-    is(bit32.btest(0x00), false, "function btest")
+    equals(bit32.btest(0x01), true, "function btest")
+    equals(bit32.btest(0x00), false, "function btest")
 end
 
 do -- bxor
-    is(bit32.bxor(0x01, 0x03, 0x07), 0x05, "function bxor")
+    equals(bit32.bxor(0x01, 0x03, 0x07), 0x05, "function bxor")
 end
 
 do -- extract
-    is(bit32.extract(0xFFFF, 3, 3), 0x07, "function extract")
+    equals(bit32.extract(0xFFFF, 3, 3), 0x07, "function extract")
 
-    error_like(function () bit32.extract(0xFFFF, 99) end,
-               "^[^:]+:%d+: trying to access non%-existent bits",
-               "function extract (non-existent bits)")
+    error_matches(function () bit32.extract(0xFFFF, 99) end,
+            "^[^:]+:%d+: trying to access non%-existent bits",
+            "function extract (non-existent bits)")
 
-    error_like(function () bit32.extract(0xFFFF, -3) end,
-               "^[^:]+:%d+: bad argument #2 to 'extract' %(field cannot be negative%)",
-               "function extract (negatif field)")
+    error_matches(function () bit32.extract(0xFFFF, -3) end,
+            "^[^:]+:%d+: bad argument #2 to 'extract' %(field cannot be negative%)",
+            "function extract (negatif field)")
 
-    error_like(function () bit32.extract(0xFFFF, 3, -3) end,
-               "^[^:]+:%d+: bad argument #3 to 'extract' %(width must be positive%)",
-               "function extract (negative width)")
+    error_matches(function () bit32.extract(0xFFFF, 3, -3) end,
+            "^[^:]+:%d+: bad argument #3 to 'extract' %(width must be positive%)",
+            "function extract (negative width)")
 end
 
 do -- replace
-    is(bit32.replace(0x0000, 0xFFFF, 3, 3), 0x38, "function replace")
+    equals(bit32.replace(0x0000, 0xFFFF, 3, 3), 0x38, "function replace")
 
-    error_like(function () bit32.replace(0x0000, 0xFFFF, 99) end,
-               "^[^:]+:%d+: trying to access non%-existent bits",
-               "function replace (non-existent bits)")
+    error_matches(function () bit32.replace(0x0000, 0xFFFF, 99) end,
+            "^[^:]+:%d+: trying to access non%-existent bits",
+            "function replace (non-existent bits)")
 
-    error_like(function () bit32.replace(0x0000, 0xFFFF, -3) end,
-               "^[^:]+:%d+: bad argument #3 to 'replace' %(field cannot be negative%)",
-               "function replace (negatif field)")
+    error_matches(function () bit32.replace(0x0000, 0xFFFF, -3) end,
+            "^[^:]+:%d+: bad argument #3 to 'replace' %(field cannot be negative%)",
+            "function replace (negatif field)")
 
-    error_like(function () bit32.replace(0x0000, 0xFFFF, 3, -3) end,
-               "^[^:]+:%d+: bad argument #4 to 'replace' %(width must be positive%)",
-               "function replace (negative width)")
+    error_matches(function () bit32.replace(0x0000, 0xFFFF, 3, -3) end,
+            "^[^:]+:%d+: bad argument #4 to 'replace' %(width must be positive%)",
+            "function replace (negative width)")
 end
 
 do -- lrotate
-    is(bit32.lrotate(0x03, 2), 0x0C, "function lrotate")
+    equals(bit32.lrotate(0x03, 2), 0x0C, "function lrotate")
 end
 
 do -- lshift
-    is(bit32.lshift(0x03, 2), 0x0C, "function lshift")
+    equals(bit32.lshift(0x03, 2), 0x0C, "function lshift")
 end
 
 do -- rrotate
-    is(bit32.rrotate(0x06, 1), 0x03, "function rrotate")
+    equals(bit32.rrotate(0x06, 1), 0x03, "function rrotate")
 end
 
 do -- rshift
-    is(bit32.rshift(0x06, 1), 0x03, "function rshift")
+    equals(bit32.rshift(0x06, 1), 0x03, "function rshift")
 end
 
 -- Local Variables:
diff --git a/test/lua-Harness-tests/314-regex.t b/test/lua-Harness-tests/314-regex.t
index 58cdb66e..56883bd4 100755
--- a/test/lua-Harness-tests/314-regex.t
+++ b/test/lua-Harness-tests/314-regex.t
@@ -2,7 +2,7 @@
 --
 -- lua-Harness : <https://fperrad.frama.io/lua-Harness/>
 --
--- Copyright (C) 2009-2018, Perrad Francois
+-- Copyright (C) 2009-2021, Perrad Francois
 --
 -- This code is licensed under the terms of the MIT/X11 license,
 -- like Lua itself.
@@ -198,14 +198,14 @@ for _, filename in ipairs(test_files) do
             end
             if result:sub(1, 1) == '/' then
                 pattern = result:sub(2, result:len() - 1)
-                error_like(compiled, pattern, desc)
+                error_matches(compiled, pattern, desc)
             else
                 local r, out
                 r, msg = pcall(function () out = compiled() end)
                 if r then
-                    is(out, result, desc)
+                    equals(out, result, desc)
                 else
-                    fail(desc)
+                    fails(desc)
                     diag(msg)
                 end
             end
diff --git a/test/lua-Harness-tests/320-stdin.t b/test/lua-Harness-tests/320-stdin.t
index 4828285d..09f92c1b 100755
--- a/test/lua-Harness-tests/320-stdin.t
+++ b/test/lua-Harness-tests/320-stdin.t
@@ -2,7 +2,7 @@
 --
 -- lua-Harness : <https://fperrad.frama.io/lua-Harness/>
 --
--- Copyright (C) 2009-2018, Perrad Francois
+-- Copyright (C) 2009-2021, Perrad Francois
 --
 -- This code is licensed under the terms of the MIT/X11 license,
 -- like Lua itself.
@@ -49,7 +49,7 @@ end
 
     local cmd = lua .. [[ -e "dofile(); n = norm(3.4, 1.0); print(twice(n))" < lib-320.lua]]
     f = io.popen(cmd)
-    like(f:read'*l', '^7%.088', "function dofile (stdin)")
+    matches(f:read'*l', '^7%.088', "function dofile (stdin)")
     f:close()
 
     os.remove('lib-320.lua') -- clean up
@@ -66,8 +66,8 @@ end
 
     local cmd = lua .. [[ -e "f = loadfile(); print(foo); f(); print(foo('ok'))" < foo-320.lua]]
     f = io.popen(cmd)
-    is(f:read'*l', 'nil', "function loadfile (stdin)")
-    is(f:read'*l', 'ok')
+    equals(f:read'*l', 'nil', "function loadfile (stdin)")
+    equals(f:read'*l', 'ok')
     f:close()
 
     os.remove('foo-320.lua') -- clean up
@@ -80,15 +80,15 @@ do
 
     local cmd = lua .. [[ -e "print(io.read'*l'); print(io.read'*l'); print(io.type(io.stdin))" < file-320.txt]]
     f = io.popen(cmd)
-    is(f:read'*l', 'file with text', "function io.read *l")
-    is(f:read'*l', 'nil')
-    is(f:read'*l', 'file')
+    equals(f:read'*l', 'file with text', "function io.read *l")
+    equals(f:read'*l', 'nil')
+    equals(f:read'*l', 'file')
     f:close()
 
     cmd = lua .. [[ -e "for line in io.lines() do print(line) end" < file-320.txt]]
     f = io.popen(cmd)
-    is(f:read'*l', 'file with text', "function io.lines")
-    is(f:read'*l', nil)
+    equals(f:read'*l', 'file with text', "function io.lines")
+    equals(f:read'*l', nil)
     f:close()
 
     os.remove('file-320.txt') -- clean up
@@ -102,8 +102,8 @@ do
 
     local cmd = lua .. [[ -e "while true do local n1, n2, n3 = io.read('*number', '*number', '*number'); if not n1 then break end; print(math.max(n1, n2, n3)) end" < number-320.txt]]
     f = io.popen(cmd)
-    like(f:read'*l', '15000%.?', "function io:read *number")
-    is(f:read'*l', '1000001')
+    matches(f:read'*l', '15000%.?', "function io:read *number")
+    equals(f:read'*l', '1000001')
     f:close()
 
     os.remove('number-320.txt') -- clean up
@@ -118,8 +118,8 @@ do
 
     local cmd = lua .. [[ -e "debug.debug()" < dbg-320.txt]]
     f = io.popen(cmd)
-    is(f:read'*l', 'ok', "function debug.debug")
-    is(f:read'*l', nil)
+    equals(f:read'*l', 'ok', "function debug.debug")
+    equals(f:read'*l', nil)
     f:close()
 
     os.remove('dbg-320.txt') -- clean up
diff --git a/test/lua-Harness-tests/401-bitop.t b/test/lua-Harness-tests/401-bitop.t
index f95aebf3..e454420e 100755
--- a/test/lua-Harness-tests/401-bitop.t
+++ b/test/lua-Harness-tests/401-bitop.t
@@ -2,7 +2,7 @@
 --
 -- lua-Harness : <https://fperrad.frama.io/lua-Harness/>
 --
--- Copyright (C) 2018, Perrad Francois
+-- Copyright (C) 2018-2021, Perrad Francois
 --
 -- This code is licensed under the terms of the MIT/X11 license,
 -- like Lua itself.
@@ -32,70 +32,70 @@ end
 
 plan(29)
 
-is(package.loaded.bit, _G.bit, "package.loaded")
-is(require'bit', bit, "require")
+equals(package.loaded.bit, _G.bit, "package.loaded")
+equals(require'bit', bit, "require")
 
 do -- arshift
-    is(bit.arshift(256, 8), 1, "function arshift")
-    is(bit.arshift(-256, 8), -1)
+    equals(bit.arshift(256, 8), 1, "function arshift")
+    equals(bit.arshift(-256, 8), -1)
 end
 
 do -- band
-    is(bit.band(0x12345678, 0xff), 0x00000078, "function band")
+    equals(bit.band(0x12345678, 0xff), 0x00000078, "function band")
 end
 
 do -- bnot
-    is(bit.bnot(0), -1, "function bnot")
-    is(bit.bnot(-1), 0)
-    is(bit.bnot(0xffffffff), 0)
+    equals(bit.bnot(0), -1, "function bnot")
+    equals(bit.bnot(-1), 0)
+    equals(bit.bnot(0xffffffff), 0)
 end
 
 do -- bor
-    is(bit.bor(1, 2, 4, 8), 15, "function bor")
+    equals(bit.bor(1, 2, 4, 8), 15, "function bor")
 end
 
 do -- bswap
-    is(bit.bswap(0x12345678), 0x78563412, "function bswap")
-    is(bit.bswap(0x78563412), 0x12345678)
+    equals(bit.bswap(0x12345678), 0x78563412, "function bswap")
+    equals(bit.bswap(0x78563412), 0x12345678)
 end
 
 do -- bxor
-    is(bit.bxor(0xa5a5f0f0, 0xaa55ff00), 0x0ff00ff0, "function bxor")
+    equals(bit.bxor(0xa5a5f0f0, 0xaa55ff00), 0x0ff00ff0, "function bxor")
 end
 
 do -- lshift
-    is(bit.lshift(1, 0), 1, "function lshift")
-    is(bit.lshift(1, 8), 256)
-    is(bit.lshift(1, 40), 256)
-    is(bit.lshift(0x87654321, 12), 0x54321000)
+    equals(bit.lshift(1, 0), 1, "function lshift")
+    equals(bit.lshift(1, 8), 256)
+    equals(bit.lshift(1, 40), 256)
+    equals(bit.lshift(0x87654321, 12), 0x54321000)
 end
 
 do -- rol
-    is(bit.rol(0x12345678, 12), 0x45678123, "function rol")
+    equals(bit.rol(0x12345678, 12), 0x45678123, "function rol")
 end
 
 do -- ror
-    is(bit.ror(0x12345678, 12), 0x67812345, "function ror")
+    equals(bit.ror(0x12345678, 12), 0x67812345, "function ror")
 end
 
 do -- rshift
-    is(bit.rshift(256, 8), 1, "function rshift")
-    is(bit.rshift(-256, 8), 16777215)
-    is(bit.rshift(0x87654321, 12), 0x00087654)
+    equals(bit.rshift(256, 8), 1, "function rshift")
+    equals(bit.rshift(-256, 8), 16777215)
+    equals(bit.rshift(0x87654321, 12), 0x00087654)
 end
 
 do -- tobit
-    is(bit.tobit(0xffffffff + 1), 0, "function tobit")
-    is(bit.tobit(2^40 + 1234), 1234)
+    equals(bit.tobit(0xffffffff + 1), 0, "function tobit")
+    equals(bit.tobit(2^40 + 1234), 1234)
 end
 
 do -- tohex
-    is(bit.tohex(1), '00000001', "function tohex")
-    is(bit.tohex(-1), 'ffffffff')
-    is(bit.tohex(0xffffffff), 'ffffffff')
-    is(bit.tohex(-1, -8), 'FFFFFFFF')
-    is(bit.tohex(0x21, 4), '0021')
-    is(bit.tohex(0x87654321, 4), '4321')
+    equals(bit.tohex(1), '00000001', "function tohex")
+    equals(bit.tohex(-1), 'ffffffff')
+    equals(bit.tohex(0xffffffff), 'ffffffff')
+    equals(bit.tohex(-1, -8), 'FFFFFFFF')
+    equals(bit.tohex(0x21, 4), '0021')
+    equals(bit.tohex(0x87654321, 4), '4321')
 end
 
 -- Local Variables:
diff --git a/test/lua-Harness-tests/402-ffi.t b/test/lua-Harness-tests/402-ffi.t
index a2e32a54..73507a61 100755
--- a/test/lua-Harness-tests/402-ffi.t
+++ b/test/lua-Harness-tests/402-ffi.t
@@ -2,7 +2,7 @@
 --
 -- lua-Harness : <https://fperrad.frama.io/lua-Harness/>
 --
--- Copyright (C) 2018, Perrad Francois
+-- Copyright (C) 2018-2021, Perrad Francois
 --
 -- This code is licensed under the terms of the MIT/X11 license,
 -- like Lua itself.
@@ -32,106 +32,106 @@ end
 
 if not pcall(require, 'ffi') then
     plan(2)
-    is(_G.ffi, nil, "no FFI")
-    is(package.loaded.ffi, nil)
+    is_nil(_G.ffi, "no FFI")
+    is_nil(package.loaded.ffi)
     os.exit(0)
 end
 
 plan(33)
 
-is(_G.ffi, nil, "ffi not loaded by default")
+is_nil(_G.ffi, "ffi not loaded by default")
 ffi = require'ffi'
-is(package.loaded.ffi, ffi, "package.loaded")
-is(require'ffi', ffi, "require")
+equals(package.loaded.ffi, ffi, "package.loaded")
+equals(require'ffi', ffi, "require")
 
 do -- C
-    type_ok(ffi.C, 'userdata', 'C')
+    is_userdata(ffi.C, 'C')
 end
 
 do -- abi
-    type_ok(ffi.abi('32bit'), 'boolean', "abi")
-    type_ok(ffi.abi('64bit'), 'boolean')
-    type_ok(ffi.abi('le'), 'boolean')
-    type_ok(ffi.abi('be'), 'boolean')
-    type_ok(ffi.abi('fpu'), 'boolean')
-    type_ok(ffi.abi('softfp'), 'boolean')
-    type_ok(ffi.abi('hardfp'), 'boolean')
-    type_ok(ffi.abi('eabi'), 'boolean')
-    type_ok(ffi.abi('win'), 'boolean')
-    is(ffi.abi('bad'), false)
-    is(ffi.abi(0), false)
-
-    error_like(function () ffi.abi(true) end,
-               "^[^:]+:%d+: bad argument #1 to 'abi' %(string expected, got boolean%)",
-               "function unpack missing size")
+    is_boolean(ffi.abi('32bit'), "abi")
+    is_boolean(ffi.abi('64bit'))
+    is_boolean(ffi.abi('le'))
+    is_boolean(ffi.abi('be'))
+    is_boolean(ffi.abi('fpu'))
+    is_boolean(ffi.abi('softfp'))
+    is_boolean(ffi.abi('hardfp'))
+    is_boolean(ffi.abi('eabi'))
+    is_boolean(ffi.abi('win'))
+    is_false(ffi.abi('bad'))
+    is_false(ffi.abi(0))
+
+    error_matches(function () ffi.abi(true) end,
+            "^[^:]+:%d+: bad argument #1 to 'abi' %(string expected, got boolean%)",
+            "function unpack missing size")
 end
 
 do -- alignof
-    type_ok(ffi.alignof, 'function', "alignof")
+    is_function(ffi.alignof, "alignof")
 end
 
 do -- arch
-    is(ffi.arch, jit.arch, "alias arch")
+    equals(ffi.arch, jit.arch, "alias arch")
 end
 
 do -- cast
-    type_ok(ffi.cast, 'function', "cast")
+    is_function(ffi.cast, "cast")
 end
 
 do -- cdef
-    type_ok(ffi.cdef, 'function', "cdef")
+    is_function(ffi.cdef, "cdef")
 end
 
 do -- copy
-    type_ok(ffi.copy, 'function', "copy")
+    is_function(ffi.copy, "copy")
 end
 
 do -- errno
-    type_ok(ffi.errno, 'function', "errno")
+    is_function(ffi.errno, "errno")
 end
 
 do -- fill
-    type_ok(ffi.fill, 'function', "fill")
+    is_function(ffi.fill, "fill")
 end
 
 do -- gc
-    type_ok(ffi.gc, 'function', "gc")
+    is_function(ffi.gc, "gc")
 end
 
 do -- istype
-    type_ok(ffi.istype, 'function', "istype")
+    is_function(ffi.istype, "istype")
 end
 
 do -- load
-    type_ok(ffi.load, 'function', "load")
+    is_function(ffi.load, "load")
 end
 
 do -- metatype
-    type_ok(ffi.metatype, 'function', "metatype")
+    is_function(ffi.metatype, "metatype")
 end
 
 do -- new
-    type_ok(ffi.new, 'function', "new")
+    is_function(ffi.new, "new")
 end
 
 do -- offsetof
-    type_ok(ffi.offsetof, 'function', "offsetof")
+    is_function(ffi.offsetof, "offsetof")
 end
 
 do -- os
-    is(ffi.os, jit.os, "alias os")
+    equals(ffi.os, jit.os, "alias os")
 end
 
 do -- sizeof
-    type_ok(ffi.sizeof, 'function', "sizeof")
+    is_function(ffi.sizeof, "sizeof")
 end
 
 do -- string
-    type_ok(ffi.string, 'function', "string")
+    is_function(ffi.string, "string")
 end
 
 do -- typeof
-    type_ok(ffi.typeof, 'function', "typeof")
+    is_function(ffi.typeof, "typeof")
 end
 
 -- Local Variables:
diff --git a/test/lua-Harness-tests/403-jit.t b/test/lua-Harness-tests/403-jit.t
index 0073c90d..306a7c44 100755
--- a/test/lua-Harness-tests/403-jit.t
+++ b/test/lua-Harness-tests/403-jit.t
@@ -2,7 +2,7 @@
 --
 -- lua-Harness : <https://fperrad.frama.io/lua-Harness/>
 --
--- Copyright (C) 2018-2020, Perrad Francois
+-- Copyright (C) 2018-2021, Perrad Francois
 --
 -- This code is licensed under the terms of the MIT/X11 license,
 -- like Lua itself.
@@ -39,118 +39,118 @@ local has_jit_util = not ujit and not jit.version:match'RaptorJIT'
 
 plan'no_plan'
 
-is(package.loaded.jit, _G.jit, "package.loaded")
-is(require'jit', jit, "require")
+equals(package.loaded.jit, _G.jit, "package.loaded")
+equals(require'jit', jit, "require")
 
 do -- arch
-    type_ok(jit.arch, 'string', "arch")
+    is_string(jit.arch, "arch")
 end
 
 do -- flush
-    type_ok(jit.flush, 'function', "flush")
+    is_function(jit.flush, 'function', "flush")
 end
 
 do -- off
     jit.off()
-    is(jit.status(), false, "off")
+    is_false(jit.status(), "off")
 end
 
 -- on
 if compiled_with_jit then
     jit.on()
-    is(jit.status(), true, "on")
+    is_true(jit.status(), "on")
 else
-    error_like(function () jit.on() end,
-               "^[^:]+:%d+: JIT compiler permanently disabled by build option",
-               "no jit.on")
+    error_matches(function () jit.on() end,
+            "^[^:]+:%d+: JIT compiler permanently disabled by build option",
+            "no jit.on")
 end
 
 -- opt
 if has_jit_opt then
-    type_ok(jit.opt, 'table', "opt.*")
-    type_ok(jit.opt.start, 'function', "opt.start")
+    is_table(jit.opt, "opt.*")
+    is_function(jit.opt.start, 'function', "opt.start")
 else
-    is(jit.opt, nil, "no jit.opt")
+    is_nil(jit.opt, "no jit.opt")
 end
 
 do -- os
-    type_ok(jit.os, 'string', "os")
+    is_string(jit.os, "os")
 end
 
 -- prngstate
 if profile.openresty then
-    type_ok(jit.prngstate(), 'table', "prngstate")
+    is_table(jit.prngstate(), "prngstate")
     local s1 = { 1, 2, 3, 4, 5, 6, 7, 8}
-    type_ok(jit.prngstate(s1), 'table')
+    is_table(jit.prngstate(s1))
     local s2 = { 8, 7, 6, 5, 4, 3, 2, 1}
-    eq_array(jit.prngstate(s2), s1)
-    eq_array(jit.prngstate(), s2)
+    array_equals(jit.prngstate(s2), s1)
+    array_equals(jit.prngstate(), s2)
 
-    type_ok(jit.prngstate(32), 'table', "backward compat")
-    eq_array(jit.prngstate(5617), { 32, 0, 0, 0, 0, 0, 0, 0 })
-    eq_array(jit.prngstate(), { 5617, 0, 0, 0, 0, 0, 0, 0 })
+    is_table(jit.prngstate(32), 'table', "backward compat")
+    array_equals(jit.prngstate(5617), { 32, 0, 0, 0, 0, 0, 0, 0 })
+    array_equals(jit.prngstate(), { 5617, 0, 0, 0, 0, 0, 0, 0 })
 
-    error_like(function () jit.prngstate(-1) end,
-               "^[^:]+:%d+: bad argument #1 to 'prngstate' %(PRNG state must be an array with up to 8 integers or an integer%)")
+    error_matches(function () jit.prngstate(-1) end,
+            "^[^:]+:%d+: bad argument #1 to 'prngstate' %(PRNG state must be an array with up to 8 integers or an integer%)")
 
-    error_like(function () jit.prngstate(false) end,
-               "^[^:]+:%d+: bad argument #1 to 'prngstate' %(table expected, got boolean%)")
+    error_matches(function () jit.prngstate(false) end,
+            "^[^:]+:%d+: bad argument #1 to 'prngstate' %(table expected, got boolean%)")
 elseif jit.version:match'moonjit' then
-    is(jit.prngstate(), 0, "prngstate")
+    equals(jit.prngstate(), 0, "prngstate")
 else
-    is(jit.prngstate, nil, "no jit.prngstate");
+    is_nil(jit.prngstate, "no jit.prngstate");
 end
 
 -- security
 if has_jit_security then
-    type_ok(jit.security, 'function', "security")
-    type_ok(jit.security('prng'), 'number', "prng")
-    type_ok(jit.security('strhash'), 'number', "strhash")
-    type_ok(jit.security('strid'), 'number', "stdid")
-    type_ok(jit.security('mcode'), 'number', "mcode")
-
-    error_like(function () jit.security('foo') end,
-               "^[^:]+:%d+: bad argument #1 to 'security' %(invalid option 'foo'%)")
+    is_function(jit.security, "security")
+    is_number(jit.security('prng'), "prng")
+    is_number(jit.security('strhash'), "strhash")
+    is_number(jit.security('strid'), "stdid")
+    is_number(jit.security('mcode'), "mcode")
+
+    error_matches(function () jit.security('foo') end,
+            "^[^:]+:%d+: bad argument #1 to 'security' %(invalid option 'foo'%)")
 else
-    is(jit.security, nil, "no jit.security")
+    is_nil(jit.security, "no jit.security")
 end
 
 do -- status
     local status = { jit.status() }
-    type_ok(status[1], 'boolean', "status")
+    is_boolean(status[1], "status")
     if compiled_with_jit then
         for i = 2, #status do
-            type_ok(status[i], 'string', status[i])
+            is_string(status[i], status[i])
         end
     else
-        is(#status, 1)
+        equals(#status, 1)
     end
 end
 
 -- util
 if has_jit_util then
     local jutil = require'jit.util'
-    type_ok(jutil, 'table', "util")
-    is(package.loaded['jit.util'], jutil)
+    is_table(jutil, "util")
+    equals(package.loaded['jit.util'], jutil)
 
     if luajit20 then
-        is(jit.util, jutil, "util inside jit")
+        equals(jit.util, jutil, "util inside jit")
     else
-        is(jit.util, nil, "no util inside jit")
+        is_nil(jit.util, "no util inside jit")
     end
 else
     local r = pcall(require, 'jit.util')
-    is(r, false, "no jit.util")
+    is_false(r, "no jit.util")
 end
 
 do -- version
-    type_ok(jit.version, 'string', "version")
-    like(jit.version, '^%w+ %d%.%d%.%d')
+    is_string(jit.version, "version")
+    matches(jit.version, '^%w+ %d%.%d%.%d')
 end
 
 do -- version_num
-    type_ok(jit.version_num, 'number', "version_num")
-    like(string.format("%06d", jit.version_num), '^0[12]0[012]%d%d$')
+    is_number(jit.version_num, "version_num")
+    matches(string.format("%06d", jit.version_num), '^0[12]0[012]%d%d$')
 end
 
 done_testing()
diff --git a/test/lua-Harness-tests/404-ext.t b/test/lua-Harness-tests/404-ext.t
index a799c750..afe1d5b5 100755
--- a/test/lua-Harness-tests/404-ext.t
+++ b/test/lua-Harness-tests/404-ext.t
@@ -2,7 +2,7 @@
 --
 -- lua-Harness : <https://fperrad.frama.io/lua-Harness/>
 --
--- Copyright (C) 2019-2020, Perrad Francois
+-- Copyright (C) 2019-2021, Perrad Francois
 --
 -- This code is licensed under the terms of the MIT/X11 license,
 -- like Lua itself.
@@ -36,124 +36,124 @@ plan'no_plan'
 
 do -- table.new
     local r, new = pcall(require, 'table.new')
-    is(r, true, 'table.new')
-    type_ok(new, 'function')
-    is(package.loaded['table.new'], new)
+    is_true(r, 'table.new')
+    is_function(new)
+    equals(package.loaded['table.new'], new)
 
-    type_ok(new(100, 0), 'table')
-    type_ok(new(0, 100), 'table')
-    type_ok(new(200, 200), 'table')
+    is_table(new(100, 0))
+    is_table(new(0, 100))
+    is_table(new(200, 200))
 
-    error_like(function () new(42) end,
-               "^[^:]+:%d+: bad argument #2 to 'new' %(number expected, got no value%)")
+    error_matches(function () new(42) end,
+            "^[^:]+:%d+: bad argument #2 to 'new' %(number expected, got no value%)")
 end
 
 do -- table.clear
     local r, clear = pcall(require, 'table.clear')
-    is(r, true, 'table.clear')
-    type_ok(clear, 'function')
-    is(package.loaded['table.clear'], clear)
+    is_true(r, 'table.clear')
+    is_function(clear)
+    equals(package.loaded['table.clear'], clear)
 
     local t = { 'foo', bar = 42 }
-    is(t[1], 'foo')
-    is(t.bar, 42)
+    equals(t[1], 'foo')
+    equals(t.bar, 42)
     clear(t)
-    is(t[1], nil)
-    is(t.bar, nil)
+    is_nil(t[1])
+    is_nil(t.bar)
 
-    error_like(function () clear(42) end,
-               "^[^:]+:%d+: bad argument #1 to 'clear' %(table expected, got number%)")
+    error_matches(function () clear(42) end,
+            "^[^:]+:%d+: bad argument #1 to 'clear' %(table expected, got number%)")
 end
 
 -- table.clone
 if profile.openresty then
     local r, clone = pcall(require, 'table.clone')
-    is(r, true, 'table.clone')
-    type_ok(clone, 'function')
-    is(package.loaded['table.clone'], clone)
+    is_true(r, 'table.clone')
+    is_function(clone)
+    equals(package.loaded['table.clone'], clone)
 
     local mt = {}
     local t = setmetatable({ 'foo', bar = 42 }, mt)
-    is(t[1], 'foo')
-    is(t.bar, 42)
+    equals(t[1], 'foo')
+    equals(t.bar, 42)
     local t2 = clone(t)
-    type_ok(t2, 'table')
-    isnt(t2, t)
-    is(getmetatable(t2), nil)
-    is(t2[1], 'foo')
-    is(t2.bar, 42)
-
-    error_like(function () clone(42) end,
-               "^[^:]+:%d+: bad argument #1 to 'clone' %(table expected, got number%)")
+    is_table(t2)
+    not_equals(t2, t)
+    is_nil(getmetatable(t2))
+    equals(t2[1], 'foo')
+    equals(t2.bar, 42)
+
+    error_matches(function () clone(42) end,
+            "^[^:]+:%d+: bad argument #1 to 'clone' %(table expected, got number%)")
 else
-    is(pcall(require, 'table.clone'), false, 'no table.clone')
+    is_false(pcall(require, 'table.clone'), 'no table.clone')
 end
 
 -- table.isarray
 if profile.openresty then
     local r, isarray = pcall(require, 'table.isarray')
-    is(r, true, 'table.isarray')
-    type_ok(isarray, 'function')
-    is(package.loaded['table.isarray'], isarray)
-
-    is(isarray({ [3] = 3, [5.3] = 4 }), false)
-    is(isarray({ [3] = 'a', [5] = true }), true)
-    is(isarray({ 'a', nil, true, 3.14 }), true)
-    is(isarray({}), true)
-    is(isarray({ ['1'] = 3, ['2'] = 4 }), false)
-    is(isarray({ ['dog'] = 3, ['cat'] = 4 }), false)
-    is(isarray({ 'dog', 'cat', true, ['bird'] = 3 }), false)
-
-    error_like(function () isarray(42) end,
-               "^[^:]+:%d+: bad argument #1 to 'isarray' %(table expected, got number%)")
+    is_true(r, 'table.isarray')
+    is_function(isarray)
+    equals(package.loaded['table.isarray'], isarray)
+
+    is_false(isarray({ [3] = 3, [5.3] = 4 }))
+    is_true(isarray({ [3] = 'a', [5] = true }))
+    is_true(isarray({ 'a', nil, true, 3.14 }))
+    is_true(isarray({}))
+    is_false(isarray({ ['1'] = 3, ['2'] = 4 }))
+    is_false(isarray({ ['dog'] = 3, ['cat'] = 4 }))
+    is_false(isarray({ 'dog', 'cat', true, ['bird'] = 3 }))
+
+    error_matches(function () isarray(42) end,
+            "^[^:]+:%d+: bad argument #1 to 'isarray' %(table expected, got number%)")
 else
-    is(pcall(require, 'table.isarray'), false, 'no table.isarray')
+    is_false(pcall(require, 'table.isarray'), 'no table.isarray')
 end
 
 -- table.isempty
 if profile.openresty then
     local r, isempty = pcall(require, 'table.isempty')
-    is(r, true, 'table.isempty')
-    type_ok(isempty, 'function')
-    is(package.loaded['table.isempty'], isempty)
-
-    is(isempty({}), true)
-    is(isempty({ nil }), true)
-    is(isempty({ dogs = nil }), true)
-    is(isempty({ 3.1 }), false)
-    is(isempty({ 'a', 'b' }), false)
-    is(isempty({ nil, false }), false)
-    is(isempty({ dogs = 3 }), false)
-    is(isempty({ dogs = 3, cats = 4 }), false)
-    is(isempty({ dogs = 3, 5 }), false)
-
-    error_like(function () isempty(42) end,
-               "^[^:]+:%d+: bad argument #1 to 'isempty' %(table expected, got number%)")
+    is_true(r, 'table.isempty')
+    is_function(isempty)
+    equals(package.loaded['table.isempty'], isempty)
+
+    is_true(isempty({}))
+    is_true(isempty({ nil }))
+    is_true(isempty({ dogs = nil }))
+    is_false(isempty({ 3.1 }))
+    is_false(isempty({ 'a', 'b' }))
+    is_false(isempty({ nil, false }))
+    is_false(isempty({ dogs = 3 }))
+    is_false(isempty({ dogs = 3, cats = 4 }))
+    is_false(isempty({ dogs = 3, 5 }))
+
+    error_matches(function () isempty(42) end,
+            "^[^:]+:%d+: bad argument #1 to 'isempty' %(table expected, got number%)")
 else
-    is(pcall(require, 'table.isempty'), false, 'no table.isempty')
+    is_false(pcall(require, 'table.isempty'), 'no table.isempty')
 end
 
 -- table.nkeys
 if profile.openresty then
     local r, nkeys = pcall(require, 'table.nkeys')
-    is(r, true, 'table.nkeys')
-    type_ok(nkeys, 'function')
-    is(package.loaded['table.nkeys'], nkeys)
-
-    is(nkeys({}), 0)
-    is(nkeys({ cats = 4 }), 1)
-    is(nkeys({ dogs = 3, cats = 4 }), 2)
-    is(nkeys({ dogs = nil, cats = 4 }), 1)
-    is(nkeys({ 'cats' }), 1)
-    is(nkeys({ 'dogs', 3, 'cats', 4 }), 4)
-    is(nkeys({ 'dogs', nil, 'cats', 4 }), 3)
-    is(nkeys({ cats = 4, 5, 6 }), 3)
-    is(nkeys({ nil, 'foo', dogs = 3, cats = 4 }), 3)
-
-    error_like(function () nkeys(42) end,
-               "^[^:]+:%d+: bad argument #1 to 'nkeys' %(table expected, got number%)")
+    is_true(r, 'table.nkeys')
+    is_function(nkeys)
+    equals(package.loaded['table.nkeys'], nkeys)
+
+    equals(nkeys({}), 0)
+    equals(nkeys({ cats = 4 }), 1)
+    equals(nkeys({ dogs = 3, cats = 4 }), 2)
+    equals(nkeys({ dogs = nil, cats = 4 }), 1)
+    equals(nkeys({ 'cats' }), 1)
+    equals(nkeys({ 'dogs', 3, 'cats', 4 }), 4)
+    equals(nkeys({ 'dogs', nil, 'cats', 4 }), 3)
+    equals(nkeys({ cats = 4, 5, 6 }), 3)
+    equals(nkeys({ nil, 'foo', dogs = 3, cats = 4 }), 3)
+
+    error_matches(function () nkeys(42) end,
+            "^[^:]+:%d+: bad argument #1 to 'nkeys' %(table expected, got number%)")
 else
-    is(pcall(require, 'table.nkeys'), false, 'no table.nkeys')
+    is_false(pcall(require, 'table.nkeys'), 'no table.nkeys')
 end
 
 -- thread.exdata
diff --git a/test/lua-Harness-tests/411-luajit.t.disabled b/test/lua-Harness-tests/411-luajit.t.disabled
index feb752eb..ad7e279e 100755
--- a/test/lua-Harness-tests/411-luajit.t.disabled
+++ b/test/lua-Harness-tests/411-luajit.t.disabled
@@ -2,7 +2,7 @@
 --
 -- lua-Harness : <https://fperrad.frama.io/lua-Harness/>
 --
--- Copyright (C) 2018-2020, Perrad Francois
+-- Copyright (C) 2018-2021, Perrad Francois
 --
 -- This code is licensed under the terms of the MIT/X11 license,
 -- like Lua itself.
@@ -44,162 +44,162 @@ local has_openresty_listing = profile.openresty or jit.version:match'moonjit'
 plan'no_plan'
 diag(lua)
 
-local f = io.open('hello-404.lua', 'w')
+local f = io.open('hello-411.lua', 'w')
 f:write([[
 print 'Hello World'
 ]])
 f:close()
 
-os.execute(lua .. " -b hello-404.lua hello-404.out")
-local cmd = lua .. " hello-404.out"
+os.execute(lua .. " -b hello-411.lua hello-411.out")
+local cmd = lua .. " hello-411.out"
 f = io.popen(cmd)
-is(f:read'*l', 'Hello World', "-b")
+equals(f:read'*l', 'Hello World', "-b")
 f:close()
 
-os.execute(lua .. " -bg hello-404.lua hello-404.out")
-cmd = lua .. " hello-404.out"
+os.execute(lua .. " -bg hello-411.lua hello-411.out")
+cmd = lua .. " hello-411.out"
 f = io.popen(cmd)
-is(f:read'*l', 'Hello World', "-bg")
+equals(f:read'*l', 'Hello World', "-bg")
 f:close()
 
-os.execute(lua .. " -be 'print[[Hello World]]' hello-404.out")
-cmd = lua .. " hello-404.out"
+os.execute(lua .. " -be 'print[[Hello World]]' hello-411.out")
+cmd = lua .. " hello-411.out"
 f = io.popen(cmd)
-is(f:read'*l', 'Hello World', "-be")
+equals(f:read'*l', 'Hello World', "-be")
 f:close()
 
-os.remove('hello-404.out') -- clean up
+os.remove('hello-411.out') -- clean up
 
 if has_jutil then
-    cmd = lua .. " -bl hello-404.lua"
+    cmd = lua .. " -bl hello-411.lua"
     f = io.popen(cmd)
-    like(f:read'*l', '^%-%- BYTECODE %-%- hello%-404%.lua', "-bl hello.lua")
+    matches(f:read'*l', '^%-%- BYTECODE %-%- hello%-411%.lua', "-bl hello.lua")
     if has_openresty_listing then
-        like(f:read'*l', '^KGC    0')
-        like(f:read'*l', '^KGC    1')
+        matches(f:read'*l', '^KGC    0')
+        matches(f:read'*l', '^KGC    1')
     end
-    like(f:read'*l', '^0001    %u[%u%d]+%s+')
-    like(f:read'*l', '^0002    %u[%u%d]+%s+')
-    like(f:read'*l', '^0003    %u[%u%d]+%s+')
+    matches(f:read'*l', '^0001    %u[%u%d]+%s+')
+    matches(f:read'*l', '^0002    %u[%u%d]+%s+')
+    matches(f:read'*l', '^0003    %u[%u%d]+%s+')
     f:close()
 
-    os.execute(lua .. " -bl hello-404.lua hello-404.txt")
-    f = io.open('hello-404.txt', 'r')
-    like(f:read'*l', '^%-%- BYTECODE %-%- hello%-404%.lua', "-bl hello.lua hello.txt")
+    os.execute(lua .. " -bl hello-411.lua hello-411.txt")
+    f = io.open('hello-411.txt', 'r')
+    matches(f:read'*l', '^%-%- BYTECODE %-%- hello%-411%.lua', "-bl hello.lua hello.txt")
     if has_openresty_listing then
-        like(f:read'*l', '^KGC    0')
-        like(f:read'*l', '^KGC    1')
+        matches(f:read'*l', '^KGC    0')
+        matches(f:read'*l', '^KGC    1')
     end
-    like(f:read'*l', '^0001    %u[%u%d]+%s+')
-    like(f:read'*l', '^0002    %u[%u%d]+%s+')
-    like(f:read'*l', '^0003    %u[%u%d]+%s+')
+    matches(f:read'*l', '^0001    %u[%u%d]+%s+')
+    matches(f:read'*l', '^0002    %u[%u%d]+%s+')
+    matches(f:read'*l', '^0003    %u[%u%d]+%s+')
     f:close()
 end
 
 if has_openresty_listing then
-    cmd = lua .. " -bL hello-404.lua"
+    cmd = lua .. " -bL hello-411.lua"
     f = io.popen(cmd)
-    like(f:read'*l', '^%-%- BYTECODE %-%- hello%-404%.lua', "-bL hello.lua")
-    like(f:read'*l', '^KGC    0')
-    like(f:read'*l', '^KGC    1')
-    like(f:read'*l', '^0001     %[1%]    %u[%u%d]+%s+')
-    like(f:read'*l', '^0002     %[1%]    %u[%u%d]+%s+')
-    like(f:read'*l', '^0003     %[1%]    %u[%u%d]+%s+')
+    matches(f:read'*l', '^%-%- BYTECODE %-%- hello%-411%.lua', "-bL hello.lua")
+    matches(f:read'*l', '^KGC    0')
+    matches(f:read'*l', '^KGC    1')
+    matches(f:read'*l', '^0001     %[1%]    %u[%u%d]+%s+')
+    matches(f:read'*l', '^0002     %[1%]    %u[%u%d]+%s+')
+    matches(f:read'*l', '^0003     %[1%]    %u[%u%d]+%s+')
     f:close()
 
-    os.execute(lua .. " -bL hello-404.lua hello-404.txt")
-    f = io.open('hello-404.txt', 'r')
-    like(f:read'*l', '^%-%- BYTECODE %-%- hello%-404%.lua', "-bL hello.lua hello.txt")
-    like(f:read'*l', '^KGC    0')
-    like(f:read'*l', '^KGC    1')
-    like(f:read'*l', '^0001     %[1%]    %u[%u%d]+%s+')
-    like(f:read'*l', '^0002     %[1%]    %u[%u%d]+%s+')
-    like(f:read'*l', '^0003     %[1%]    %u[%u%d]+%s+')
+    os.execute(lua .. " -bL hello-411.lua hello-411.txt")
+    f = io.open('hello-411.txt', 'r')
+    matches(f:read'*l', '^%-%- BYTECODE %-%- hello%-411%.lua', "-bL hello.lua hello.txt")
+    matches(f:read'*l', '^KGC    0')
+    matches(f:read'*l', '^KGC    1')
+    matches(f:read'*l', '^0001     %[1%]    %u[%u%d]+%s+')
+    matches(f:read'*l', '^0002     %[1%]    %u[%u%d]+%s+')
+    matches(f:read'*l', '^0003     %[1%]    %u[%u%d]+%s+')
     f:close()
 end
 
-os.remove('hello-404.txt') -- clean up
-
-os.execute(lua .. " -b hello-404.lua hello-404.c")
-f = io.open('hello-404.c', 'r')
-like(f:read'*l', '^#ifdef __?cplusplus$', "-b hello.lua hello.c")
-like(f:read'*l', '^extern "C"$')
-like(f:read'*l', '^#endif$')
-like(f:read'*l', '^#ifdef _WIN32$')
-like(f:read'*l', '^__declspec%(dllexport%)$')
-like(f:read'*l', '^#endif$')
-like(f:read'*l', '^const.- char luaJIT_BC_hello_404%[%] = {$')
-like(f:read'*l', '^%d+,%d+,%d+,')
+os.remove('hello-411.txt') -- clean up
+
+os.execute(lua .. " -b hello-411.lua hello-411.c")
+f = io.open('hello-411.c', 'r')
+matches(f:read'*l', '^#ifdef __?cplusplus$', "-b hello.lua hello.c")
+matches(f:read'*l', '^extern "C"$')
+matches(f:read'*l', '^#endif$')
+matches(f:read'*l', '^#ifdef _WIN32$')
+matches(f:read'*l', '^__declspec%(dllexport%)$')
+matches(f:read'*l', '^#endif$')
+matches(f:read'*l', '^const.- char luaJIT_BC_hello_411%[%] = {$')
+matches(f:read'*l', '^%d+,%d+,%d+,')
 f:close()
 
-os.remove('hello-404.c') -- clean up
+os.remove('hello-411.c') -- clean up
 
-os.execute(lua .. " -b hello-404.lua hello-404.h")
-f = io.open('hello-404.h', 'r')
-like(f:read'*l', '^#define luaJIT_BC_hello_404_SIZE %d+$', "-b hello.lua hello.h")
-like(f:read'*l', '^static const.- char luaJIT_BC_hello_404%[%] = {$')
-like(f:read'*l', '^%d+,%d+,%d+,')
+os.execute(lua .. " -b hello-411.lua hello-411.h")
+f = io.open('hello-411.h', 'r')
+matches(f:read'*l', '^#define luaJIT_BC_hello_411_SIZE %d+$', "-b hello.lua hello.h")
+matches(f:read'*l', '^static const.- char luaJIT_BC_hello_411%[%] = {$')
+matches(f:read'*l', '^%d+,%d+,%d+,')
 f:close()
 
-os.remove('hello-404.h') -- clean up
+os.remove('hello-411.h') -- clean up
 
-cmd = lua .. " -j flush hello-404.lua"
+cmd = lua .. " -j flush hello-411.lua"
 f = io.popen(cmd)
-is(f:read'*l', 'Hello World', "-j flush")
+equals(f:read'*l', 'Hello World', "-j flush")
 f:close()
 
-cmd = lua .. " -joff hello-404.lua"
+cmd = lua .. " -joff hello-411.lua"
 f = io.popen(cmd)
-is(f:read'*l', 'Hello World', "-joff")
+equals(f:read'*l', 'Hello World', "-joff")
 f:close()
 
-cmd = lua .. " -jon hello-404.lua 2>&1"
+cmd = lua .. " -jon hello-411.lua 2>&1"
 f = io.popen(cmd)
 if compiled_with_jit then
-    is(f:read'*l', 'Hello World', "-jon")
+    equals(f:read'*l', 'Hello World', "-jon")
 else
-    like(f:read'*l', "^[^:]+: JIT compiler permanently disabled by build option", "no jit")
+    matches(f:read'*l', "^[^:]+: JIT compiler permanently disabled by build option", "no jit")
 end
 f:close()
 
-cmd = lua .. " -j bad hello-404.lua 2>&1"
+cmd = lua .. " -j bad hello-411.lua 2>&1"
 f = io.popen(cmd)
-like(f:read'*l', "^[^:]+: unknown luaJIT command or jit%.%* modules not installed", "-j bad")
+matches(f:read'*l', "^[^:]+: unknown luaJIT command or jit%.%* modules not installed", "-j bad")
 f:close()
 
 if compiled_with_jit then
-    cmd = lua .. " -O hello-404.lua"
+    cmd = lua .. " -O hello-411.lua"
     f = io.popen(cmd)
-    is(f:read'*l', 'Hello World', "-O")
+    equals(f:read'*l', 'Hello World', "-O")
     f:close()
 
-    cmd = lua .. " -O3 hello-404.lua"
+    cmd = lua .. " -O3 hello-411.lua"
     f = io.popen(cmd)
-    is(f:read'*l', 'Hello World', "-O3")
+    equals(f:read'*l', 'Hello World', "-O3")
     f:close()
 
-    cmd = lua .. " -Ocse -O-dce -Ohotloop=10 hello-404.lua"
+    cmd = lua .. " -Ocse -O-dce -Ohotloop=10 hello-411.lua"
     f = io.popen(cmd)
-    is(f:read'*l', 'Hello World', "-Ocse -O-dce -Ohotloop=10")
+    equals(f:read'*l', 'Hello World', "-Ocse -O-dce -Ohotloop=10")
     f:close()
 
-    cmd = lua .. " -O+cse,-dce,hotloop=10 hello-404.lua"
+    cmd = lua .. " -O+cse,-dce,hotloop=10 hello-411.lua"
     f = io.popen(cmd)
-    is(f:read'*l', 'Hello World', "-O+cse,-dce,hotloop=10")
+    equals(f:read'*l', 'Hello World', "-O+cse,-dce,hotloop=10")
     f:close()
 
-    cmd = lua .. " -O+bad hello-404.lua 2>&1"
+    cmd = lua .. " -O+bad hello-411.lua 2>&1"
     f = io.popen(cmd)
-    like(f:read'*l', "^[^:]+: unknown or malformed optimization flag '%+bad'", "-O+bad")
+    matches(f:read'*l', "^[^:]+: unknown or malformed optimization flag '%+bad'", "-O+bad")
     f:close()
 else
-    cmd = lua .. " -O0 hello-404.lua 2>&1"
+    cmd = lua .. " -O0 hello-411.lua 2>&1"
     f = io.popen(cmd)
-    like(f:read'*l', "^[^:]+: attempt to index a nil value")
+    matches(f:read'*l', "^[^:]+: attempt to index a nil value")
     f:close()
 end
 
-os.remove('hello-404.lua') -- clean up
+os.remove('hello-411.lua') -- clean up
 
 done_testing()
 
diff --git a/test/lua-Harness-tests/lexico52/lexico.t b/test/lua-Harness-tests/lexico52/lexico.t
index ff6bb99e..df6610ed 100644
--- a/test/lua-Harness-tests/lexico52/lexico.t
+++ b/test/lua-Harness-tests/lexico52/lexico.t
@@ -1,40 +1,40 @@
 --
 -- lua-Harness : <https://fperrad.frama.io/lua-Harness/>
 --
--- Copyright (C) 2012-2018, Perrad Francois
+-- Copyright (C) 2012-2021, Perrad Francois
 --
 -- This code is licensed under the terms of the MIT/X11 license,
 -- like Lua itself.
 --
 
-is("\x41", "A")
-is("\x3d", "=")
-is("\x3D", "=")
+equals("\x41", "A")
+equals("\x3d", "=")
+equals("\x3D", "=")
 
 do
     local f, msg = load [[a = "A\xyz"]]
-    like(msg, "^[^:]+:%d+: .- near")
+    matches(msg, "^[^:]+:%d+: .- near")
 
     f, msg = load [[a = "A\Z"]]
-    like(msg, "^[^:]+:%d+: .- escape .- near")
+    matches(msg, "^[^:]+:%d+: .- escape .- near")
 end
 
 do
     local a = 'alo\n123"'
-    is("alo\n\z
+    equals("alo\n\z
     123\"", a)
 
     local f, msg = load [[a = " escape \z unauthorized
 new line" ]]
-    like(msg, "^[^:]+:%d+: unfinished string near")
+    matches(msg, "^[^:]+:%d+: unfinished string near")
 end
 
-is(0x0.1E, 0x1E / 0x100)        -- 0.1171875
-is(0xA23p-4, 0xA23 / (2^4))     -- 162.1875
+equals(0x0.1E, 0x1E / 0x100)    -- 0.1171875
+equals(0xA23p-4, 0xA23 / (2^4)) -- 162.1875
 if string.pack and #string.pack('n', 0) == 4 then
     diag('Small Lua')
 else
-    is(0X1.921FB54442D18P+1, (1 + 0x921FB54442D18/0x10000000000000) * 2)
+    equals(0X1.921FB54442D18P+1, (1 + 0x921FB54442D18/0x10000000000000) * 2)
 end
 
 -- Local Variables:
diff --git a/test/lua-Harness-tests/lexico53/boolean.t b/test/lua-Harness-tests/lexico53/boolean.t
index 693ac767..09dc96d4 100644
--- a/test/lua-Harness-tests/lexico53/boolean.t
+++ b/test/lua-Harness-tests/lexico53/boolean.t
@@ -1,39 +1,39 @@
 --
 -- lua-Harness : <https://fperrad.frama.io/lua-Harness/>
 --
--- Copyright (C) 2009-2018, Perrad Francois
+-- Copyright (C) 2009-2021, Perrad Francois
 --
 -- This code is licensed under the terms of the MIT/X11 license,
 -- like Lua itself.
 --
 
-error_like(function () return ~true end,
-           "^[^:]+:%d+: attempt to perform bitwise operation on a boolean value",
-           "~true")
+error_matches(function () return ~true end,
+        "^[^:]+:%d+: attempt to perform bitwise operation on a boolean value",
+        "~true")
 
-error_like(function () return true // 3 end,
-           "^[^:]+:%d+: attempt to perform arithmetic on a boolean value",
-           "true // 3")
+error_matches(function () return true // 3 end,
+        "^[^:]+:%d+: attempt to perform arithmetic on a boolean value",
+        "true // 3")
 
-error_like(function () return true & 7 end,
-           "^[^:]+:%d+: attempt to perform bitwise operation on a boolean value",
-           "true & 7")
+error_matches(function () return true & 7 end,
+        "^[^:]+:%d+: attempt to perform bitwise operation on a boolean value",
+        "true & 7")
 
-error_like(function () return true | 1 end,
-           "^[^:]+:%d+: attempt to perform bitwise operation on a boolean value",
-           "true | 1")
+error_matches(function () return true | 1 end,
+        "^[^:]+:%d+: attempt to perform bitwise operation on a boolean value",
+        "true | 1")
 
-error_like(function () return true ~ 4 end,
-           "^[^:]+:%d+: attempt to perform bitwise operation on a boolean value",
-           "true ~ 4")
+error_matches(function () return true ~ 4 end,
+        "^[^:]+:%d+: attempt to perform bitwise operation on a boolean value",
+        "true ~ 4")
 
-error_like(function () return true >> 5 end,
-           "^[^:]+:%d+: attempt to perform bitwise operation on a boolean value",
-           "true >> 5")
+error_matches(function () return true >> 5 end,
+        "^[^:]+:%d+: attempt to perform bitwise operation on a boolean value",
+        "true >> 5")
 
-error_like(function () return true << 2 end,
-           "^[^:]+:%d+: attempt to perform bitwise operation on a boolean value",
-           "true << 2")
+error_matches(function () return true << 2 end,
+        "^[^:]+:%d+: attempt to perform bitwise operation on a boolean value",
+        "true << 2")
 
 -- Local Variables:
 --   mode: lua
diff --git a/test/lua-Harness-tests/lexico53/function.t b/test/lua-Harness-tests/lexico53/function.t
index 2471be6e..ab48c118 100644
--- a/test/lua-Harness-tests/lexico53/function.t
+++ b/test/lua-Harness-tests/lexico53/function.t
@@ -1,7 +1,7 @@
 --
 -- lua-Harness : <https://fperrad.frama.io/lua-Harness/>
 --
--- Copyright (C) 2009-2019, Perrad Francois
+-- Copyright (C) 2009-2021, Perrad Francois
 --
 -- This code is licensed under the terms of the MIT/X11 license,
 -- like Lua itself.
@@ -9,54 +9,54 @@
 
 local f = function () return 1 end
 
-error_like(function () return ~f end,
-           "^[^:]+:%d+: attempt to perform bitwise operation on",
-           "~f")
+error_matches(function () return ~f end,
+        "^[^:]+:%d+: attempt to perform bitwise operation on",
+        "~f")
 
-error_like(function () f = print; return ~f end,
-           "^[^:]+:%d+: attempt to perform bitwise operation on")
+error_matches(function () f = print; return ~f end,
+        "^[^:]+:%d+: attempt to perform bitwise operation on")
 
-error_like(function () return f // 3 end,
-           "^[^:]+:%d+: attempt to perform arithmetic on",
-           "f // 3")
+error_matches(function () return f // 3 end,
+        "^[^:]+:%d+: attempt to perform arithmetic on",
+        "f // 3")
 
-error_like(function () f = print; return f // 3 end,
-           "^[^:]+:%d+: attempt to perform arithmetic on")
+error_matches(function () f = print; return f // 3 end,
+        "^[^:]+:%d+: attempt to perform arithmetic on")
 
-error_like(function () return f & 7 end,
-           "^[^:]+:%d+: attempt to perform bitwise operation on",
-           "f & 7")
+error_matches(function () return f & 7 end,
+        "^[^:]+:%d+: attempt to perform bitwise operation on",
+        "f & 7")
 
-error_like(function () f = print; return f & 7 end,
-           "^[^:]+:%d+: attempt to perform bitwise operation on")
+error_matches(function () f = print; return f & 7 end,
+        "^[^:]+:%d+: attempt to perform bitwise operation on")
 
-error_like(function () return f | 1 end,
-           "^[^:]+:%d+: attempt to perform bitwise operation on",
-           "f | 1")
+error_matches(function () return f | 1 end,
+        "^[^:]+:%d+: attempt to perform bitwise operation on",
+        "f | 1")
 
-error_like(function () f = print; return f | 1 end,
-           "^[^:]+:%d+: attempt to perform bitwise operation on")
+error_matches(function () f = print; return f | 1 end,
+        "^[^:]+:%d+: attempt to perform bitwise operation on")
 
-error_like(function () return f ~ 4 end,
-           "^[^:]+:%d+: attempt to perform bitwise operation on",
-           "f ~ 4")
+error_matches(function () return f ~ 4 end,
+        "^[^:]+:%d+: attempt to perform bitwise operation on",
+        "f ~ 4")
 
-error_like(function () f = print; return f ~ 4 end,
-           "^[^:]+:%d+: attempt to perform bitwise operation on")
+error_matches(function () f = print; return f ~ 4 end,
+        "^[^:]+:%d+: attempt to perform bitwise operation on")
 
-error_like(function () return f >> 5 end,
-           "^[^:]+:%d+: attempt to perform bitwise operation on",
-           "f >> 5")
+error_matches(function () return f >> 5 end,
+        "^[^:]+:%d+: attempt to perform bitwise operation on",
+        "f >> 5")
 
-error_like(function () f = print; return f >> 5 end,
-           "^[^:]+:%d+: attempt to perform bitwise operation on")
+error_matches(function () f = print; return f >> 5 end,
+        "^[^:]+:%d+: attempt to perform bitwise operation on")
 
-error_like(function () return f << 2 end,
-           "^[^:]+:%d+: attempt to perform bitwise operation on",
-           "f << 2")
+error_matches(function () return f << 2 end,
+        "^[^:]+:%d+: attempt to perform bitwise operation on",
+        "f << 2")
 
-error_like(function () f = print; return f << 2 end,
-           "^[^:]+:%d+: attempt to perform bitwise operation on")
+error_matches(function () f = print; return f << 2 end,
+        "^[^:]+:%d+: attempt to perform bitwise operation on")
 
 -- Local Variables:
 --   mode: lua
diff --git a/test/lua-Harness-tests/lexico53/lexico.t b/test/lua-Harness-tests/lexico53/lexico.t
index 41b0d897..03be2f96 100644
--- a/test/lua-Harness-tests/lexico53/lexico.t
+++ b/test/lua-Harness-tests/lexico53/lexico.t
@@ -1,25 +1,25 @@
 --
 -- lua-Harness : <https://fperrad.frama.io/lua-Harness/>
 --
--- Copyright (C) 2015-2018, Perrad Francois
+-- Copyright (C) 2015-2021, Perrad Francois
 --
 -- This code is licensed under the terms of the MIT/X11 license,
 -- like Lua itself.
 --
 
-is("\u{41}", "A")
-is("\u{20AC}", "\xE2\x82\xAC")
-is("\u{20ac}", "\xe2\x82\xac")
+equals("\u{41}", "A")
+equals("\u{20AC}", "\xE2\x82\xAC")
+equals("\u{20ac}", "\xe2\x82\xac")
 
 do
     local f, msg = load [[a = "A\u{yz}"]]
-    like(msg, "^[^:]+:%d+: .- near")
+    matches(msg, "^[^:]+:%d+: .- near")
 
     f, msg = load [[a = "A\u{41"]]
-    like(msg, "^[^:]+:%d+: .- near")
+    matches(msg, "^[^:]+:%d+: .- near")
 
     f, msg = load [[a = "A\u{FFFFFFFFFF}"]]
-    like(msg, "^[^:]+:%d+: .- near")
+    matches(msg, "^[^:]+:%d+: .- near")
 end
 
 -- Local Variables:
diff --git a/test/lua-Harness-tests/lexico53/nil.t b/test/lua-Harness-tests/lexico53/nil.t
index a6438e20..e665cce4 100644
--- a/test/lua-Harness-tests/lexico53/nil.t
+++ b/test/lua-Harness-tests/lexico53/nil.t
@@ -1,39 +1,39 @@
 --
 -- lua-Harness : <https://fperrad.frama.io/lua-Harness/>
 --
--- Copyright (C) 2009-2018, Perrad Francois
+-- Copyright (C) 2009-2021, Perrad Francois
 --
 -- This code is licensed under the terms of the MIT/X11 license,
 -- like Lua itself.
 --
 
-error_like(function () return ~nil end,
-           "^[^:]+:%d+: attempt to perform bitwise operation on a nil value",
-           "~nil")
+error_matches(function () return ~nil end,
+        "^[^:]+:%d+: attempt to perform bitwise operation on a nil value",
+        "~nil")
 
-error_like(function () return  nil // 3 end,
-           "^[^:]+:%d+: attempt to perform arithmetic on a nil value",
-           "nil // 3")
+error_matches(function () return  nil // 3 end,
+        "^[^:]+:%d+: attempt to perform arithmetic on a nil value",
+        "nil // 3")
 
-error_like(function () return nil & 7 end,
-           "^[^:]+:%d+: attempt to perform bitwise operation on a nil value",
-           "nil & 7")
+error_matches(function () return nil & 7 end,
+        "^[^:]+:%d+: attempt to perform bitwise operation on a nil value",
+        "nil & 7")
 
-error_like(function () return nil | 1 end,
-           "^[^:]+:%d+: attempt to perform bitwise operation on a nil value",
-           "nil | 1")
+error_matches(function () return nil | 1 end,
+        "^[^:]+:%d+: attempt to perform bitwise operation on a nil value",
+        "nil | 1")
 
-error_like(function () return nil ~ 4 end,
-           "^[^:]+:%d+: attempt to perform bitwise operation on a nil value",
-           "nil ~ 4")
+error_matches(function () return nil ~ 4 end,
+        "^[^:]+:%d+: attempt to perform bitwise operation on a nil value",
+        "nil ~ 4")
 
-error_like(function () return nil >> 5 end,
-           "^[^:]+:%d+: attempt to perform bitwise operation on a nil value",
-           "nil >> 5")
+error_matches(function () return nil >> 5 end,
+        "^[^:]+:%d+: attempt to perform bitwise operation on a nil value",
+        "nil >> 5")
 
-error_like(function () return nil << 2 end,
-           "^[^:]+:%d+: attempt to perform bitwise operation on a nil value",
-           "nil << 2")
+error_matches(function () return nil << 2 end,
+        "^[^:]+:%d+: attempt to perform bitwise operation on a nil value",
+        "nil << 2")
 
 -- Local Variables:
 --   mode: lua
diff --git a/test/lua-Harness-tests/lexico53/number.t b/test/lua-Harness-tests/lexico53/number.t
index d205da3b..b0e1acb2 100644
--- a/test/lua-Harness-tests/lexico53/number.t
+++ b/test/lua-Harness-tests/lexico53/number.t
@@ -1,7 +1,7 @@
 --
 -- lua-Harness : <https://fperrad.frama.io/lua-Harness/>
 --
--- Copyright (C) 2009-2019, Perrad Francois
+-- Copyright (C) 2009-2021, Perrad Francois
 --
 -- This code is licensed under the terms of the MIT/X11 license,
 -- like Lua itself.
@@ -9,169 +9,169 @@
 
 local profile = require'profile'
 
-is(~4, -5, "~4")
+equals(~4, -5, "~4")
 
-error_like(function () return ~3.14 end,
-           "^[^:]+:%d+: number has no integer representation",
-           "~3.14")
+error_matches(function () return ~3.14 end,
+        "^[^:]+:%d+: number has no integer representation",
+        "~3.14")
 
-is(25.5 // 3.5, 7.0, "25.5 // 3.5")
+equals(25.5 // 3.5, 7.0, "25.5 // 3.5")
 
-is(25 // 3, 8, "25 // 3")
+equals(25 // 3, 8, "25 // 3")
 
-is(25 // -3, -9, "25 // -3")
+equals(25 // -3, -9, "25 // -3")
 
-is(1 // -1, -1, "1 // -1")
+equals(1 // -1, -1, "1 // -1")
 
-type_ok(1.0 // 0, 'number', "1.0 // 0")
+is_number(1.0 // 0, "1.0 // 0")
 
-error_like(function () return 1 // 0 end,
-           "^[^:]+:%d+: attempt to divide by zero",
-           "1 // 0")
+error_matches(function () return 1 // 0 end,
+        "^[^:]+:%d+: attempt to divide by zero",
+        "1 // 0")
 
-is(3 & 7, 3, "3 & 7")
+equals(3 & 7, 3, "3 & 7")
 
-is(4 | 1, 5, "4 | 1")
+equals(4 | 1, 5, "4 | 1")
 
-is(7 ~ 1, 6, "7 ~ 1")
+equals(7 ~ 1, 6, "7 ~ 1")
 
-is(100 >> 5, 3, "100 >> 5")
+equals(100 >> 5, 3, "100 >> 5")
 
-is(3 << 2, 12, "3 << 2")
+equals(3 << 2, 12, "3 << 2")
 
-error_like(function () return 25 // {} end,
-           "^[^:]+:%d+: attempt to perform arithmetic on a table value",
-           "25 // {}")
+error_matches(function () return 25 // {} end,
+        "^[^:]+:%d+: attempt to perform arithmetic on a table value",
+        "25 // {}")
 
-error_like(function () return 3 & true end,
-           "^[^:]+:%d+: attempt to perform bitwise operation on a boolean value",
-           "3 & true")
+error_matches(function () return 3 & true end,
+        "^[^:]+:%d+: attempt to perform bitwise operation on a boolean value",
+        "3 & true")
 
-error_like(function () return 4 | true end,
-           "^[^:]+:%d+: attempt to perform bitwise operation on a boolean value",
-           "4 | true")
+error_matches(function () return 4 | true end,
+        "^[^:]+:%d+: attempt to perform bitwise operation on a boolean value",
+        "4 | true")
 
-error_like(function () return 7 ~ true end,
-           "^[^:]+:%d+: attempt to perform bitwise operation on a boolean value",
-           "7 ~ true")
+error_matches(function () return 7 ~ true end,
+        "^[^:]+:%d+: attempt to perform bitwise operation on a boolean value",
+        "7 ~ true")
 
-error_like(function () return 100 >> true end,
-           "^[^:]+:%d+: attempt to perform bitwise operation on a boolean value",
-           "100 >> true")
+error_matches(function () return 100 >> true end,
+        "^[^:]+:%d+: attempt to perform bitwise operation on a boolean value",
+        "100 >> true")
 
-error_like(function () return 3 << true end,
-           "^[^:]+:%d+: attempt to perform bitwise operation on a boolean value",
-           "3 << true")
+error_matches(function () return 3 << true end,
+        "^[^:]+:%d+: attempt to perform bitwise operation on a boolean value",
+        "3 << true")
 
-error_like(function () return 25 // 'text' end,
-           "^[^:]+:%d+: attempt to",
-           "25 // 'text'")
+error_matches(function () return 25 // 'text' end,
+        "^[^:]+:%d+: attempt to",
+        "25 // 'text'")
 
-error_like(function () return 3 & 'text' end,
-           "^[^:]+:%d+: attempt to",
-           "3 & 'text'")
+error_matches(function () return 3 & 'text' end,
+        "^[^:]+:%d+: attempt to",
+        "3 & 'text'")
 
-error_like(function () return 4 | 'text' end,
-           "^[^:]+:%d+: attempt to",
-           "4 | 'text'")
+error_matches(function () return 4 | 'text' end,
+        "^[^:]+:%d+: attempt to",
+        "4 | 'text'")
 
-error_like(function () return 7 ~ 'text' end,
-           "^[^:]+:%d+: attempt to",
-           "7 ~ 'text'")
+error_matches(function () return 7 ~ 'text' end,
+        "^[^:]+:%d+: attempt to",
+        "7 ~ 'text'")
 
-error_like(function () return 100 >> 'text' end,
-           "^[^:]+:%d+: attempt to",
-           "100 >> 'text'")
+error_matches(function () return 100 >> 'text' end,
+        "^[^:]+:%d+: attempt to",
+        "100 >> 'text'")
 
-error_like(function () return 3 << 'text' end,
-           "^[^:]+:%d+: attempt to",
-           "3 << 'text'")
+error_matches(function () return 3 << 'text' end,
+        "^[^:]+:%d+: attempt to",
+        "3 << 'text'")
 
 if profile.nocvts2n then
-    error_like(function () return 25.5 // '3.5' end,
-               "^[^:]+:%d+: attempt to",
-               "25.5 // '3.5'")
+    error_matches(function () return 25.5 // '3.5' end,
+            "^[^:]+:%d+: attempt to",
+            "25.5 // '3.5'")
 
-    error_like(function () return 25 // '3' end,
-               "^[^:]+:%d+: attempt to",
-               "25 // '3'")
+    error_matches(function () return 25 // '3' end,
+            "^[^:]+:%d+: attempt to",
+            "25 // '3'")
 else
-    is(25.5 // '3.5', 7.0, "25.5 // '3.5'")
+    equals(25.5 // '3.5', 7.0, "25.5 // '3.5'")
 
-    is(25 // '3', 8, "25 // '3'")
+    equals(25 // '3', 8, "25 // '3'")
 end
 
 if profile.nocvts2n or _VERSION >= 'Lua 5.4' then
-    error_like(function () return 3 & '7' end,
-               "^[^:]+:%d+: attempt to",
-               "3 & '7'")
+    error_matches(function () return 3 & '7' end,
+            "^[^:]+:%d+: attempt to",
+            "3 & '7'")
 
-    error_like(function () return 4 | '1' end,
-               "^[^:]+:%d+: attempt to",
-               "4 | '1'")
+    error_matches(function () return 4 | '1' end,
+            "^[^:]+:%d+: attempt to",
+            "4 | '1'")
 
-    error_like(function () return 7 ~ '1' end,
-               "^[^:]+:%d+: attempt to",
-               "7 ~ '1'")
+    error_matches(function () return 7 ~ '1' end,
+            "^[^:]+:%d+: attempt to",
+            "7 ~ '1'")
 
-    error_like(function () return 100 >> '5' end,
-               "^[^:]+:%d+: attempt to",
-               "100 >> '5'")
+    error_matches(function () return 100 >> '5' end,
+            "^[^:]+:%d+: attempt to",
+            "100 >> '5'")
 
-    error_like(function () return 3 << '2' end,
-               "^[^:]+:%d+: attempt to",
-               "3 << '2'")
+    error_matches(function () return 3 << '2' end,
+            "^[^:]+:%d+: attempt to",
+            "3 << '2'")
 else
-    is(3 & '7', 3, "3 & '7'")
+    equals(3 & '7', 3, "3 & '7'")
 
-    is(4 | '1', 5, "4 | '1'")
+    equals(4 | '1', 5, "4 | '1'")
 
-    is(7 ~ '1', 6, "7 ~ '1'")
+    equals(7 ~ '1', 6, "7 ~ '1'")
 
-    is(100 >> '5', 3, "100 >> '5'")
+    equals(100 >> '5', 3, "100 >> '5'")
 
-    is(3 << '2', 12, "3 << '2'")
+    equals(3 << '2', 12, "3 << '2'")
 end
 
-error_like(function () return 3.5 & 7 end,
-           "^[^:]+:%d+: number has no integer representation",
-           "3.5 & 7")
+error_matches(function () return 3.5 & 7 end,
+        "^[^:]+:%d+: number has no integer representation",
+        "3.5 & 7")
 
-error_like(function () return 3 & 7.5 end,
-           "^[^:]+:%d+: number has no integer representation",
-           "3 & 7.5")
+error_matches(function () return 3 & 7.5 end,
+        "^[^:]+:%d+: number has no integer representation",
+        "3 & 7.5")
 
-error_like(function () return 4.5 | 1 end,
-           "^[^:]+:%d+: number has no integer representation",
-           "4.5 | 1")
+error_matches(function () return 4.5 | 1 end,
+        "^[^:]+:%d+: number has no integer representation",
+        "4.5 | 1")
 
-error_like(function () return 4 | 1.5 end,
-           "^[^:]+:%d+: number has no integer representation",
-           "4 | 1.5")
+error_matches(function () return 4 | 1.5 end,
+        "^[^:]+:%d+: number has no integer representation",
+        "4 | 1.5")
 
-error_like(function () return 7.5 ~ 1 end,
-           "^[^:]+:%d+: number has no integer representation",
-           "7.5 ~ 1")
+error_matches(function () return 7.5 ~ 1 end,
+        "^[^:]+:%d+: number has no integer representation",
+        "7.5 ~ 1")
 
-error_like(function () return 7 ~ 1.5 end,
-           "^[^:]+:%d+: number has no integer representation",
-           "7 ~ 1.5")
+error_matches(function () return 7 ~ 1.5 end,
+        "^[^:]+:%d+: number has no integer representation",
+        "7 ~ 1.5")
 
-error_like(function () return 100.5 >> 5 end,
-           "^[^:]+:%d+: number has no integer representation",
-           "100.5 >> 5")
+error_matches(function () return 100.5 >> 5 end,
+        "^[^:]+:%d+: number has no integer representation",
+        "100.5 >> 5")
 
-error_like(function () return 100 >> 5.5 end,
-           "^[^:]+:%d+: number has no integer representation",
-           "100 >> 5.5")
+error_matches(function () return 100 >> 5.5 end,
+        "^[^:]+:%d+: number has no integer representation",
+        "100 >> 5.5")
 
-error_like(function () return 3.5 << 2 end,
-           "^[^:]+:%d+: number has no integer representation",
-           "3.5 << 2")
+error_matches(function () return 3.5 << 2 end,
+        "^[^:]+:%d+: number has no integer representation",
+        "3.5 << 2")
 
-error_like(function () return 3 << 2.5 end,
-           "^[^:]+:%d+: number has no integer representation",
-           "3 << 2.5")
+error_matches(function () return 3 << 2.5 end,
+        "^[^:]+:%d+: number has no integer representation",
+        "3 << 2.5")
 
 -- Local Variables:
 --   mode: lua
diff --git a/test/lua-Harness-tests/lexico53/string.t b/test/lua-Harness-tests/lexico53/string.t
index eb74064b..de0140c7 100644
--- a/test/lua-Harness-tests/lexico53/string.t
+++ b/test/lua-Harness-tests/lexico53/string.t
@@ -1,7 +1,7 @@
 --
 -- lua-Harness : <https://fperrad.frama.io/lua-Harness/>
 --
--- Copyright (C) 2009-2019, Perrad Francois
+-- Copyright (C) 2009-2021, Perrad Francois
 --
 -- This code is licensed under the terms of the MIT/X11 license,
 -- like Lua itself.
@@ -10,155 +10,155 @@
 local profile = require'profile'
 
 if profile.nocvts2n or _VERSION >= 'Lua 5.4' then
-    error_like(function () return ~'4' end,
+    error_matches(function () return ~'4' end,
                "^[^:]+:%d+: attempt to",
                "~'4'")
 else
-    is(~'4', -5, "~'4'")
+    equals(~'4', -5, "~'4'")
 end
 
-error_like(function () return ~'text' end,
-           "^[^:]+:%d+: attempt to",
-           "~'text'")
+error_matches(function () return ~'text' end,
+        "^[^:]+:%d+: attempt to",
+        "~'text'")
 
 if profile.nocvts2n then
-    error_like(function () return '25.5' // 3.5 end,
-               "^[^:]+:%d+: attempt to",
-               "'25.5' // 3.5")
+    error_matches(function () return '25.5' // 3.5 end,
+            "^[^:]+:%d+: attempt to",
+            "'25.5' // 3.5")
 
-    error_like(function () return '25' // 3 end,
-               "^[^:]+:%d+: attempt to",
-               "'25' // 3")
+    error_matches(function () return '25' // 3 end,
+            "^[^:]+:%d+: attempt to",
+            "'25' // 3")
 else
-    is('25.5' // 3.5, 7.0, "'25.5' // 3.5")
+    equals('25.5' // 3.5, 7.0, "'25.5' // 3.5")
 
-    is('25' // 3, 8, "'25' // 3")
+    equals('25' // 3, 8, "'25' // 3")
 end
 
 if profile.nocvts2n or _VERSION >= 'Lua 5.4' then
-    error_like(function () return '3' & 7 end,
-               "^[^:]+:%d+: attempt to",
-               "'3' & 7")
+    error_matches(function () return '3' & 7 end,
+            "^[^:]+:%d+: attempt to",
+            "'3' & 7")
 
-    error_like(function () return '4' | 1 end,
-               "^[^:]+:%d+: attempt to",
-               "'4' | 1")
+    error_matches(function () return '4' | 1 end,
+            "^[^:]+:%d+: attempt to",
+            "'4' | 1")
 
-    error_like(function () return '7' ~ 1 end,
-               "^[^:]+:%d+: attempt to",
-               "'7' ~ 1")
+    error_matches(function () return '7' ~ 1 end,
+            "^[^:]+:%d+: attempt to",
+            "'7' ~ 1")
 
-    error_like(function () return '100' >> 5 end,
-               "^[^:]+:%d+: attempt to",
-               "'100' >> 5")
+    error_matches(function () return '100' >> 5 end,
+            "^[^:]+:%d+: attempt to",
+            "'100' >> 5")
 
-    error_like(function () return '3' << 2 end,
-               "^[^:]+:%d+: attempt to",
-               "'3' << 2")
+    error_matches(function () return '3' << 2 end,
+            "^[^:]+:%d+: attempt to",
+            "'3' << 2")
 else
-    is('3' & 7, 3, "'3' & 7")
+    equals('3' & 7, 3, "'3' & 7")
 
-    is('4' | 1, 5, "'4' | 1")
+    equals('4' | 1, 5, "'4' | 1")
 
-    is('7' ~ 1, 6, "'7' ~ 1")
+    equals('7' ~ 1, 6, "'7' ~ 1")
 
-    is('100' >> 5, 3, "'100' >> 5")
+    equals('100' >> 5, 3, "'100' >> 5")
 
-    is('3' << 2, 12, "'3' << 2")
+    equals('3' << 2, 12, "'3' << 2")
 end
 
-error_like(function () return '25' // {} end,
-           "^[^:]+:%d+: attempt to",
-           "'25' // {}")
+error_matches(function () return '25' // {} end,
+        "^[^:]+:%d+: attempt to",
+        "'25' // {}")
 
-error_like(function () return '3' & true end,
-           "^[^:]+:%d+: attempt to",
-           "'3' & true")
+error_matches(function () return '3' & true end,
+        "^[^:]+:%d+: attempt to",
+        "'3' & true")
 
-error_like(function () return '4' | true end,
-           "^[^:]+:%d+: attempt to",
-           "'4' | true")
+error_matches(function () return '4' | true end,
+        "^[^:]+:%d+: attempt to",
+        "'4' | true")
 
-error_like(function () return '7' ~ true end,
-           "^[^:]+:%d+: attempt to",
-           "'7' ~ true")
+error_matches(function () return '7' ~ true end,
+        "^[^:]+:%d+: attempt to",
+        "'7' ~ true")
 
-error_like(function () return '100' >> true end,
-           "^[^:]+:%d+: attempt to",
-           "'100' >> true")
+error_matches(function () return '100' >> true end,
+        "^[^:]+:%d+: attempt to",
+        "'100' >> true")
 
-error_like(function () return '3' << true end,
-           "^[^:]+:%d+: attempt to",
-           "'3' << true")
+error_matches(function () return '3' << true end,
+        "^[^:]+:%d+: attempt to",
+        "'3' << true")
 
-error_like(function () return '25' // 'text' end,
-           "^[^:]+:%d+: attempt to",
-           "'25' // 'text'")
+error_matches(function () return '25' // 'text' end,
+        "^[^:]+:%d+: attempt to",
+        "'25' // 'text'")
 
-error_like(function () return '3' & 'text' end,
-           "^[^:]+:%d+: attempt to",
-           "'3' & 'text'")
+error_matches(function () return '3' & 'text' end,
+        "^[^:]+:%d+: attempt to",
+        "'3' & 'text'")
 
-error_like(function () return '4' | 'text' end,
-           "^[^:]+:%d+: attempt to",
-           "'4' | 'text'")
+error_matches(function () return '4' | 'text' end,
+        "^[^:]+:%d+: attempt to",
+        "'4' | 'text'")
 
-error_like(function () return '7' ~ 'text' end,
-           "^[^:]+:%d+: attempt to",
-           "'7' ~ 'text'")
+error_matches(function () return '7' ~ 'text' end,
+        "^[^:]+:%d+: attempt to",
+        "'7' ~ 'text'")
 
-error_like(function () return '100' >> 'text' end,
-           "^[^:]+:%d+: attempt to",
-           "'100' >> 'text'")
+error_matches(function () return '100' >> 'text' end,
+        "^[^:]+:%d+: attempt to",
+        "'100' >> 'text'")
 
-error_like(function () return '3' << 'text' end,
-           "^[^:]+:%d+: attempt to",
-           "'3' << 'text'")
+error_matches(function () return '3' << 'text' end,
+        "^[^:]+:%d+: attempt to",
+        "'3' << 'text'")
 
 if profile.nocvts2n then
-    error_like(function () return '25.5' // '3.5' end,
-               "^[^:]+:%d+: attempt to",
-               "'25.5' // '3.5'")
+    error_matches(function () return '25.5' // '3.5' end,
+            "^[^:]+:%d+: attempt to",
+            "'25.5' // '3.5'")
 
-    error_like(function () return '25' // '3' end,
-               "^[^:]+:%d+: attempt to",
-               "'25' // '3'")
+    error_matches(function () return '25' // '3' end,
+            "^[^:]+:%d+: attempt to",
+            "'25' // '3'")
 else
-    is('25.5' // '3.5', 7.0, "'25.5' // '3.5'")
+    equals('25.5' // '3.5', 7.0, "'25.5' // '3.5'")
 
-     is('25' // '3', 8, "'25' // '3'")
+    equals('25' // '3', 8, "'25' // '3'")
 end
 
 if profile.nocvts2n or _VERSION >= 'Lua 5.4' then
-    error_like(function () return '3' & '7' end,
-               "^[^:]+:%d+: attempt to",
-               "'3' & '7'")
+    error_matches(function () return '3' & '7' end,
+            "^[^:]+:%d+: attempt to",
+            "'3' & '7'")
 
-    error_like(function () return '4' | '1' end,
-               "^[^:]+:%d+: attempt to",
-               "'4' | '1'")
+    error_matches(function () return '4' | '1' end,
+            "^[^:]+:%d+: attempt to",
+            "'4' | '1'")
 
-    error_like(function () return '7' ~ '1' end,
-               "^[^:]+:%d+: attempt to",
-               "'7' ~ '1'")
+    error_matches(function () return '7' ~ '1' end,
+            "^[^:]+:%d+: attempt to",
+            "'7' ~ '1'")
 
-    error_like(function () return '100' >> '5' end,
-               "^[^:]+:%d+: attempt to",
-               "'100' >> '5'")
+    error_matches(function () return '100' >> '5' end,
+            "^[^:]+:%d+: attempt to",
+            "'100' >> '5'")
 
-    error_like(function () return '3' << '2' end,
-               "^[^:]+:%d+: attempt to",
-               "'3' << '2'")
+    error_matches(function () return '3' << '2' end,
+            "^[^:]+:%d+: attempt to",
+            "'3' << '2'")
 else
-    is('3' & '7', 3, "'3' & '7'")
+    equals('3' & '7', 3, "'3' & '7'")
 
-    is('4' | '1', 5, "'4' | '1'")
+    equals('4' | '1', 5, "'4' | '1'")
 
-    is('7' ~ '1', 6, "'7' ~ '1'")
+    equals('7' ~ '1', 6, "'7' ~ '1'")
 
-    is('100' >> '5', 3, "'100' >> '5'")
+    equals('100' >> '5', 3, "'100' >> '5'")
 
-    is('3' << '2', 12, "'3' << 2")
+    equals('3' << '2', 12, "'3' << 2")
 end
 
 -- Local Variables:
diff --git a/test/lua-Harness-tests/lexico53/table.t b/test/lua-Harness-tests/lexico53/table.t
index 007232d5..f5a5d82c 100644
--- a/test/lua-Harness-tests/lexico53/table.t
+++ b/test/lua-Harness-tests/lexico53/table.t
@@ -1,39 +1,39 @@
 --
 -- lua-Harness : <https://fperrad.frama.io/lua-Harness/>
 --
--- Copyright (C) 2009-2018, Perrad Francois
+-- Copyright (C) 2009-2021, Perrad Francois
 --
 -- This code is licensed under the terms of the MIT/X11 license,
 -- like Lua itself.
 --
 
-error_like(function () return ~{} end,
-           "^[^:]+:%d+: attempt to perform bitwise operation on a table value",
-           "~{}")
+error_matches(function () return ~{} end,
+        "^[^:]+:%d+: attempt to perform bitwise operation on a table value",
+        "~{}")
 
-error_like(function () return {} // 3 end,
-           "^[^:]+:%d+: attempt to perform arithmetic on",
-           "{} // 3")
+error_matches(function () return {} // 3 end,
+        "^[^:]+:%d+: attempt to perform arithmetic on",
+        "{} // 3")
 
-error_like(function () return {} & 7 end,
-           "^[^:]+:%d+: attempt to perform bitwise operation on a table value",
-           "{} & 7")
+error_matches(function () return {} & 7 end,
+        "^[^:]+:%d+: attempt to perform bitwise operation on a table value",
+        "{} & 7")
 
-error_like(function () return {} | 1 end,
-           "^[^:]+:%d+: attempt to perform bitwise operation on a table value",
-           "{} | 1")
+error_matches(function () return {} | 1 end,
+        "^[^:]+:%d+: attempt to perform bitwise operation on a table value",
+        "{} | 1")
 
-error_like(function () return {} ~ 4 end,
-           "^[^:]+:%d+: attempt to perform bitwise operation on a table value",
-           "{} ~ 4")
+error_matches(function () return {} ~ 4 end,
+        "^[^:]+:%d+: attempt to perform bitwise operation on a table value",
+        "{} ~ 4")
 
-error_like(function () return {} >> 5 end,
-           "^[^:]+:%d+: attempt to perform bitwise operation on a table value",
-           "{} >> 5")
+error_matches(function () return {} >> 5 end,
+        "^[^:]+:%d+: attempt to perform bitwise operation on a table value",
+        "{} >> 5")
 
-error_like(function () return {} << 2 end,
-           "^[^:]+:%d+: attempt to perform bitwise operation on a table value",
-           "{} << 2")
+error_matches(function () return {} << 2 end,
+        "^[^:]+:%d+: attempt to perform bitwise operation on a table value",
+        "{} << 2")
 
 -- Local Variables:
 --   mode: lua
diff --git a/test/lua-Harness-tests/lexico53/thread.t b/test/lua-Harness-tests/lexico53/thread.t
index ef9e57b3..c49de20a 100644
--- a/test/lua-Harness-tests/lexico53/thread.t
+++ b/test/lua-Harness-tests/lexico53/thread.t
@@ -1,7 +1,7 @@
 --
 -- lua-Harness : <https://fperrad.frama.io/lua-Harness/>
 --
--- Copyright (C) 2009-2019, Perrad Francois
+-- Copyright (C) 2009-2021, Perrad Francois
 --
 -- This code is licensed under the terms of the MIT/X11 license,
 -- like Lua itself.
@@ -9,33 +9,33 @@
 
 local co = coroutine.create(function () return 1 end)
 
-error_like(function () return ~co end,
-           "^[^:]+:%d+: attempt to perform bitwise operation on",
-           "~co")
+error_matches(function () return ~co end,
+        "^[^:]+:%d+: attempt to perform bitwise operation on",
+        "~co")
 
-error_like(function () return co // 3 end,
-           "^[^:]+:%d+: attempt to perform arithmetic on",
-           "co // 3")
+error_matches(function () return co // 3 end,
+        "^[^:]+:%d+: attempt to perform arithmetic on",
+        "co // 3")
 
-error_like(function () return co & 7 end,
-           "^[^:]+:%d+: attempt to perform bitwise operation on",
-           "co & 7")
+error_matches(function () return co & 7 end,
+        "^[^:]+:%d+: attempt to perform bitwise operation on",
+        "co & 7")
 
-error_like(function () return co | 1 end,
-           "^[^:]+:%d+: attempt to perform bitwise operation on",
-           "co | 1")
+error_matches(function () return co | 1 end,
+        "^[^:]+:%d+: attempt to perform bitwise operation on",
+        "co | 1")
 
-error_like(function () return co ~ 4 end,
-           "^[^:]+:%d+: attempt to perform bitwise operation on",
-           "co ~ 4")
+error_matches(function () return co ~ 4 end,
+        "^[^:]+:%d+: attempt to perform bitwise operation on",
+        "co ~ 4")
 
-error_like(function () return co >> 5 end,
-           "^[^:]+:%d+: attempt to perform bitwise operation on",
-           "co >> 5")
+error_matches(function () return co >> 5 end,
+        "^[^:]+:%d+: attempt to perform bitwise operation on",
+        "co >> 5")
 
-error_like(function () return co << 2 end,
-           "^[^:]+:%d+: attempt to perform bitwise operation on",
-           "co << 2")
+error_matches(function () return co << 2 end,
+        "^[^:]+:%d+: attempt to perform bitwise operation on",
+        "co << 2")
 
 -- Local Variables:
 --   mode: lua
diff --git a/test/lua-Harness-tests/lexico53/userdata.t b/test/lua-Harness-tests/lexico53/userdata.t
index 06b96f91..f01febf6 100644
--- a/test/lua-Harness-tests/lexico53/userdata.t
+++ b/test/lua-Harness-tests/lexico53/userdata.t
@@ -1,7 +1,7 @@
 --
 -- lua-Harness : <https://fperrad.frama.io/lua-Harness/>
 --
--- Copyright (C) 2009-2019, Perrad Francois
+-- Copyright (C) 2009-2021, Perrad Francois
 --
 -- This code is licensed under the terms of the MIT/X11 license,
 -- like Lua itself.
@@ -9,33 +9,33 @@
 
 local u = io.stdin
 
-error_like(function () return ~u end,
-           "^[^:]+:%d+: attempt to perform bitwise operation on",
-           "~u")
+error_matches(function () return ~u end,
+        "^[^:]+:%d+: attempt to perform bitwise operation on",
+        "~u")
 
-error_like(function () return u // 3 end,
-           "^[^:]+:%d+: attempt to perform arithmetic on",
-           "u // 3")
+error_matches(function () return u // 3 end,
+        "^[^:]+:%d+: attempt to perform arithmetic on",
+        "u // 3")
 
-error_like(function () return u & 7 end,
-           "^[^:]+:%d+: attempt to perform bitwise operation on",
-           "u & 7")
+error_matches(function () return u & 7 end,
+        "^[^:]+:%d+: attempt to perform bitwise operation on",
+        "u & 7")
 
-error_like(function () return u | 1 end,
-           "^[^:]+:%d+: attempt to perform bitwise operation on",
-           "u | 1")
+error_matches(function () return u | 1 end,
+        "^[^:]+:%d+: attempt to perform bitwise operation on",
+        "u | 1")
 
-error_like(function () return u ~ 4 end,
-           "^[^:]+:%d+: attempt to perform bitwise operation on",
-           "u ~ 4")
+error_matches(function () return u ~ 4 end,
+        "^[^:]+:%d+: attempt to perform bitwise operation on",
+        "u ~ 4")
 
-error_like(function () return u >> 5 end,
-           "^[^:]+:%d+: attempt to perform bitwise operation on",
-           "u >> 5")
+error_matches(function () return u >> 5 end,
+        "^[^:]+:%d+: attempt to perform bitwise operation on",
+        "u >> 5")
 
-error_like(function () return u << 2 end,
-           "^[^:]+:%d+: attempt to perform bitwise operation on",
-           "u << 2")
+error_matches(function () return u << 2 end,
+        "^[^:]+:%d+: attempt to perform bitwise operation on",
+        "u << 2")
 
 -- Local Variables:
 --   mode: lua
diff --git a/test/lua-Harness-tests/lexico53/utf8.t b/test/lua-Harness-tests/lexico53/utf8.t
index 87d3f6dd..1458fe86 100644
--- a/test/lua-Harness-tests/lexico53/utf8.t
+++ b/test/lua-Harness-tests/lexico53/utf8.t
@@ -1,7 +1,7 @@
 --
 -- lua-Harness : <https://fperrad.frama.io/lua-Harness/>
 --
--- Copyright (C) 2014-2020, Perrad Francois
+-- Copyright (C) 2014-2021, Perrad Francois
 --
 -- This code is licensed under the terms of the MIT/X11 license,
 -- like Lua itself.
@@ -11,44 +11,44 @@ local has_char54 = _VERSION >= 'Lua 5.4'
 local has_charpattern54 = _VERSION >= 'Lua 5.4'
 
 do -- char
-    is(utf8.char(65, 66, 67), 'ABC', "function char")
-    is(utf8.char(0x20AC), '\u{20AC}')
-    is(utf8.char(), '')
-
-    is(utf8.char(0):len(), 1)
-    is(utf8.char(0x7F):len(), 1)
-    is(utf8.char(0x80):len(), 2)
-    is(utf8.char(0x7FF):len(), 2)
-    is(utf8.char(0x800):len(), 3)
-    is(utf8.char(0xFFFF):len(), 3)
-    is(utf8.char(0x10000):len(), 4)
-    is(utf8.char(0x10FFFF):len(), 4)
+    equals(utf8.char(65, 66, 67), 'ABC', "function char")
+    equals(utf8.char(0x20AC), '\u{20AC}')
+    equals(utf8.char(), '')
+
+    equals(utf8.char(0):len(), 1)
+    equals(utf8.char(0x7F):len(), 1)
+    equals(utf8.char(0x80):len(), 2)
+    equals(utf8.char(0x7FF):len(), 2)
+    equals(utf8.char(0x800):len(), 3)
+    equals(utf8.char(0xFFFF):len(), 3)
+    equals(utf8.char(0x10000):len(), 4)
+    equals(utf8.char(0x10FFFF):len(), 4)
     if has_char54 then
-        is(utf8.char(0x1FFFFF):len(), 4)
-        is(utf8.char(0x200000):len(), 5)
-        is(utf8.char(0x3FFFFFF):len(), 5)
-        is(utf8.char(0x4000000):len(), 6)
-        is(utf8.char(0x7FFFFFFF):len(), 6)
+        equals(utf8.char(0x1FFFFF):len(), 4)
+        equals(utf8.char(0x200000):len(), 5)
+        equals(utf8.char(0x3FFFFFF):len(), 5)
+        equals(utf8.char(0x4000000):len(), 6)
+        equals(utf8.char(0x7FFFFFFF):len(), 6)
     else
-        error_like(function () utf8.char(0x110000) end,
-                   "^[^:]+:%d+: bad argument #1 to 'char' %(value out of ",
-                   "function char (out of range)")
+        error_matches(function () utf8.char(0x110000) end,
+                "^[^:]+:%d+: bad argument #1 to 'char' %(value out of ",
+                "function char (out of range)")
     end
 
-    error_like(function () utf8.char(0, -1) end,
-               "^[^:]+:%d+: bad argument #2 to 'char' %(value out of ",
-               "function char (out of range)")
+    error_matches(function () utf8.char(0, -1) end,
+            "^[^:]+:%d+: bad argument #2 to 'char' %(value out of ",
+            "function char (out of range)")
 
-     error_like(function () utf8.char(0, 'bad') end,
-                "^[^:]+:%d+: bad argument #2 to 'char' %(number expected, got string%)",
-                "function char (bad)")
+     error_matches(function () utf8.char(0, 'bad') end,
+            "^[^:]+:%d+: bad argument #2 to 'char' %(number expected, got string%)",
+            "function char (bad)")
 end
 
 do -- charpattern
     if has_charpattern54 then
-        is(utf8.charpattern, "[\0-\x7F\xC2-\xFD][\x80-\xBF]*", "charpattern")
+        equals(utf8.charpattern, "[\0-\x7F\xC2-\xFD][\x80-\xBF]*", "charpattern")
     else
-        is(utf8.charpattern, "[\0-\x7F\xC2-\xF4][\x80-\xBF]*", "charpattern")
+        equals(utf8.charpattern, "[\0-\x7F\xC2-\xF4][\x80-\xBF]*", "charpattern")
     end
 end
 
@@ -59,116 +59,116 @@ do -- codes
         ap[#ap+1] = p
         ac[#ac+1] = c
     end
-    eq_array(ap, {1, 2, 5}, "function codes")
-    eq_array(ac, {0x41, 0x20AC, 0x33})
+    array_equals(ap, {1, 2, 5}, "function codes")
+    array_equals(ac, {0x41, 0x20AC, 0x33})
 
     local empty = true
     for p, c in utf8.codes('') do
         empty = false
     end
-    ok(empty, "codes (empty)")
+    truthy(empty, "codes (empty)")
 
-    error_like(function () utf8.codes() end,
-               "^[^:]+:%d+: bad argument #1 to 'codes' %(string expected, got no value%)",
-               "function codes ()")
+    error_matches(function () utf8.codes() end,
+            "^[^:]+:%d+: bad argument #1 to 'codes' %(string expected, got no value%)",
+            "function codes ()")
 
-    error_like(function () utf8.codes(true) end,
-               "^[^:]+:%d+: bad argument #1 to 'codes' %(string expected, got boolean%)",
-               "function codes (true)")
+    error_matches(function () utf8.codes(true) end,
+            "^[^:]+:%d+: bad argument #1 to 'codes' %(string expected, got boolean%)",
+            "function codes (true)")
 
-    error_like(function () for p, c in utf8.codes('invalid\xFF') do end end,
-               "^[^:]+:%d+: invalid UTF%-8 code",
-               "function codes (invalid)")
+    error_matches(function () for p, c in utf8.codes('invalid\xFF') do end end,
+            "^[^:]+:%d+: invalid UTF%-8 code",
+            "function codes (invalid)")
 end
 
 do -- codepoints
-    is(utf8.codepoint("A\u{20AC}3"), 0x41, "function codepoint")
-    is(utf8.codepoint("A\u{20AC}3", 2), 0x20AC)
-    is(utf8.codepoint("A\u{20AC}3", -1), 0x33)
-    is(utf8.codepoint("A\u{20AC}3", 5), 0x33)
-    eq_array({utf8.codepoint("A\u{20AC}3", 1, 5)}, {0x41, 0x20AC, 0x33})
-    eq_array({utf8.codepoint("A\u{20AC}3", 1, 4)}, {0x41, 0x20AC})
-
-    error_like(function () utf8.codepoint("A\u{20AC}3", 6) end,
-               "^[^:]+:%d+: bad argument #3 to 'codepoint' %(out of ",
-               "function codepoint (out of range)")
-
-    error_like(function () utf8.codepoint("A\u{20AC}3", 8) end,
-               "^[^:]+:%d+: bad argument #3 to 'codepoint' %(out of ",
-               "function codepoint (out of range)")
-
-    error_like(function () utf8.codepoint("invalid\xFF", 8) end,
-               "^[^:]+:%d+: invalid UTF%-8 code",
-               "function codepoint (invalid)")
+    equals(utf8.codepoint("A\u{20AC}3"), 0x41, "function codepoint")
+    equals(utf8.codepoint("A\u{20AC}3", 2), 0x20AC)
+    equals(utf8.codepoint("A\u{20AC}3", -1), 0x33)
+    equals(utf8.codepoint("A\u{20AC}3", 5), 0x33)
+    array_equals({utf8.codepoint("A\u{20AC}3", 1, 5)}, {0x41, 0x20AC, 0x33})
+    array_equals({utf8.codepoint("A\u{20AC}3", 1, 4)}, {0x41, 0x20AC})
+
+    error_matches(function () utf8.codepoint("A\u{20AC}3", 6) end,
+            "^[^:]+:%d+: bad argument #3 to 'codepoint' %(out of ",
+            "function codepoint (out of range)")
+
+    error_matches(function () utf8.codepoint("A\u{20AC}3", 8) end,
+            "^[^:]+:%d+: bad argument #3 to 'codepoint' %(out of ",
+            "function codepoint (out of range)")
+
+    error_matches(function () utf8.codepoint("invalid\xFF", 8) end,
+            "^[^:]+:%d+: invalid UTF%-8 code",
+            "function codepoint (invalid)")
 end
 
 do -- len
-    is(utf8.len('A'), 1, "function len")
-    is(utf8.len(''), 0)
-    is(utf8.len("\u{41}\u{42}\u{43}"), 3)
-    is(utf8.len("A\u{20AC}3"), 3)
-
-    is(utf8.len('A', 1), 1)
-    is(utf8.len('A', 2), 0)
-    is(utf8.len('ABC', 1, 1), 1)
-    is(utf8.len('ABC', 2, 2), 1)
-    is(utf8.len('ABC', -1), 1)
-    is(utf8.len('ABC', -2), 2)
-
-    error_like(function () utf8.len('A', 3) end,
-               "^[^:]+:%d+: bad argument #2 to 'len' %(initial position out of ",
-               "function len (out of range)")
+    equals(utf8.len('A'), 1, "function len")
+    equals(utf8.len(''), 0)
+    equals(utf8.len("\u{41}\u{42}\u{43}"), 3)
+    equals(utf8.len("A\u{20AC}3"), 3)
+
+    equals(utf8.len('A', 1), 1)
+    equals(utf8.len('A', 2), 0)
+    equals(utf8.len('ABC', 1, 1), 1)
+    equals(utf8.len('ABC', 2, 2), 1)
+    equals(utf8.len('ABC', -1), 1)
+    equals(utf8.len('ABC', -2), 2)
+
+    error_matches(function () utf8.len('A', 3) end,
+            "^[^:]+:%d+: bad argument #2 to 'len' %(initial position out of ",
+            "function len (out of range)")
 
     local len, pos = utf8.len('invalid\xFF')
-    is(len, nil, "function len (invalid)")
-    is(pos, 8)
+    equals(len, nil, "function len (invalid)")
+    equals(pos, 8)
 end
 
 do -- offset
-    is(utf8.offset("A\u{20AC}3", 1), 1, "function offset")
-    is(utf8.offset("A\u{20AC}3", 2), 2)
-    is(utf8.offset("A\u{20AC}3", 3), 5)
-    is(utf8.offset("A\u{20AC}3", 4), 6)
-    is(utf8.offset("A\u{20AC}3", 5), nil)
-    is(utf8.offset("A\u{20AC}3", 6), nil)
-    is(utf8.offset("A\u{20AC}3", -1), 5)
-    is(utf8.offset("A\u{20AC}3", 1, 2), 2)
-    is(utf8.offset("A\u{20AC}3", 2, 2), 5)
-    is(utf8.offset("A\u{20AC}3", 3, 2), 6)
-    is(utf8.offset("A\u{20AC}3", 4, 2), nil)
-    is(utf8.offset("A\u{20AC}3", -1, 2), 1)
-    is(utf8.offset("A\u{20AC}3", -2, 2), nil)
-    is(utf8.offset("A\u{20AC}3", 1, 5), 5)
-    is(utf8.offset("A\u{20AC}3", 2, 5), 6)
-    is(utf8.offset("A\u{20AC}3", 3, 5), nil)
-    is(utf8.offset("A\u{20AC}3", -1, 5), 2)
-    is(utf8.offset("A\u{20AC}3", -2, 5), 1)
-    is(utf8.offset("A\u{20AC}3", -3, 5), nil)
-    is(utf8.offset("A\u{20AC}3", 1, 6), 6)
-    is(utf8.offset("A\u{20AC}3", 2, 6), nil)
-    is(utf8.offset("A\u{20AC}3", 1, -1), 5)
-    is(utf8.offset("A\u{20AC}3", -1, -1), 2)
-    is(utf8.offset("A\u{20AC}3", -2, -1), 1)
-    is(utf8.offset("A\u{20AC}3", -3, -1), nil)
-    is(utf8.offset("A\u{20AC}3", 1, -4), 2)
-    is(utf8.offset("A\u{20AC}3", 2, -4), 5)
-    is(utf8.offset("A\u{20AC}3", -1, -4), 1)
-    is(utf8.offset("A\u{20AC}3", -2, -4), nil)
-
-    is(utf8.offset("A\u{20AC}3", 0, 1), 1)
-    is(utf8.offset("A\u{20AC}3", 0, 2), 2)
-    is(utf8.offset("A\u{20AC}3", 0, 3), 2)
-    is(utf8.offset("A\u{20AC}3", 0, 4), 2)
-    is(utf8.offset("A\u{20AC}3", 0, 5), 5)
-    is(utf8.offset("A\u{20AC}3", 0, 6), 6)
-
-    error_like(function () utf8.offset("A\u{20AC}3", 1, 7) end,
-               "^[^:]+:%d+: bad argument #3 to 'offset' %(position out of ",
-              "function offset (out of range)")
-
-    error_like(function () utf8.offset("\x80", 1) end,
-               "^[^:]+:%d+: initial position is a continuation byte",
-               "function offset (continuation byte)")
+    equals(utf8.offset("A\u{20AC}3", 1), 1, "function offset")
+    equals(utf8.offset("A\u{20AC}3", 2), 2)
+    equals(utf8.offset("A\u{20AC}3", 3), 5)
+    equals(utf8.offset("A\u{20AC}3", 4), 6)
+    equals(utf8.offset("A\u{20AC}3", 5), nil)
+    equals(utf8.offset("A\u{20AC}3", 6), nil)
+    equals(utf8.offset("A\u{20AC}3", -1), 5)
+    equals(utf8.offset("A\u{20AC}3", 1, 2), 2)
+    equals(utf8.offset("A\u{20AC}3", 2, 2), 5)
+    equals(utf8.offset("A\u{20AC}3", 3, 2), 6)
+    equals(utf8.offset("A\u{20AC}3", 4, 2), nil)
+    equals(utf8.offset("A\u{20AC}3", -1, 2), 1)
+    equals(utf8.offset("A\u{20AC}3", -2, 2), nil)
+    equals(utf8.offset("A\u{20AC}3", 1, 5), 5)
+    equals(utf8.offset("A\u{20AC}3", 2, 5), 6)
+    equals(utf8.offset("A\u{20AC}3", 3, 5), nil)
+    equals(utf8.offset("A\u{20AC}3", -1, 5), 2)
+    equals(utf8.offset("A\u{20AC}3", -2, 5), 1)
+    equals(utf8.offset("A\u{20AC}3", -3, 5), nil)
+    equals(utf8.offset("A\u{20AC}3", 1, 6), 6)
+    equals(utf8.offset("A\u{20AC}3", 2, 6), nil)
+    equals(utf8.offset("A\u{20AC}3", 1, -1), 5)
+    equals(utf8.offset("A\u{20AC}3", -1, -1), 2)
+    equals(utf8.offset("A\u{20AC}3", -2, -1), 1)
+    equals(utf8.offset("A\u{20AC}3", -3, -1), nil)
+    equals(utf8.offset("A\u{20AC}3", 1, -4), 2)
+    equals(utf8.offset("A\u{20AC}3", 2, -4), 5)
+    equals(utf8.offset("A\u{20AC}3", -1, -4), 1)
+    equals(utf8.offset("A\u{20AC}3", -2, -4), nil)
+
+    equals(utf8.offset("A\u{20AC}3", 0, 1), 1)
+    equals(utf8.offset("A\u{20AC}3", 0, 2), 2)
+    equals(utf8.offset("A\u{20AC}3", 0, 3), 2)
+    equals(utf8.offset("A\u{20AC}3", 0, 4), 2)
+    equals(utf8.offset("A\u{20AC}3", 0, 5), 5)
+    equals(utf8.offset("A\u{20AC}3", 0, 6), 6)
+
+    error_matches(function () utf8.offset("A\u{20AC}3", 1, 7) end,
+            "^[^:]+:%d+: bad argument #3 to 'offset' %(position out of ",
+            "function offset (out of range)")
+
+    error_matches(function () utf8.offset("\x80", 1) end,
+            "^[^:]+:%d+: initial position is a continuation byte",
+            "function offset (continuation byte)")
 end
 
 -- Local Variables:
diff --git a/test/lua-Harness-tests/lexico54/lexico.t b/test/lua-Harness-tests/lexico54/lexico.t
index 4523a51a..af14e71c 100644
--- a/test/lua-Harness-tests/lexico54/lexico.t
+++ b/test/lua-Harness-tests/lexico54/lexico.t
@@ -1,15 +1,15 @@
 --
 -- lua-Harness : <https://fperrad.frama.io/lua-Harness/>
 --
--- Copyright (C) 2019, Perrad Francois
+-- Copyright (C) 2019-2021, Perrad Francois
 --
 -- This code is licensed under the terms of the MIT/X11 license,
 -- like Lua itself.
 --
 
-is("\u{10000}", "\xF0\x90\x80\x80")
-is("\u{200000}", "\xF8\x88\x80\x80\x80")
-is("\u{4000000}", "\xFC\x84\x80\x80\x80\x80")
+equals("\u{10000}", "\xF0\x90\x80\x80")
+equals("\u{200000}", "\xF8\x88\x80\x80\x80")
+equals("\u{4000000}", "\xFC\x84\x80\x80\x80\x80")
 
 -- Local Variables:
 --   mode: lua
diff --git a/test/lua-Harness-tests/lexico54/metatable.t b/test/lua-Harness-tests/lexico54/metatable.t
index 4685b341..32878b3d 100644
--- a/test/lua-Harness-tests/lexico54/metatable.t
+++ b/test/lua-Harness-tests/lexico54/metatable.t
@@ -1,7 +1,7 @@
 --
 -- lua-Harness : <https://fperrad.frama.io/lua-Harness/>
 --
--- Copyright (C) 2019-2020, Perrad Francois
+-- Copyright (C) 2019-2021, Perrad Francois
 --
 -- This code is licensed under the terms of the MIT/X11 license,
 -- like Lua itself.
@@ -11,15 +11,15 @@ do -- toclose
     local called = false
     do
         local foo <close> = setmetatable({}, { __close = function () called = true end })
-        type_ok(foo, 'table', "toclose")
-        is(called, false)
+        is_table(foo, "toclose")
+        is_false(called)
     end
-    is(called, true)
+    is_true(called)
 
-    error_like(function () do local foo <close> = {} end end,
-               "^[^:]+:%d+: variable 'foo' got a non%-closable value")
+    error_matches(function () do local foo <close> = {} end end,
+            "^[^:]+:%d+: variable 'foo' got a non%-closable value")
 
-    lives_ok(function ()
+    not_errors(function ()
         local var1 <const> = nil
         local var2 <const> = nil
         do
diff --git a/test/lua-Harness-tests/lexico54/utf8.t b/test/lua-Harness-tests/lexico54/utf8.t
index 1aa70cc6..a3dfddc2 100644
--- a/test/lua-Harness-tests/lexico54/utf8.t
+++ b/test/lua-Harness-tests/lexico54/utf8.t
@@ -1,7 +1,7 @@
 --
 -- lua-Harness : <https://fperrad.frama.io/lua-Harness/>
 --
--- Copyright (C) 2019, Perrad Francois
+-- Copyright (C) 2019-2021, Perrad Francois
 --
 -- This code is licensed under the terms of the MIT/X11 license,
 -- like Lua itself.
@@ -14,36 +14,36 @@ do -- codes
         ap[#ap+1] = p
         ac[#ac+1] = c
     end
-    eq_array(ap, {1, 2, 7}, "function codes lax")
-    eq_array(ac, {0x41, 0x200000, 0x33})
+    array_equals(ap, {1, 2, 7}, "function codes lax")
+    array_equals(ac, {0x41, 0x200000, 0x33})
 
-    error_like(function () for _ in utf8.codes("A\u{200000}3", false) do end end,
-               "^[^:]+:%d+: invalid UTF%-8 code")
+    error_matches(function () for _ in utf8.codes("A\u{200000}3", false) do end end,
+            "^[^:]+:%d+: invalid UTF%-8 code")
 
-    error_like(function () for _ in utf8.codes("A\u{200000}3") do end end,
-               "^[^:]+:%d+: invalid UTF%-8 code")
+    error_matches(function () for _ in utf8.codes("A\u{200000}3") do end end,
+            "^[^:]+:%d+: invalid UTF%-8 code")
 end
 
 do -- codepoints
-    eq_array({utf8.codepoint("A\u{200000}3", 1, 7, true)}, {0x41, 0x200000, 0x33}, "function codepoint lax")
+    array_equals({utf8.codepoint("A\u{200000}3", 1, 7, true)}, {0x41, 0x200000, 0x33}, "function codepoint lax")
 
-    error_like(function () utf8.codepoint("A\u{200000}3", 1, 7, false) end,
-               "^[^:]+:%d+: invalid UTF%-8 code")
+    error_matches(function () utf8.codepoint("A\u{200000}3", 1, 7, false) end,
+            "^[^:]+:%d+: invalid UTF%-8 code")
 
-    error_like(function () utf8.codepoint("A\u{200000}3", 1, 7) end,
-               "^[^:]+:%d+: invalid UTF%-8 code")
+    error_matches(function () utf8.codepoint("A\u{200000}3", 1, 7) end,
+            "^[^:]+:%d+: invalid UTF%-8 code")
 end
 
 do -- len
-    is(utf8.len('A\u{200000}C', 1, -1, true), 3, "function len lax")
+    equals(utf8.len('A\u{200000}C', 1, -1, true), 3, "function len lax")
 
     local len, pos = utf8.len('A\u{200000}C')
-    is(len, nil)
-    is(pos, 2)
+    equals(len, nil)
+    equals(pos, 2)
 
     len, pos = utf8.len('A\u{200000}C', 1, -1, false)
-    is(len, nil)
-    is(pos, 2)
+    equals(len, nil)
+    equals(pos, 2)
 end
 
 -- Local Variables:
diff --git a/test/lua-Harness-tests/lexicojit/basic.t b/test/lua-Harness-tests/lexicojit/basic.t
index 8ad3a59b..2925e06f 100644
--- a/test/lua-Harness-tests/lexicojit/basic.t
+++ b/test/lua-Harness-tests/lexicojit/basic.t
@@ -1,22 +1,22 @@
 --
 -- lua-Harness : <https://fperrad.frama.io/lua-Harness/>
 --
--- Copyright (C) 2018, Perrad Francois
+-- Copyright (C) 2018-2021, Perrad Francois
 --
 -- This code is licensed under the terms of the MIT/X11 license,
 -- like Lua itself.
 --
 
 do -- tonumber
-    is(tonumber(42uLL), 42, "function tonumber (cdata)")
-    is(tonumber(42LL), 42)
+    equals(tonumber(42uLL), 42, "function tonumber (cdata)")
+    equals(tonumber(42LL), 42)
 end
 
 do -- tostring
-    is(tostring(42uLL), '42ULL', "function tostring (cdata)")
-    is(tostring(42LL), '42LL')
-    is(tostring(1i), '0+1i')
-    is(tostring(12.5i), '0+12.5i')
+    equals(tostring(42uLL), '42ULL', "function tostring (cdata)")
+    equals(tostring(42LL), '42LL')
+    equals(tostring(1i), '0+1i')
+    equals(tostring(12.5i), '0+12.5i')
 end
 
 -- Local Variables:
diff --git a/test/lua-Harness-tests/lexicojit/ext.t b/test/lua-Harness-tests/lexicojit/ext.t
index 8c44b99b..d044e2bb 100644
--- a/test/lua-Harness-tests/lexicojit/ext.t
+++ b/test/lua-Harness-tests/lexicojit/ext.t
@@ -1,7 +1,7 @@
 --
 -- lua-Harness : <https://fperrad.frama.io/lua-Harness/>
 --
--- Copyright (C) 2019-2020, Perrad Francois
+-- Copyright (C) 2019-2021, Perrad Francois
 --
 -- This code is licensed under the terms of the MIT/X11 license,
 -- like Lua itself.
@@ -11,37 +11,37 @@ local profile = require'profile'
 
 do -- thread.exdata
     local r, exdata = pcall(require, 'thread.exdata')
-    is(r, true, 'thread.exdata')
-    type_ok(exdata, 'function')
-    is(package.loaded['thread.exdata'], exdata)
+    is_true(r, 'thread.exdata')
+    is_function(exdata)
+    equals(package.loaded['thread.exdata'], exdata)
 
     local ffi = require'ffi'
     local u64 = ffi.new('uintptr_t', 0xefdeaddeadbeefLL)
     local ptr = ffi.cast('void *', u64)
     exdata(u64)  -- set
-    is(exdata(), ptr) -- get
+    equals(exdata(), ptr) -- get
 
-    error_like(function () exdata(42) end,
-               "^[^:]+:%d+: bad argument #1 to 'exdata' %(cdata expected, got number%)")
+    error_matches(function () exdata(42) end,
+            "^[^:]+:%d+: bad argument #1 to 'exdata' %(cdata expected, got number%)")
 end
 
 -- thread.exdata2
 if profile.openresty then
     local r, exdata2 = pcall(require, 'thread.exdata2')
-    is(r, true, 'thread.exdata2')
-    type_ok(exdata2, 'function')
-    is(package.loaded['thread.exdata2'], exdata2)
+    is_true(r, 'thread.exdata2')
+    is_function(exdata2)
+    equals(package.loaded['thread.exdata2'], exdata2)
 
     local ffi = require'ffi'
     local u64 = ffi.new('uintptr_t', 0xefdeaddeadbeefLL)
     local ptr = ffi.cast('void *', u64)
     exdata2(u64)  -- set
-    is(exdata2(), ptr) -- get
+    equals(exdata2(), ptr) -- get
 
-    error_like(function () exdata2(42) end,
+    error_matches(function () exdata2(42) end,
                "^[^:]+:%d+: bad argument #1 to 'exdata2' %(cdata expected, got number%)")
 else
-    is(pcall(require, 'thread.exdata2'), false, 'no thread.exdata2')
+    is_false(pcall(require, 'thread.exdata2'), 'no thread.exdata2')
 end
 
 -- Local Variables:
diff --git a/test/lua-Harness-tests/lexicojit/lexico.t b/test/lua-Harness-tests/lexicojit/lexico.t
index 1a973b5b..72992907 100644
--- a/test/lua-Harness-tests/lexicojit/lexico.t
+++ b/test/lua-Harness-tests/lexicojit/lexico.t
@@ -1,28 +1,28 @@
 --
 -- lua-Harness : <https://fperrad.frama.io/lua-Harness/>
 --
--- Copyright (C) 2018, Perrad Francois
+-- Copyright (C) 2018-2021, Perrad Francois
 --
 -- This code is licensed under the terms of the MIT/X11 license,
 -- like Lua itself.
 --
 
-type_ok(42LL, 'cdata', "42LL")
-type_ok(42ULL, 'cdata', "42ULL")
-type_ok(42uLL, 'cdata', "42uLL")
-type_ok(42ull, 'cdata', "42ull")
+is_cdata(42LL, "42LL")
+is_cdata(42ULL, "42ULL")
+is_cdata(42uLL, "42uLL")
+is_cdata(42ull, "42ull")
 
-type_ok(0x2aLL, 'cdata', "0x2aLL")
-type_ok(0x2aULL, 'cdata', "0x2aULL")
-type_ok(0x2auLL, 'cdata', "0x2auLL")
-type_ok(0x2aull, 'cdata', "0x2aull")
+is_cdata(0x2aLL, "0x2aLL")
+is_cdata(0x2aULL, "0x2aULL")
+is_cdata(0x2auLL, "0x2auLL")
+is_cdata(0x2aull, "0x2aull")
 
-type_ok(12.5i, 'cdata', '12.5i')
-type_ok(12.5I, 'cdata', '12.5I')
-type_ok(1i, 'cdata', '1i')
-type_ok(1I, 'cdata', '1I')
-type_ok(0i, 'cdata', '0i')
-type_ok(0I, 'cdata', '0I')
+is_cdata(12.5i, '12.5i')
+is_cdata(12.5I, '12.5I')
+is_cdata(1i, '1i')
+is_cdata(1I, '1I')
+is_cdata(0i, '0i')
+is_cdata(0I, '0I')
 
 -- Local Variables:
 --   mode: lua
diff --git a/test/lua-Harness-tests/tap.lua b/test/lua-Harness-tests/tap.lua
index a8454ae0..f50cc319 100644
--- a/test/lua-Harness-tests/tap.lua
+++ b/test/lua-Harness-tests/tap.lua
@@ -9,8 +9,8 @@
 
 ]]
 
-if pcall(require, 'Test.More') then
-    diag 'Test.More loaded'
+if pcall(require, 'Test.Assertion') then
+    diag 'Test.Assertion loaded'
     return
 end
 
@@ -46,7 +46,7 @@ function skip_all (reason)
     os.exit(0)
 end
 
-function ok (test, name)
+function truthy (test, name)
     curr_test = curr_test + 1
     local out = ''
     if not test then
@@ -62,69 +62,93 @@ function ok (test, name)
     print(out)
 end
 
-function nok (test, name)
-    ok(not test, name)
+function falsy (test, name)
+    truthy(not test, name)
 end
 
-function is (got, expected, name)
+function equals (got, expected, name)
     local pass = got == expected
-    ok(pass, name)
+    truthy(pass, name)
     if not pass then
         diag("         got: " .. tostring(got))
         diag("    expected: " .. tostring(expected))
     end
 end
 
-function isnt (got, not_expected, name)
+function not_equals (got, not_expected, name)
     local pass = got ~= not_expected
-    ok(pass, name)
+    truthy(pass, name)
     if not pass then
         diag("         got: " .. tostring(got))
         diag("    expected: anything else")
     end
 end
 
-function like (got, pattern, name)
+function matches (got, pattern, name)
     local pass = tostring(got):match(pattern)
-    ok(pass, name)
+    truthy(pass, name)
     if not pass then
         diag("                  " .. tostring(got))
         diag("    doesn't match '" .. tostring(pattern) .. "'")
     end
 end
 
-function type_ok (val, t, name)
-    if type(val) == t then
-        ok(true, name)
-    else
-        ok(false, name)
-        diag("    " .. tostring(val) .. " isn't a '" .. t .."' it's '" .. type(val) .. "'")
+local function is_type (t)
+    return function (val, name)
+        if type(val) == t then
+            truthy(true, name)
+        else
+            truthy(false, name)
+            diag("    " .. tostring(val) .. " isn't a '" .. t .."' it's a '" .. type(val) .. "'")
+        end
+    end
+end
+is_boolean = is_type('boolean')
+is_cdata = is_type('cdata')
+is_function = is_type('function')
+is_number = is_type('number')
+is_string = is_type('string')
+is_table = is_type('table')
+is_thread = is_type('thread')
+is_userdata = is_type('userdata')
+
+local function is_value (expected)
+    return function (got, name)
+        local pass = got == expected
+        truthy(pass, name)
+        if not pass then
+            diag("         got: " .. tostring(got))
+            diag("    expected: " .. tostring(expected))
+        end
     end
 end
+is_nil = is_value(nil)
+is_true = is_value(true)
+is_false = is_value(false)
 
-function pass (name)
-    ok(true, name)
+function passes (name)
+    truthy(true, name)
 end
 
-function fail (name)
-    ok(false, name)
+function fails (name)
+    truthy(false, name)
 end
 
 function require_ok (mod)
     local r, msg = pcall(require, mod)
-    ok(r, "require '" .. mod .. "'")
+    truthy(r, "require '" .. mod .. "'")
     if not r then
         diag("    " .. msg)
     end
     return r
 end
 
-function eq_array (got, expected, name)
+function array_equals (got, expected, name)
     for i = 1, #expected do
         local v = expected[i]
         local val = got[i]
         if val ~= v then
-            ok(false, name)
+            truthy(false, name)
             diag("    at index: " .. tostring(i))
             diag("         got: " .. tostring(val))
             diag("    expected: " .. tostring(v))
@@ -133,38 +157,38 @@ function eq_array (got, expected, name)
     end
     local extra = #got - #expected
     if extra ~= 0 then
-        ok(false, name)
+        truthy(false, name)
         diag("    " .. tostring(extra) .. " unexpected item(s)")
     else
-        ok(true, name)
+        truthy(true, name)
     end
 end
 
-function error_is (code, expected, name)
+function error_equals (code, expected, name)
     local r, msg = pcall(code)
     if r then
-        ok(false, name)
+        truthy(false, name)
         diag("    unexpected success")
         diag("    expected: " .. tostring(pattern))
     else
-        is(msg, expected, name)
+        equals(msg, expected, name)
     end
 end
 
-function error_like (code, pattern, name)
+function error_matches (code, pattern, name)
     local r, msg = pcall(code)
     if r then
-        ok(false, name)
+        truthy(false, name)
         diag("    unexpected success")
         diag("    expected: " .. tostring(pattern))
     else
-        like(msg, pattern, name)
+        matches(msg, pattern, name)
     end
 end
 
-function lives_ok (code, name)
+function not_errors (code, name)
     local r, msg = pcall(code)
-    ok(r, name)
+    truthy(r, name)
     if not r then
         diag("    " .. msg)
     end
@@ -181,7 +205,7 @@ function skip (reason, count)
         name = name .. " " ..reason
     end
     for i = 1, count do
-        ok(true, name)
+        truthy(true, name)
     end
 end
 
@@ -214,7 +238,7 @@ function make_specific_checks (filename)
 end
 
 --
--- Copyright (c) 2009-2018 Francois Perrad
+-- Copyright (c) 2009-2021 Francois Perrad
 --
 -- This library is licensed under the terms of the MIT/X11 license,
 -- like Lua itself.
-- 
2.32.0


^ permalink raw reply	[flat|nested] 22+ messages in thread

* [Tarantool-patches] [PATCH v2 02/10] test: rename lua-Harness tap to test_assertion
  2021-07-20 16:26 [Tarantool-patches] [PATCH v2 00/10] test: lua-Harness suite patch bump Maxim Kokryashkin via Tarantool-patches
  2021-07-20 16:26 ` [Tarantool-patches] [PATCH v2 01/10] test: port lua-Harness to Test.Assertion Maxim Kokryashkin via Tarantool-patches
@ 2021-07-20 16:26 ` Maxim Kokryashkin via Tarantool-patches
  2021-07-25 21:08   ` Igor Munkin via Tarantool-patches
  2021-07-20 16:26 ` [Tarantool-patches] [PATCH v2 03/10] test: use CI friendly variables in lua-Harness Maxim Kokryashkin via Tarantool-patches
                   ` (8 subsequent siblings)
  10 siblings, 1 reply; 22+ messages in thread
From: Maxim Kokryashkin via Tarantool-patches @ 2021-07-20 16:26 UTC (permalink / raw)
  To: tarantool-patches, imun, skaplun

In scope of this patch[1] from lua-Harness assertion module tap.lua is
renamed to test_assertion.lua to avoid name collision with Tarantool
tap builtin module.

[1]: https://framagit.org/fperrad/lua-Harness/-/commit/8041c45

Part of tarantool/tarantool#5970
Part of tarantool/tarantool#4473
---
 test/lua-Harness-tests/090-tap.t                       | 2 +-
 test/lua-Harness-tests/091-profile.t                   | 2 +-
 test/lua-Harness-tests/101-boolean.t                   | 2 +-
 test/lua-Harness-tests/102-function.t                  | 2 +-
 test/lua-Harness-tests/103-nil.t                       | 2 +-
 test/lua-Harness-tests/104-number.t                    | 2 +-
 test/lua-Harness-tests/105-string.t                    | 2 +-
 test/lua-Harness-tests/106-table.t                     | 2 +-
 test/lua-Harness-tests/107-thread.t                    | 2 +-
 test/lua-Harness-tests/108-userdata.t                  | 2 +-
 test/lua-Harness-tests/200-examples.t                  | 2 +-
 test/lua-Harness-tests/201-assign.t                    | 2 +-
 test/lua-Harness-tests/202-expr.t                      | 2 +-
 test/lua-Harness-tests/203-lexico.t                    | 2 +-
 test/lua-Harness-tests/204-grammar.t                   | 2 +-
 test/lua-Harness-tests/211-scope.t                     | 2 +-
 test/lua-Harness-tests/212-function.t                  | 2 +-
 test/lua-Harness-tests/213-closure.t                   | 2 +-
 test/lua-Harness-tests/214-coroutine.t                 | 2 +-
 test/lua-Harness-tests/221-table.t                     | 2 +-
 test/lua-Harness-tests/222-constructor.t               | 2 +-
 test/lua-Harness-tests/223-iterator.t                  | 2 +-
 test/lua-Harness-tests/231-metatable.t                 | 2 +-
 test/lua-Harness-tests/232-object.t                    | 2 +-
 test/lua-Harness-tests/241-standalone.t.disabled       | 2 +-
 test/lua-Harness-tests/242-luac.t                      | 2 +-
 test/lua-Harness-tests/301-basic.t                     | 2 +-
 test/lua-Harness-tests/303-package.t                   | 8 ++++----
 test/lua-Harness-tests/304-string.t                    | 2 +-
 test/lua-Harness-tests/305-utf8.t                      | 2 +-
 test/lua-Harness-tests/306-table.t                     | 2 +-
 test/lua-Harness-tests/307-math.t                      | 2 +-
 test/lua-Harness-tests/308-io.t                        | 2 +-
 test/lua-Harness-tests/309-os.t                        | 2 +-
 test/lua-Harness-tests/310-debug.t                     | 2 +-
 test/lua-Harness-tests/311-bit32.t                     | 2 +-
 test/lua-Harness-tests/314-regex.t                     | 2 +-
 test/lua-Harness-tests/320-stdin.t                     | 2 +-
 test/lua-Harness-tests/401-bitop.t                     | 2 +-
 test/lua-Harness-tests/402-ffi.t                       | 2 +-
 test/lua-Harness-tests/403-jit.t                       | 2 +-
 test/lua-Harness-tests/404-ext.t                       | 2 +-
 test/lua-Harness-tests/411-luajit.t.disabled           | 2 +-
 test/lua-Harness-tests/{tap.lua => test_assertion.lua} | 0
 44 files changed, 46 insertions(+), 46 deletions(-)
 rename test/lua-Harness-tests/{tap.lua => test_assertion.lua} (100%)

diff --git a/test/lua-Harness-tests/090-tap.t b/test/lua-Harness-tests/090-tap.t
index 47a9b613..ff4565a4 100755
--- a/test/lua-Harness-tests/090-tap.t
+++ b/test/lua-Harness-tests/090-tap.t
@@ -22,7 +22,7 @@
 
 ]]
 
-require'tap'
+require'test_assertion'
 
 plan(3)
 truthy( true, 'truthy' )
diff --git a/test/lua-Harness-tests/091-profile.t b/test/lua-Harness-tests/091-profile.t
index 53220569..5f4010fc 100755
--- a/test/lua-Harness-tests/091-profile.t
+++ b/test/lua-Harness-tests/091-profile.t
@@ -22,7 +22,7 @@
 
 ]]
 
-require'tap'
+require'test_assertion'
 
 plan'no_plan'
 
diff --git a/test/lua-Harness-tests/101-boolean.t b/test/lua-Harness-tests/101-boolean.t
index 95a3c0bd..eb8b6bbd 100755
--- a/test/lua-Harness-tests/101-boolean.t
+++ b/test/lua-Harness-tests/101-boolean.t
@@ -22,7 +22,7 @@
 
 ]]
 
-require'tap'
+require'test_assertion'
 local has_op53 = _VERSION >= 'Lua 5.3'
 
 plan'no_plan'
diff --git a/test/lua-Harness-tests/102-function.t b/test/lua-Harness-tests/102-function.t
index 26ced043..a0a3ad33 100755
--- a/test/lua-Harness-tests/102-function.t
+++ b/test/lua-Harness-tests/102-function.t
@@ -22,7 +22,7 @@
 
 --]]
 
-require'tap'
+require'test_assertion'
 local has_op53 = _VERSION >= 'Lua 5.3'
 
 plan'no_plan'
diff --git a/test/lua-Harness-tests/103-nil.t b/test/lua-Harness-tests/103-nil.t
index 90a3b4f3..718fde16 100755
--- a/test/lua-Harness-tests/103-nil.t
+++ b/test/lua-Harness-tests/103-nil.t
@@ -22,7 +22,7 @@
 
 --]]
 
-require'tap'
+require'test_assertion'
 local has_op53 = _VERSION >= 'Lua 5.3'
 
 plan'no_plan'
diff --git a/test/lua-Harness-tests/104-number.t b/test/lua-Harness-tests/104-number.t
index a41c5951..872042c0 100755
--- a/test/lua-Harness-tests/104-number.t
+++ b/test/lua-Harness-tests/104-number.t
@@ -22,7 +22,7 @@
 
 --]]
 
-require'tap'
+require'test_assertion'
 local profile = require'profile'
 local has_op53 = _VERSION >= 'Lua 5.3'
 
diff --git a/test/lua-Harness-tests/105-string.t b/test/lua-Harness-tests/105-string.t
index af8c90b7..22e6cfa6 100755
--- a/test/lua-Harness-tests/105-string.t
+++ b/test/lua-Harness-tests/105-string.t
@@ -22,7 +22,7 @@
 
 --]]
 
-require'tap'
+require'test_assertion'
 local profile = require'profile'
 local has_op53 = _VERSION >= 'Lua 5.3'
 
diff --git a/test/lua-Harness-tests/106-table.t b/test/lua-Harness-tests/106-table.t
index 03d45085..ecb761d2 100755
--- a/test/lua-Harness-tests/106-table.t
+++ b/test/lua-Harness-tests/106-table.t
@@ -22,7 +22,7 @@
 
 --]]
 
-require'tap'
+require'test_assertion'
 local has_op53 = _VERSION >= 'Lua 5.3'
 
 plan'no_plan'
diff --git a/test/lua-Harness-tests/107-thread.t b/test/lua-Harness-tests/107-thread.t
index 36003bab..33ebf769 100755
--- a/test/lua-Harness-tests/107-thread.t
+++ b/test/lua-Harness-tests/107-thread.t
@@ -22,7 +22,7 @@
 
 --]]
 
-require'tap'
+require'test_assertion'
 local has_op53 = _VERSION >= 'Lua 5.3'
 
 plan'no_plan'
diff --git a/test/lua-Harness-tests/108-userdata.t b/test/lua-Harness-tests/108-userdata.t
index 41b820d3..314a60e7 100755
--- a/test/lua-Harness-tests/108-userdata.t
+++ b/test/lua-Harness-tests/108-userdata.t
@@ -22,7 +22,7 @@
 
 --]]
 
-require'tap'
+require'test_assertion'
 local has_op53 = _VERSION >= 'Lua 5.3'
 
 plan'no_plan'
diff --git a/test/lua-Harness-tests/200-examples.t b/test/lua-Harness-tests/200-examples.t
index 708ee3bd..7020af4d 100755
--- a/test/lua-Harness-tests/200-examples.t
+++ b/test/lua-Harness-tests/200-examples.t
@@ -24,7 +24,7 @@ First tests in order to check infrastructure.
 
 --]]
 
-require'tap'
+require'test_assertion'
 
 plan(5)
 
diff --git a/test/lua-Harness-tests/201-assign.t b/test/lua-Harness-tests/201-assign.t
index 3e978091..968b019e 100755
--- a/test/lua-Harness-tests/201-assign.t
+++ b/test/lua-Harness-tests/201-assign.t
@@ -28,7 +28,7 @@ L<https://www.lua.org/manual/5.4/manual.html#3.3.3>
 
 --]]
 
-require'tap'
+require'test_assertion'
 local has_env = _VERSION >= 'Lua 5.2'
 
 plan'no_plan'
diff --git a/test/lua-Harness-tests/202-expr.t b/test/lua-Harness-tests/202-expr.t
index f86276af..0ac14f28 100755
--- a/test/lua-Harness-tests/202-expr.t
+++ b/test/lua-Harness-tests/202-expr.t
@@ -28,7 +28,7 @@ L<https://www.lua.org/manual/5.4/manual.html#3.4>
 
 --]]
 
-require'tap'
+require'test_assertion'
 local profile = require'profile'
 local nocvtn2s = profile.nocvtn2s
 local nocvts2n = profile.nocvts2n
diff --git a/test/lua-Harness-tests/203-lexico.t b/test/lua-Harness-tests/203-lexico.t
index 6143615c..c9345c71 100755
--- a/test/lua-Harness-tests/203-lexico.t
+++ b/test/lua-Harness-tests/203-lexico.t
@@ -31,7 +31,7 @@ L<https://www.lua.org/manual/5.4/manual.html#3.1>
 
 --]]
 
-require'tap'
+require'test_assertion'
 local loadstring = loadstring or load
 local luajit21 = jit and (jit.version_num >= 20100 or jit.version:match'^RaptorJIT')
 
diff --git a/test/lua-Harness-tests/204-grammar.t b/test/lua-Harness-tests/204-grammar.t
index c34fd28c..51671e99 100755
--- a/test/lua-Harness-tests/204-grammar.t
+++ b/test/lua-Harness-tests/204-grammar.t
@@ -28,7 +28,7 @@ L<https://www.lua.org/manual/5.4/manual.html#9>
 
 --]]
 
-require'tap'
+require'test_assertion'
 local profile = require'profile'
 local has_goto = _VERSION >= 'Lua 5.2' or jit
 local has_attr = _VERSION >= 'Lua 5.4'
diff --git a/test/lua-Harness-tests/211-scope.t b/test/lua-Harness-tests/211-scope.t
index 2c449ab5..4c25f6e4 100755
--- a/test/lua-Harness-tests/211-scope.t
+++ b/test/lua-Harness-tests/211-scope.t
@@ -30,7 +30,7 @@ See section "Local Variables and Blocks" in "Programming in Lua".
 
 --]]
 
-require'tap'
+require'test_assertion'
 
 plan(10)
 
diff --git a/test/lua-Harness-tests/212-function.t b/test/lua-Harness-tests/212-function.t
index 8325e79b..28c747e6 100755
--- a/test/lua-Harness-tests/212-function.t
+++ b/test/lua-Harness-tests/212-function.t
@@ -30,7 +30,7 @@ See section "Functions" in "Programming in Lua".
 
 --]]
 
-require'tap'
+require'test_assertion'
 local loadstring = loadstring or load
 
 plan(68)
diff --git a/test/lua-Harness-tests/213-closure.t b/test/lua-Harness-tests/213-closure.t
index 925a0b84..370f8956 100755
--- a/test/lua-Harness-tests/213-closure.t
+++ b/test/lua-Harness-tests/213-closure.t
@@ -24,7 +24,7 @@ See section "Closures" in "Programming in Lua".
 
 --]]
 
-require'tap'
+require'test_assertion'
 
 plan(15)
 
diff --git a/test/lua-Harness-tests/214-coroutine.t b/test/lua-Harness-tests/214-coroutine.t
index 3101f840..372810cf 100755
--- a/test/lua-Harness-tests/214-coroutine.t
+++ b/test/lua-Harness-tests/214-coroutine.t
@@ -30,7 +30,7 @@ See section "Coroutines" in "Programming in Lua".
 
 --]]
 
-require'tap'
+require'test_assertion'
 local profile = require'profile'
 local luajit21 = jit and (jit.version_num >= 20100 or jit.version:match'^RaptorJIT')
 local has_coroutine52 = _VERSION >= 'Lua 5.2' or jit
diff --git a/test/lua-Harness-tests/221-table.t b/test/lua-Harness-tests/221-table.t
index 1b4e6ff6..1b8c25a3 100755
--- a/test/lua-Harness-tests/221-table.t
+++ b/test/lua-Harness-tests/221-table.t
@@ -24,7 +24,7 @@ See section "Tables" in "Programming in Lua".
 
 --]]
 
-require'tap'
+require'test_assertion'
 
 plan(25)
 
diff --git a/test/lua-Harness-tests/222-constructor.t b/test/lua-Harness-tests/222-constructor.t
index ce89b9aa..0a945616 100755
--- a/test/lua-Harness-tests/222-constructor.t
+++ b/test/lua-Harness-tests/222-constructor.t
@@ -30,7 +30,7 @@ See section "Table Constructors" in "Programming in Lua".
 
 --]]
 
-require'tap'
+require'test_assertion'
 
 plan(16)
 
diff --git a/test/lua-Harness-tests/223-iterator.t b/test/lua-Harness-tests/223-iterator.t
index a95fd1fe..588534da 100755
--- a/test/lua-Harness-tests/223-iterator.t
+++ b/test/lua-Harness-tests/223-iterator.t
@@ -25,7 +25,7 @@ section "Coroutines as Iterators" in "Programming in Lua".
 
 --]]
 
-require'tap'
+require'test_assertion'
 
 plan(8)
 
diff --git a/test/lua-Harness-tests/231-metatable.t b/test/lua-Harness-tests/231-metatable.t
index 8d181d0e..15625c11 100755
--- a/test/lua-Harness-tests/231-metatable.t
+++ b/test/lua-Harness-tests/231-metatable.t
@@ -30,7 +30,7 @@ See section "Metatables and Metamethods" in "Programming in Lua".
 
 --]]
 
-require'tap'
+require'test_assertion'
 local profile = require'profile'
 local has_metamethod52 = _VERSION >= 'Lua 5.2' or profile.luajit_compat52
 local has_metamethod_ipairs = _VERSION == 'Lua 5.2' or profile.compat52 or profile.luajit_compat52
diff --git a/test/lua-Harness-tests/232-object.t b/test/lua-Harness-tests/232-object.t
index 583e37a6..8c56d3f6 100755
--- a/test/lua-Harness-tests/232-object.t
+++ b/test/lua-Harness-tests/232-object.t
@@ -24,7 +24,7 @@ See section "Object-Oriented Programming" in "Programming in Lua".
 
 --]]
 
-require'tap'
+require'test_assertion'
 
 plan(18)
 
diff --git a/test/lua-Harness-tests/241-standalone.t.disabled b/test/lua-Harness-tests/241-standalone.t.disabled
index deb5421d..a02ed5bf 100755
--- a/test/lua-Harness-tests/241-standalone.t.disabled
+++ b/test/lua-Harness-tests/241-standalone.t.disabled
@@ -28,7 +28,7 @@ L<https://www.lua.org/manual/5.4/manual.html#7>
 
 --]]
 
-require'tap'
+require'test_assertion'
 local has_bytecode = not ujit and not ravi
 local has_error52 = _VERSION >= 'Lua 5.2'
 local has_error53 = _VERSION >= 'Lua 5.3'
diff --git a/test/lua-Harness-tests/242-luac.t b/test/lua-Harness-tests/242-luac.t
index 9efabd01..0a2e160e 100755
--- a/test/lua-Harness-tests/242-luac.t
+++ b/test/lua-Harness-tests/242-luac.t
@@ -28,7 +28,7 @@ L<https://www.lua.org/manual/5.4/manual.html#7>
 
 --]]
 
-require'tap'
+require'test_assertion'
 
 if jit then
     skip_all("LuaJIT")
diff --git a/test/lua-Harness-tests/301-basic.t b/test/lua-Harness-tests/301-basic.t
index 415cc497..63f0004a 100755
--- a/test/lua-Harness-tests/301-basic.t
+++ b/test/lua-Harness-tests/301-basic.t
@@ -30,7 +30,7 @@ L<https://www.lua.org/manual/5.4/manual.html#6.1>
 
 --]]
 
-require'tap'
+require'test_assertion'
 local profile = require'profile'
 local has_error53 = _VERSION >= 'Lua 5.3'
 local has_gcinfo = _VERSION == 'Lua 5.1'
diff --git a/test/lua-Harness-tests/303-package.t b/test/lua-Harness-tests/303-package.t
index 1a1d7e05..ccd7c510 100755
--- a/test/lua-Harness-tests/303-package.t
+++ b/test/lua-Harness-tests/303-package.t
@@ -30,7 +30,7 @@ L<https://www.lua.org/manual/5.4/manual.html#6.3>
 
 --]]
 
-require'tap'
+require'test_assertion'
 local profile = require'profile'
 local luajit21 = jit and (jit.version_num >= 20100 or jit.version:match'^RaptorJIT')
 local has_loaders = _VERSION == 'Lua 5.1'
@@ -130,10 +130,10 @@ end
 
 -- searchpath
 if has_searcherpath then
-    local p = package.searchpath('tap', package.path)
+    local p = package.searchpath('test_assertion', package.path)
     is_string(p, "searchpath")
-    matches(p, "tap.lua$", "searchpath")
-    p = package.searchpath('tap', 'bad path')
+    matches(p, "test_assertion.lua$", "searchpath")
+    p = package.searchpath('test_assertion', 'bad path')
     is_nil(p)
 else
     is_nil(package.searchpath, "no package.searchpath")
diff --git a/test/lua-Harness-tests/304-string.t b/test/lua-Harness-tests/304-string.t
index 7011a88e..82e0408d 100755
--- a/test/lua-Harness-tests/304-string.t
+++ b/test/lua-Harness-tests/304-string.t
@@ -30,7 +30,7 @@ L<https://www.lua.org/manual/5.4/manual.html#6.4>
 
 ]]
 
-require'tap'
+require'test_assertion'
 local profile = require'profile'
 local luajit21 = jit and (jit.version_num >= 20100 or jit.version:match'^RaptorJIT')
 local has_dump53 = _VERSION >= 'Lua 5.3' or jit
diff --git a/test/lua-Harness-tests/305-utf8.t b/test/lua-Harness-tests/305-utf8.t
index be0ace6e..e448a448 100755
--- a/test/lua-Harness-tests/305-utf8.t
+++ b/test/lua-Harness-tests/305-utf8.t
@@ -30,7 +30,7 @@ L<https://www.lua.org/manual/5.4/manual.html#6.5>
 
 --]]
 
-require 'tap'
+require 'test_assertion'
 
 local profile = require'profile'
 local has_utf8 = _VERSION >= 'Lua 5.3' or (jit and jit.version:match'moonjit') or profile.utf8
diff --git a/test/lua-Harness-tests/306-table.t b/test/lua-Harness-tests/306-table.t
index c57947f6..5d74c499 100755
--- a/test/lua-Harness-tests/306-table.t
+++ b/test/lua-Harness-tests/306-table.t
@@ -30,7 +30,7 @@ L<https://www.lua.org/manual/5.4/manual.html#6.6>
 
 --]]
 
-require'tap'
+require'test_assertion'
 local profile = require'profile'
 local luajit21 = jit and (jit.version_num >= 20100 or jit.version:match'^RaptorJIT')
 local has_foreach = _VERSION == 'Lua 5.1'
diff --git a/test/lua-Harness-tests/307-math.t b/test/lua-Harness-tests/307-math.t
index b50e449f..08b1e5ec 100755
--- a/test/lua-Harness-tests/307-math.t
+++ b/test/lua-Harness-tests/307-math.t
@@ -30,7 +30,7 @@ L<https://www.lua.org/manual/5.4/manual.html#6.7>
 
 --]]
 
-require'tap'
+require'test_assertion'
 local profile = require'profile'
 local has_integer = _VERSION >= 'Lua 5.3' or (jit and jit.version:match'moonjit') or profile.integer
 local has_mathx = _VERSION < 'Lua 5.3' or profile.compat52 or profile.compat53 or profile.has_mathx
diff --git a/test/lua-Harness-tests/308-io.t b/test/lua-Harness-tests/308-io.t
index c126adf2..5ea3afc7 100755
--- a/test/lua-Harness-tests/308-io.t
+++ b/test/lua-Harness-tests/308-io.t
@@ -30,7 +30,7 @@ L<https://www.lua.org/manual/5.4/manual.html#6.8>
 
 --]]
 
-require'tap'
+require'test_assertion'
 local profile = require'profile'
 local luajit21 = jit and (jit.version_num >= 20100 or jit.version:match'^RaptorJIT')
 local has_write51 = _VERSION == 'Lua 5.1' and (not profile.luajit_compat52 or ujit)
diff --git a/test/lua-Harness-tests/309-os.t b/test/lua-Harness-tests/309-os.t
index ff033bbf..2002ca47 100755
--- a/test/lua-Harness-tests/309-os.t
+++ b/test/lua-Harness-tests/309-os.t
@@ -30,7 +30,7 @@ L<https://www.lua.org/manual/5.4/manual.html#6.9>
 
 --]]
 
-require'tap'
+require'test_assertion'
 local profile = require'profile'
 local luajit20 = jit and (jit.version_num < 20100 and not jit.version:match'^RaptorJIT')
 local has_execute51 = _VERSION == 'Lua 5.1' and (not profile.luajit_compat52 or ujit)
diff --git a/test/lua-Harness-tests/310-debug.t b/test/lua-Harness-tests/310-debug.t
index 4ec970fb..f8338d1f 100755
--- a/test/lua-Harness-tests/310-debug.t
+++ b/test/lua-Harness-tests/310-debug.t
@@ -30,7 +30,7 @@ L<https://www.lua.org/manual/5.4/manual.html#6.10>
 
 ]]
 
-require 'tap'
+require 'test_assertion'
 local profile = require'profile'
 local has_getfenv = _VERSION == 'Lua 5.1'
 local has_gethook54 = _VERSION >= 'Lua 5.4'
diff --git a/test/lua-Harness-tests/311-bit32.t b/test/lua-Harness-tests/311-bit32.t
index b8ccb7ea..e6d5ca8d 100755
--- a/test/lua-Harness-tests/311-bit32.t
+++ b/test/lua-Harness-tests/311-bit32.t
@@ -29,7 +29,7 @@ L<https://www.lua.org/manual/5.2/manual.html#6.7>
 
 --]]
 
-require 'tap'
+require 'test_assertion'
 local profile = require'profile'
 local has_bit32 = _VERSION == 'Lua 5.2' or profile.compat52 or profile.has_bit32
 
diff --git a/test/lua-Harness-tests/314-regex.t b/test/lua-Harness-tests/314-regex.t
index 56883bd4..62e2ad7f 100755
--- a/test/lua-Harness-tests/314-regex.t
+++ b/test/lua-Harness-tests/314-regex.t
@@ -49,7 +49,7 @@ Description of the test.
 
 --]]
 
-require'tap'
+require'test_assertion'
 local loadstring = loadstring or load
 
 plan(162)
diff --git a/test/lua-Harness-tests/320-stdin.t b/test/lua-Harness-tests/320-stdin.t
index 09f92c1b..b65b8f37 100755
--- a/test/lua-Harness-tests/320-stdin.t
+++ b/test/lua-Harness-tests/320-stdin.t
@@ -24,7 +24,7 @@ Tests Lua Basic & IO Libraries with stdin
 
 --]]
 
-require'tap'
+require'test_assertion'
 
 local lua = get_lua_binary_name()
 
diff --git a/test/lua-Harness-tests/401-bitop.t b/test/lua-Harness-tests/401-bitop.t
index e454420e..84259cd3 100755
--- a/test/lua-Harness-tests/401-bitop.t
+++ b/test/lua-Harness-tests/401-bitop.t
@@ -24,7 +24,7 @@ See L<http://bitop.luajit.org/>.
 
 --]]
 
-require 'tap'
+require 'test_assertion'
 
 if not jit then
     skip_all("only with LuaJIT")
diff --git a/test/lua-Harness-tests/402-ffi.t b/test/lua-Harness-tests/402-ffi.t
index 73507a61..48ae8c20 100755
--- a/test/lua-Harness-tests/402-ffi.t
+++ b/test/lua-Harness-tests/402-ffi.t
@@ -24,7 +24,7 @@ See L<http://luajit.org/ext_ffi.html>.
 
 --]]
 
-require 'tap'
+require 'test_assertion'
 
 if not jit then
     skip_all("only with LuaJIT")
diff --git a/test/lua-Harness-tests/403-jit.t b/test/lua-Harness-tests/403-jit.t
index 306a7c44..1724dfd1 100755
--- a/test/lua-Harness-tests/403-jit.t
+++ b/test/lua-Harness-tests/403-jit.t
@@ -24,7 +24,7 @@ See L<http://luajit.org/ext_jit.html>.
 
 --]]
 
-require 'tap'
+require 'test_assertion'
 local profile = require'profile'
 
 if not jit then
diff --git a/test/lua-Harness-tests/404-ext.t b/test/lua-Harness-tests/404-ext.t
index afe1d5b5..7239e5df 100755
--- a/test/lua-Harness-tests/404-ext.t
+++ b/test/lua-Harness-tests/404-ext.t
@@ -24,7 +24,7 @@ See L<http://luajit.org/ext_jit.html>.
 
 --]]
 
-require 'tap'
+require 'test_assertion'
 local profile = require'profile'
 
 local luajit21 = jit and (jit.version_num >= 20100 or jit.version:match'^RaptorJIT')
diff --git a/test/lua-Harness-tests/411-luajit.t.disabled b/test/lua-Harness-tests/411-luajit.t.disabled
index ad7e279e..39cca5b0 100755
--- a/test/lua-Harness-tests/411-luajit.t.disabled
+++ b/test/lua-Harness-tests/411-luajit.t.disabled
@@ -24,7 +24,7 @@ See L<http://luajit.org/running.html>
 
 --]]
 
-require'tap'
+require'test_assertion'
 local profile = require'profile'
 
 if not jit or ujit then
diff --git a/test/lua-Harness-tests/tap.lua b/test/lua-Harness-tests/test_assertion.lua
similarity index 100%
rename from test/lua-Harness-tests/tap.lua
rename to test/lua-Harness-tests/test_assertion.lua
-- 
2.32.0


^ permalink raw reply	[flat|nested] 22+ messages in thread

* [Tarantool-patches] [PATCH v2 03/10] test: use CI friendly variables in lua-Harness
  2021-07-20 16:26 [Tarantool-patches] [PATCH v2 00/10] test: lua-Harness suite patch bump Maxim Kokryashkin via Tarantool-patches
  2021-07-20 16:26 ` [Tarantool-patches] [PATCH v2 01/10] test: port lua-Harness to Test.Assertion Maxim Kokryashkin via Tarantool-patches
  2021-07-20 16:26 ` [Tarantool-patches] [PATCH v2 02/10] test: rename lua-Harness tap to test_assertion Maxim Kokryashkin via Tarantool-patches
@ 2021-07-20 16:26 ` Maxim Kokryashkin via Tarantool-patches
  2021-07-25 21:09   ` Igor Munkin via Tarantool-patches
  2021-07-20 16:26 ` [Tarantool-patches] [PATCH v2 04/10] test: refactor with _retrieve_progname Maxim Kokryashkin via Tarantool-patches
                   ` (7 subsequent siblings)
  10 siblings, 1 reply; 22+ messages in thread
From: Maxim Kokryashkin via Tarantool-patches @ 2021-07-20 16:26 UTC (permalink / raw)
  To: tarantool-patches, imun, skaplun

In scope of the commit 45ed138dcb9228d8ac5b8d82331ddd20a0bfada1
('test: set USERNAME env var for lua-Harness suite') the environment
of the testing process is tweaked via CMake, since both LOGNAME and
USERNAME environment variables might be missing.

Actually, POSIX standard states that every user must have HOME
environment variable set. It allows to use this in the corresponding
assertion instead of LOGNAME and USERNAME without additional
environment setup.

As a result this patch[1] from lua-Harness suite supersedes the
mentioned commit, and CMake hack can be dropped.

[1]: https://framagit.org/fperrad/lua-Harness/-/commit/6c2aa87

Part of tarantool/tarantool#5970
Part of tarantool/tarantool#4473
---
 test/lua-Harness-tests/309-os.t       | 4 ++--
 test/lua-Harness-tests/CMakeLists.txt | 5 -----
 2 files changed, 2 insertions(+), 7 deletions(-)

diff --git a/test/lua-Harness-tests/309-os.t b/test/lua-Harness-tests/309-os.t
index 2002ca47..14cbb89a 100755
--- a/test/lua-Harness-tests/309-os.t
+++ b/test/lua-Harness-tests/309-os.t
@@ -169,8 +169,8 @@ end
 do -- getenv
     equals(os.getenv('__IMPROBABLE__'), nil, "function getenv")
 
-    local user = os.getenv('LOGNAME') or os.getenv('USERNAME')
-    is_string(user, "function getenv")
+    local home = os.getenv('HOME') or os.getenv('HOMEPATH')
+    is_string(home, "function getenv")
 end
 
 do -- remove
diff --git a/test/lua-Harness-tests/CMakeLists.txt b/test/lua-Harness-tests/CMakeLists.txt
index 9fddd625..b9804033 100644
--- a/test/lua-Harness-tests/CMakeLists.txt
+++ b/test/lua-Harness-tests/CMakeLists.txt
@@ -26,11 +26,6 @@ add_custom_command(TARGET lua-Harness-tests
   COMMAND
   env
     LUA_PATH="${LUA_PATH}\;"
-    # XXX: 309-os.t checks os.getenv() function by examining
-    # USERNAME or LOGNAME environment variable.
-    # These variables might not be set in the environment, so
-    # set one of them explicitly.
-    USERNAME="fperrad"
     ${PROVE} ${CMAKE_CURRENT_SOURCE_DIR}
       --exec '${LUAJIT_TEST_COMMAND} -l profile_luajit21'
       ${LUA_TEST_FLAGS}
-- 
2.32.0


^ permalink raw reply	[flat|nested] 22+ messages in thread

* [Tarantool-patches] [PATCH v2 04/10] test: refactor with _retrieve_progname
  2021-07-20 16:26 [Tarantool-patches] [PATCH v2 00/10] test: lua-Harness suite patch bump Maxim Kokryashkin via Tarantool-patches
                   ` (2 preceding siblings ...)
  2021-07-20 16:26 ` [Tarantool-patches] [PATCH v2 03/10] test: use CI friendly variables in lua-Harness Maxim Kokryashkin via Tarantool-patches
@ 2021-07-20 16:26 ` Maxim Kokryashkin via Tarantool-patches
  2021-07-25 21:09   ` Igor Munkin via Tarantool-patches
  2021-07-20 16:26 ` [Tarantool-patches] [PATCH v2 05/10] test: refactor with _dofile Maxim Kokryashkin via Tarantool-patches
                   ` (6 subsequent siblings)
  10 siblings, 1 reply; 22+ messages in thread
From: Maxim Kokryashkin via Tarantool-patches @ 2021-07-20 16:26 UTC (permalink / raw)
  To: tarantool-patches, imun, skaplun

The patch[1] from lua-Harness suite fixes the same issue commit
837688590919fcf8de47ef90479fd2a640c8fddc ('test: adjust lua-Harness
suite to CMake machinery') does except the single difference:
`get_lua_binary_name()` is called `_retrieved_progname()`. As a result
of this patch the function is renamed to follow the original naming.

[1]: https://framagit.org/fperrad/lua-Harness/-/commit/1be25a8

Part of tarantool/tarantool#5970
Part of tarantool/tarantool#4473
---
 .../241-standalone.t.disabled                  |  2 +-
 test/lua-Harness-tests/242-luac.t              |  2 +-
 test/lua-Harness-tests/301-basic.t             |  2 +-
 test/lua-Harness-tests/308-io.t                |  2 +-
 test/lua-Harness-tests/309-os.t                |  2 +-
 test/lua-Harness-tests/320-stdin.t             |  2 +-
 test/lua-Harness-tests/411-luajit.t.disabled   |  2 +-
 test/lua-Harness-tests/test_assertion.lua      | 18 ++++++++----------
 8 files changed, 15 insertions(+), 17 deletions(-)

diff --git a/test/lua-Harness-tests/241-standalone.t.disabled b/test/lua-Harness-tests/241-standalone.t.disabled
index a02ed5bf..47c50a6b 100755
--- a/test/lua-Harness-tests/241-standalone.t.disabled
+++ b/test/lua-Harness-tests/241-standalone.t.disabled
@@ -41,7 +41,7 @@ elseif ravi then
     banner = '^Ravi %d%.%d%.%d'
 end
 
-local lua = get_lua_binary_name()
+local lua = _retrieve_progname()
 local luac = jit and lua or (lua .. 'c')
 
 if not pcall(io.popen, lua .. [[ -e "a=1"]]) then
diff --git a/test/lua-Harness-tests/242-luac.t b/test/lua-Harness-tests/242-luac.t
index 0a2e160e..526b31fe 100755
--- a/test/lua-Harness-tests/242-luac.t
+++ b/test/lua-Harness-tests/242-luac.t
@@ -38,7 +38,7 @@ if ravi then
     skip_all("ravi")
 end
 
-local lua = get_lua_binary_name()
+local lua = _retrieve_progname()
 local luac = lua .. 'c'
 
 if not pcall(io.popen, lua .. [[ -e "a=1"]]) then
diff --git a/test/lua-Harness-tests/301-basic.t b/test/lua-Harness-tests/301-basic.t
index 63f0004a..c45b2558 100755
--- a/test/lua-Harness-tests/301-basic.t
+++ b/test/lua-Harness-tests/301-basic.t
@@ -48,7 +48,7 @@ local has_warn = _VERSION >= 'Lua 5.4'
 local has_xpcall52 = _VERSION >= 'Lua 5.2' or jit
 local has_xpcall53 = _VERSION >= 'Lua 5.3' or jit
 
-local lua = get_lua_binary_name()
+local lua = _retrieve_progname()
 
 plan'no_plan'
 
diff --git a/test/lua-Harness-tests/308-io.t b/test/lua-Harness-tests/308-io.t
index 5ea3afc7..af2b3232 100755
--- a/test/lua-Harness-tests/308-io.t
+++ b/test/lua-Harness-tests/308-io.t
@@ -40,7 +40,7 @@ local has_read53 = _VERSION >= 'Lua 5.3' or luajit21
 local has_meta53 = _VERSION >= 'Lua 5.3'
 local has_meta54 = _VERSION >= 'Lua 5.4'
 
-local lua = get_lua_binary_name()
+local lua = _retrieve_progname()
 
 plan'no_plan'
 
diff --git a/test/lua-Harness-tests/309-os.t b/test/lua-Harness-tests/309-os.t
index 14cbb89a..fbc2d24b 100755
--- a/test/lua-Harness-tests/309-os.t
+++ b/test/lua-Harness-tests/309-os.t
@@ -34,7 +34,7 @@ require'test_assertion'
 local profile = require'profile'
 local luajit20 = jit and (jit.version_num < 20100 and not jit.version:match'^RaptorJIT')
 local has_execute51 = _VERSION == 'Lua 5.1' and (not profile.luajit_compat52 or ujit)
-local lua = get_lua_binary_name()
+local lua = _retrieve_progname()
 
 plan'no_plan'
 
diff --git a/test/lua-Harness-tests/320-stdin.t b/test/lua-Harness-tests/320-stdin.t
index b65b8f37..bff63760 100755
--- a/test/lua-Harness-tests/320-stdin.t
+++ b/test/lua-Harness-tests/320-stdin.t
@@ -26,7 +26,7 @@ Tests Lua Basic & IO Libraries with stdin
 
 require'test_assertion'
 
-local lua = get_lua_binary_name()
+local lua = _retrieve_progname()
 
 if not pcall(io.popen, lua .. [[ -e "a=1"]]) then
     skip_all "io.popen not supported"
diff --git a/test/lua-Harness-tests/411-luajit.t.disabled b/test/lua-Harness-tests/411-luajit.t.disabled
index 39cca5b0..7830df4f 100755
--- a/test/lua-Harness-tests/411-luajit.t.disabled
+++ b/test/lua-Harness-tests/411-luajit.t.disabled
@@ -31,7 +31,7 @@ if not jit or ujit then
     skip_all("only with LuaJIT")
 end
 
-local lua = get_lua_binary_name()
+local lua = _retrieve_progname()
 
 if not pcall(io.popen, lua .. [[ -e "a=1"]]) then
     skip_all("io.popen not supported")
diff --git a/test/lua-Harness-tests/test_assertion.lua b/test/lua-Harness-tests/test_assertion.lua
index f50cc319..f126eab1 100644
--- a/test/lua-Harness-tests/test_assertion.lua
+++ b/test/lua-Harness-tests/test_assertion.lua
@@ -9,6 +9,14 @@
 
 ]]
 
+function _retrieve_progname ()
+    local i = 0
+    while arg[i] do
+        i = i - 1
+    end
+    return arg[i + 1]
+end
+
 if pcall(require, 'Test.Assertion') then
     diag 'Test.Assertion loaded'
     return
@@ -219,16 +227,6 @@ function todo (reason, count)
     todo_reason = reason
 end
 
--- The least arg element is guaranteed to be the name
--- of the tested binary.
-function get_lua_binary_name ()
-    local i = 0
-    while arg[i] do
-        i = i - 1
-    end
-    return arg[i + 1]
-end
-
 -- XXX: If tests is run out of the tests source tree, the
 -- relative paths below become invalid. Hence, we need to
 -- prepend the directory from the script (i.e. test) name to
-- 
2.32.0


^ permalink raw reply	[flat|nested] 22+ messages in thread

* [Tarantool-patches] [PATCH v2 05/10] test: refactor with _dofile
  2021-07-20 16:26 [Tarantool-patches] [PATCH v2 00/10] test: lua-Harness suite patch bump Maxim Kokryashkin via Tarantool-patches
                   ` (3 preceding siblings ...)
  2021-07-20 16:26 ` [Tarantool-patches] [PATCH v2 04/10] test: refactor with _retrieve_progname Maxim Kokryashkin via Tarantool-patches
@ 2021-07-20 16:26 ` Maxim Kokryashkin via Tarantool-patches
  2021-07-25 21:10   ` Igor Munkin via Tarantool-patches
  2021-07-20 16:26 ` [Tarantool-patches] [PATCH v2 06/10] test: support tarantool in lua-Harness Maxim Kokryashkin via Tarantool-patches
                   ` (5 subsequent siblings)
  10 siblings, 1 reply; 22+ messages in thread
From: Maxim Kokryashkin via Tarantool-patches @ 2021-07-20 16:26 UTC (permalink / raw)
  To: tarantool-patches, imun, skaplun

The patch[1] from lua-Harness suite is quite similar to commit
d11c5bbc08a118b11167c5d455d4024607dab662 ('test: adjust lua-Harness
tests that use dofile'), with the one difference (except the naming):
`make_specific_checks()` provides the particular behaviour to run the
tests for out-of-source build, however `_dofile()` allows user to
overload this function considering his purposes. If user leave
`_dofile()` untouched, it defaults to `dofile()` Lua standard library
function.

It's worth to mention, that LuaJIT testing machinery has been using
such approach since commit 734cc0f1d508429c2c3c46bd1860398db0051060
('test: adapt PUC-Rio suite for out-of-source build') and `_dofile()`
behaviour for running tests when out of source build is used is
already defined in luajit-test-init.lua.

[1]: https://framagit.org/fperrad/lua-Harness/-/commit/60da289

Part of tarantool/tarantool#5970
Part of tarantool/tarantool#4473
---
 test/lua-Harness-tests/101-boolean.t      |  2 +-
 test/lua-Harness-tests/102-function.t     |  2 +-
 test/lua-Harness-tests/103-nil.t          |  2 +-
 test/lua-Harness-tests/104-number.t       |  2 +-
 test/lua-Harness-tests/105-string.t       |  2 +-
 test/lua-Harness-tests/106-table.t        |  2 +-
 test/lua-Harness-tests/107-thread.t       |  2 +-
 test/lua-Harness-tests/108-userdata.t     |  2 +-
 test/lua-Harness-tests/203-lexico.t       |  8 ++++----
 test/lua-Harness-tests/231-metatable.t    |  2 +-
 test/lua-Harness-tests/301-basic.t        |  2 +-
 test/lua-Harness-tests/305-utf8.t         |  4 ++--
 test/lua-Harness-tests/404-ext.t          |  2 +-
 test/lua-Harness-tests/test_assertion.lua | 10 ++--------
 test/luajit-test-init.lua                 |  2 ++
 15 files changed, 21 insertions(+), 25 deletions(-)

diff --git a/test/lua-Harness-tests/101-boolean.t b/test/lua-Harness-tests/101-boolean.t
index eb8b6bbd..9b36174f 100755
--- a/test/lua-Harness-tests/101-boolean.t
+++ b/test/lua-Harness-tests/101-boolean.t
@@ -114,7 +114,7 @@ error_matches(function () local a = true; a[1] = 1; end,
         "index")
 
 if has_op53 then
-    make_specific_checks'lexico53/boolean.t'
+    _dofile'lexico53/boolean.t'
 end
 
 done_testing()
diff --git a/test/lua-Harness-tests/102-function.t b/test/lua-Harness-tests/102-function.t
index a0a3ad33..f144f702 100755
--- a/test/lua-Harness-tests/102-function.t
+++ b/test/lua-Harness-tests/102-function.t
@@ -193,7 +193,7 @@ t[print] = true
 truthy(t[print])
 
 if has_op53 then
-    make_specific_checks'lexico53/function.t'
+    _dofile'lexico53/function.t'
 end
 
 done_testing()
diff --git a/test/lua-Harness-tests/103-nil.t b/test/lua-Harness-tests/103-nil.t
index 718fde16..d7cab0da 100755
--- a/test/lua-Harness-tests/103-nil.t
+++ b/test/lua-Harness-tests/103-nil.t
@@ -114,7 +114,7 @@ error_matches(function () local a = nil; a[1] = 1; end,
         "index")
 
 if has_op53 then
-    make_specific_checks'lexico53/nil.t'
+    _dofile'lexico53/nil.t'
 end
 
 done_testing()
diff --git a/test/lua-Harness-tests/104-number.t b/test/lua-Harness-tests/104-number.t
index 872042c0..9dd3ffa0 100755
--- a/test/lua-Harness-tests/104-number.t
+++ b/test/lua-Harness-tests/104-number.t
@@ -233,7 +233,7 @@ error_matches(function () local a = 3.14; a[1] = 1; end,
         "index")
 
 if has_op53 then
-    make_specific_checks'lexico53/number.t'
+    _dofile'lexico53/number.t'
 end
 
 done_testing()
diff --git a/test/lua-Harness-tests/105-string.t b/test/lua-Harness-tests/105-string.t
index 22e6cfa6..3d167840 100755
--- a/test/lua-Harness-tests/105-string.t
+++ b/test/lua-Harness-tests/105-string.t
@@ -264,7 +264,7 @@ error_matches(function () a = 'text'; a[1] = 1; end,
         "index")
 
 if has_op53 then
-    make_specific_checks'lexico53/string.t'
+    _dofile'lexico53/string.t'
 end
 
 done_testing()
diff --git a/test/lua-Harness-tests/106-table.t b/test/lua-Harness-tests/106-table.t
index ecb761d2..6beb2a5e 100755
--- a/test/lua-Harness-tests/106-table.t
+++ b/test/lua-Harness-tests/106-table.t
@@ -122,7 +122,7 @@ error_matches(function () t = {}; t[0/0] = 42 end,
         "table index is NaN")
 
 if has_op53 then
-    make_specific_checks'lexico53/table.t'
+    _dofile'lexico53/table.t'
 end
 
 done_testing()
diff --git a/test/lua-Harness-tests/107-thread.t b/test/lua-Harness-tests/107-thread.t
index 33ebf769..e9b17139 100755
--- a/test/lua-Harness-tests/107-thread.t
+++ b/test/lua-Harness-tests/107-thread.t
@@ -122,7 +122,7 @@ t[co] = true
 truthy(t[co])
 
 if has_op53 then
-    make_specific_checks'lexico53/thread.t'
+    _dofile'lexico53/thread.t'
 end
 
 done_testing()
diff --git a/test/lua-Harness-tests/108-userdata.t b/test/lua-Harness-tests/108-userdata.t
index 314a60e7..0c7f0c24 100755
--- a/test/lua-Harness-tests/108-userdata.t
+++ b/test/lua-Harness-tests/108-userdata.t
@@ -119,7 +119,7 @@ t[u] = true
 truthy(t[u])
 
 if has_op53 then
-    make_specific_checks'lexico53/userdata.t'
+    _dofile'lexico53/userdata.t'
 end
 
 done_testing()
diff --git a/test/lua-Harness-tests/203-lexico.t b/test/lua-Harness-tests/203-lexico.t
index c9345c71..396a167f 100755
--- a/test/lua-Harness-tests/203-lexico.t
+++ b/test/lua-Harness-tests/203-lexico.t
@@ -118,19 +118,19 @@ do
 end
 
 if _VERSION >= 'Lua 5.2' or jit then
-    make_specific_checks'lexico52/lexico.t'
+    _dofile'lexico52/lexico.t'
 end
 
 if _VERSION >= 'Lua 5.3' or luajit21 then
-    make_specific_checks'lexico53/lexico.t'
+    _dofile'lexico53/lexico.t'
 end
 
 if _VERSION >= 'Lua 5.4' then
-    make_specific_checks'lexico54/lexico.t'
+    _dofile'lexico54/lexico.t'
 end
 
 if jit and pcall(require, 'ffi') then
-    make_specific_checks'lexicojit/lexico.t'
+    _dofile'lexicojit/lexico.t'
 end
 
 done_testing()
diff --git a/test/lua-Harness-tests/231-metatable.t b/test/lua-Harness-tests/231-metatable.t
index 15625c11..06cc902c 100755
--- a/test/lua-Harness-tests/231-metatable.t
+++ b/test/lua-Harness-tests/231-metatable.t
@@ -589,7 +589,7 @@ do
 end
 
 if has_anno_toclose then
-    make_specific_checks'lexico54/metatable.t'
+    _dofile'lexico54/metatable.t'
 end
 
 done_testing()
diff --git a/test/lua-Harness-tests/301-basic.t b/test/lua-Harness-tests/301-basic.t
index c45b2558..01e187d9 100755
--- a/test/lua-Harness-tests/301-basic.t
+++ b/test/lua-Harness-tests/301-basic.t
@@ -843,7 +843,7 @@ do -- xpcall
 end
 
 if jit and pcall(require, 'ffi') then
-    make_specific_checks'lexicojit/basic.t'
+    _dofile'lexicojit/basic.t'
 end
 
 done_testing()
diff --git a/test/lua-Harness-tests/305-utf8.t b/test/lua-Harness-tests/305-utf8.t
index e448a448..2ba48c08 100755
--- a/test/lua-Harness-tests/305-utf8.t
+++ b/test/lua-Harness-tests/305-utf8.t
@@ -40,9 +40,9 @@ if not utf8 then
     falsy(has_utf8, "no has_utf8")
 else
     plan'no_plan'
-    make_specific_checks'lexico53/utf8.t'
+    _dofile'lexico53/utf8.t'
     if _VERSION >= 'Lua 5.4' then
-        make_specific_checks'lexico54/utf8.t'
+        _dofile'lexico54/utf8.t'
     end
     done_testing()
 end
diff --git a/test/lua-Harness-tests/404-ext.t b/test/lua-Harness-tests/404-ext.t
index 7239e5df..45701671 100755
--- a/test/lua-Harness-tests/404-ext.t
+++ b/test/lua-Harness-tests/404-ext.t
@@ -158,7 +158,7 @@ end
 
 -- thread.exdata
 if pcall(require, 'ffi') and (profile.openresty or jit.version:match'moonjit') then
-    make_specific_checks'lexicojit/ext.t'
+    _dofile'lexicojit/ext.t'
 end
 
 done_testing()
diff --git a/test/lua-Harness-tests/test_assertion.lua b/test/lua-Harness-tests/test_assertion.lua
index f126eab1..67cf37f9 100644
--- a/test/lua-Harness-tests/test_assertion.lua
+++ b/test/lua-Harness-tests/test_assertion.lua
@@ -9,6 +9,8 @@
 
 ]]
 
+_dofile = _dofile or dofile     -- could be defined in profile
+
 function _retrieve_progname ()
     local i = 0
     while arg[i] do
@@ -227,14 +229,6 @@ function todo (reason, count)
     todo_reason = reason
 end
 
--- XXX: If tests is run out of the tests source tree, the
--- relative paths below become invalid. Hence, we need to
--- prepend the directory from the script (i.e. test) name to
--- the auxiliary files to be loaded and executed.
-function make_specific_checks (filename)
-    return dofile(arg[0]:gsub('([^/]+)%.t$', '') .. filename)
-end
-
 --
 -- Copyright (c) 2009-2021 Francois Perrad
 --
diff --git a/test/luajit-test-init.lua b/test/luajit-test-init.lua
index 54a1f815..feec17cf 100644
--- a/test/luajit-test-init.lua
+++ b/test/luajit-test-init.lua
@@ -2,6 +2,8 @@
 -- `_loadfile()` exists and uses it for code loading from test
 -- files. If the variable is not defined then suite uses
 -- `loadfile()` as default. Same for the `_dofile()`.
+-- Lua-Harness also uses the same implementation of `dofile()`
+-- fot he same reason
 
 -- XXX: Some tests in PUC Rio Lua 5.1 test suite clean `arg`
 -- variable, so evaluate this once and use later.
-- 
2.32.0


^ permalink raw reply	[flat|nested] 22+ messages in thread

* [Tarantool-patches] [PATCH v2 06/10] test: support tarantool in lua-Harness
  2021-07-20 16:26 [Tarantool-patches] [PATCH v2 00/10] test: lua-Harness suite patch bump Maxim Kokryashkin via Tarantool-patches
                   ` (4 preceding siblings ...)
  2021-07-20 16:26 ` [Tarantool-patches] [PATCH v2 05/10] test: refactor with _dofile Maxim Kokryashkin via Tarantool-patches
@ 2021-07-20 16:26 ` Maxim Kokryashkin via Tarantool-patches
  2021-07-25 21:11   ` Igor Munkin via Tarantool-patches
  2021-07-20 16:26 ` [Tarantool-patches] [PATCH v2 07/10] test: backport lua-Harness directory detection Maxim Kokryashkin via Tarantool-patches
                   ` (4 subsequent siblings)
  10 siblings, 1 reply; 22+ messages in thread
From: Maxim Kokryashkin via Tarantool-patches @ 2021-07-20 16:26 UTC (permalink / raw)
  To: tarantool-patches, imun, skaplun

Backports 'supoort Tarantool' patch[1] from lua-Harness.

[1]: https://framagit.org/fperrad/lua-Harness/-/commit/d3ceee16

Part of tarantool/tarantool#5970
Part of tarantool/tarantool#4473
---
 ...standalone.t.disabled => 241-standalone.t} |  5 ++
 test/lua-Harness-tests/320-stdin.t            |  2 +-
 .../{411-luajit.t.disabled => 411-luajit.t}   |  2 +-
 test/lua-Harness-tests/profile_tarantool.lua  | 63 +++++++++++++++++++
 4 files changed, 70 insertions(+), 2 deletions(-)
 rename test/lua-Harness-tests/{241-standalone.t.disabled => 241-standalone.t} (99%)
 rename test/lua-Harness-tests/{411-luajit.t.disabled => 411-luajit.t} (99%)
 create mode 100644 test/lua-Harness-tests/profile_tarantool.lua

diff --git a/test/lua-Harness-tests/241-standalone.t.disabled b/test/lua-Harness-tests/241-standalone.t
similarity index 99%
rename from test/lua-Harness-tests/241-standalone.t.disabled
rename to test/lua-Harness-tests/241-standalone.t
index 47c50a6b..57d9e5bd 100755
--- a/test/lua-Harness-tests/241-standalone.t.disabled
+++ b/test/lua-Harness-tests/241-standalone.t
@@ -29,6 +29,11 @@ L<https://www.lua.org/manual/5.4/manual.html#7>
 --]]
 
 require'test_assertion'
+
+if _TARANTOOL then
+    skip_all("tarantool")
+end
+
 local has_bytecode = not ujit and not ravi
 local has_error52 = _VERSION >= 'Lua 5.2'
 local has_error53 = _VERSION >= 'Lua 5.3'
diff --git a/test/lua-Harness-tests/320-stdin.t b/test/lua-Harness-tests/320-stdin.t
index bff63760..f4de97fd 100755
--- a/test/lua-Harness-tests/320-stdin.t
+++ b/test/lua-Harness-tests/320-stdin.t
@@ -64,7 +64,7 @@ end
 ]]
     f:close()
 
-    local cmd = lua .. [[ -e "f = loadfile(); print(foo); f(); print(foo('ok'))" < foo-320.lua]]
+    local cmd = lua .. [[ -e "foo = nil; f = loadfile(); print(foo); f(); print(foo('ok'))" < foo-320.lua]]
     f = io.popen(cmd)
     equals(f:read'*l', 'nil', "function loadfile (stdin)")
     equals(f:read'*l', 'ok')
diff --git a/test/lua-Harness-tests/411-luajit.t.disabled b/test/lua-Harness-tests/411-luajit.t
similarity index 99%
rename from test/lua-Harness-tests/411-luajit.t.disabled
rename to test/lua-Harness-tests/411-luajit.t
index 7830df4f..da1af9ce 100755
--- a/test/lua-Harness-tests/411-luajit.t.disabled
+++ b/test/lua-Harness-tests/411-luajit.t
@@ -27,7 +27,7 @@ See L<http://luajit.org/running.html>
 require'test_assertion'
 local profile = require'profile'
 
-if not jit or ujit then
+if not jit or ujit or _TARANTOOL then
     skip_all("only with LuaJIT")
 end
 
diff --git a/test/lua-Harness-tests/profile_tarantool.lua b/test/lua-Harness-tests/profile_tarantool.lua
new file mode 100644
index 00000000..2abd37ff
--- /dev/null
+++ b/test/lua-Harness-tests/profile_tarantool.lua
@@ -0,0 +1,63 @@
+---
+-- lua-Harness : <https://fperrad.frama.io/lua-Harness/>
+---
+
+local profile = {
+
+--[[ compat 5.0
+    has_string_gfind = true,
+    has_math_mod = true,
+--]]
+
+    compat51 = false,
+--[[
+    has_unpack = true,
+    has_package_loaders = true,
+    has_math_log10 = true,
+    has_loadstring = true,
+    has_table_maxn = true,
+    has_module = true,
+    has_package_seeall = true,
+--]]
+
+    compat52 = false,
+--[[
+    has_mathx = true,
+    has_bit32 = true,
+    has_metamethod_ipairs = true,
+--]]
+
+    compat53 = false,
+--[[
+    has_math_log10 = true,
+    has_mathx = true,
+    has_metamethod_ipairs = true,
+--]]
+
+-- [[ luajit
+    luajit_compat52 = false,
+    openresty = false,
+--]]
+
+}
+
+require'strict'.off()                   -- allows undeclared variables
+
+_G.utf8 = nil                           -- not compatible with the PUC one
+
+-- luacheck: globals _dofile
+function _dofile (filename)
+    print("# Custom dofile")
+    return dofile(filename)
+end
+
+package.loaded.profile = profile        -- prevents loading of default profile
+
+return profile
+
+--
+-- Copyright (c) 2018-2021 Francois Perrad
+--
+-- This library is licensed under the terms of the MIT/X11 license,
+-- like Lua itself.
+--
-- 
2.32.0


^ permalink raw reply	[flat|nested] 22+ messages in thread

* [Tarantool-patches] [PATCH v2 07/10] test: backport lua-Harness directory detection
  2021-07-20 16:26 [Tarantool-patches] [PATCH v2 00/10] test: lua-Harness suite patch bump Maxim Kokryashkin via Tarantool-patches
                   ` (5 preceding siblings ...)
  2021-07-20 16:26 ` [Tarantool-patches] [PATCH v2 06/10] test: support tarantool in lua-Harness Maxim Kokryashkin via Tarantool-patches
@ 2021-07-20 16:26 ` Maxim Kokryashkin via Tarantool-patches
  2021-07-25 21:12   ` Igor Munkin via Tarantool-patches
  2021-07-20 16:26 ` [Tarantool-patches] [PATCH v2 08/10] test: support tarantool cli in lua-Harness Maxim Kokryashkin via Tarantool-patches
                   ` (3 subsequent siblings)
  10 siblings, 1 reply; 22+ messages in thread
From: Maxim Kokryashkin via Tarantool-patches @ 2021-07-20 16:26 UTC (permalink / raw)
  To: tarantool-patches, imun, skaplun

The patch[1] from lua-Harness fixes the same issue commit
789820aac7cecc3b5ae394aadc12a5ec25b68121('test: fix directory detection
in lua-Harness suite') does, but it also works on Windows, so the
mentioned commit can be supreseded by that patch.

Part of tarantool/tarantool#5970
Part of tarantool/tarantool#4473
---
 test/lua-Harness-tests/314-regex.t | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/lua-Harness-tests/314-regex.t b/test/lua-Harness-tests/314-regex.t
index 62e2ad7f..71037779 100755
--- a/test/lua-Harness-tests/314-regex.t
+++ b/test/lua-Harness-tests/314-regex.t
@@ -164,7 +164,7 @@ local function split (line)
 end
 
 local test_number = 0
-local dirname = arg[0]:gsub('([^/]+)%.t$', '')
+local dirname = arg[0]:gsub('([^/\\]+)$', '')
 for _, filename in ipairs(test_files) do
     local f, msg = io.open(dirname .. filename, 'r')
     if f == nil then
-- 
2.32.0


^ permalink raw reply	[flat|nested] 22+ messages in thread

* [Tarantool-patches] [PATCH v2 08/10] test: support tarantool cli in lua-Harness
  2021-07-20 16:26 [Tarantool-patches] [PATCH v2 00/10] test: lua-Harness suite patch bump Maxim Kokryashkin via Tarantool-patches
                   ` (6 preceding siblings ...)
  2021-07-20 16:26 ` [Tarantool-patches] [PATCH v2 07/10] test: backport lua-Harness directory detection Maxim Kokryashkin via Tarantool-patches
@ 2021-07-20 16:26 ` Maxim Kokryashkin via Tarantool-patches
  2021-07-25 21:13   ` Igor Munkin via Tarantool-patches
  2021-07-20 16:26 ` [Tarantool-patches] [PATCH v2 09/10] test: update lua-Harness to b7b1a9a2 Maxim Kokryashkin via Tarantool-patches
                   ` (2 subsequent siblings)
  10 siblings, 1 reply; 22+ messages in thread
From: Maxim Kokryashkin via Tarantool-patches @ 2021-07-20 16:26 UTC (permalink / raw)
  To: tarantool-patches, imun, skaplun

The patch[1] from lua-Harness suite adds some specific checks to
lua-Harness tests, so they are compatible with Tarantool now.

Considering this, commit d4e12d7ac28e3bc857d30971dd77deec66a67297('test:
disable LuaJIT CLI tests in lua-Harness suite'), which disabled
tarantool cli tests, can be superseded.

As a result, the introduced assertion for Tarantool error message fails
on MacOS, since getopt_long(3) yields the error message without single
quotes wrapping the flag. Hence, this commit also includes fix for that
from patch[2] in the trunk.

[1]: https://framagit.org/fperrad/lua-Harness/-/commit/1da5b1b3
[2]: https://framagit.org/fperrad/lua-Harness/-/commit/a0532c5
---
Additional information on issue with MacOS:
https://github.com/tarantool/tarantool/issues/5970#issuecomment-880158605

NOTICE: tests for this separate commit are failing on FreeBSD

 test/lua-Harness-tests/241-standalone.t | 79 +++++++++++++++++++------
 1 file changed, 61 insertions(+), 18 deletions(-)

diff --git a/test/lua-Harness-tests/241-standalone.t b/test/lua-Harness-tests/241-standalone.t
index 57d9e5bd..e4cf83b5 100755
--- a/test/lua-Harness-tests/241-standalone.t
+++ b/test/lua-Harness-tests/241-standalone.t
@@ -29,21 +29,18 @@ L<https://www.lua.org/manual/5.4/manual.html#7>
 --]]
 
 require'test_assertion'
-
-if _TARANTOOL then
-    skip_all("tarantool")
-end
-
-local has_bytecode = not ujit and not ravi
+local has_bytecode = not ujit and not ravi and not _TARANTOOL
 local has_error52 = _VERSION >= 'Lua 5.2'
 local has_error53 = _VERSION >= 'Lua 5.3'
-local has_opt_E = _VERSION >= 'Lua 5.2' or jit
+local has_opt_E = _VERSION >= 'Lua 5.2' or (jit and not _TARANTOOL)
 local has_opt_W = _VERSION >= 'Lua 5.4'
 local banner = '^[%w%s%-%.]-Copyright %(C%) %d%d%d%d'
 if jit and jit.version:match'^RaptorJIT' then
     banner = '^[%w%s%.]- %-%- '
 elseif ravi then
     banner = '^Ravi %d%.%d%.%d'
+elseif _TARANTOOL then
+    banner = '^Tarantool %d%.%d+%.%d+'
 end
 
 local lua = _retrieve_progname()
@@ -74,7 +71,11 @@ f:close()
 
 cmd = lua .. " no_file-241.lua 2>&1"
 f = io.popen(cmd)
-matches(f:read'*l', "^[^:]+: cannot open no_file%-241%.lua", "no file")
+if _TARANTOOL then
+    matches(f:read'*l', "Can't open script no_file%-241%.lua", "no file")
+else
+    matches(f:read'*l', "^[^:]+: cannot open no_file%-241%.lua", "no file")
+end
 f:close()
 
 if has_bytecode then
@@ -121,6 +122,9 @@ if ravi then
     matches(f:read'*l', '^Portions Copyright %(C%)')
     matches(f:read'*l', '^Options')
 end
+if _TARANTOOL then
+    matches(f:read'*l', "^type 'help' for interactive help")
+end
 equals(f:read'*l', 'Hello World')
 f:close()
 
@@ -131,18 +135,26 @@ f:close()
 
 cmd = lua .. [[ -e "error('msg')"  2>&1]]
 f = io.popen(cmd)
-equals(f:read'*l', lua .. [[: (command line):1: msg]], "error")
-equals(f:read'*l', "stack traceback:", "backtrace")
+if _TARANTOOL then
+    equals(f:read'*l', "LuajitError: (command line):1: msg", "error")
+    equals(f:read'*l', "fatal error, exiting the event loop")
+else
+    equals(f:read'*l', lua .. [[: (command line):1: msg]], "error")
+    equals(f:read'*l', "stack traceback:", "backtrace")
+end
 f:close()
 
 cmd = lua .. [[ -e "error(setmetatable({}, {__tostring=function() return 'MSG' end}))"  2>&1]]
 f = io.popen(cmd)
-if has_error52 or jit then
+if _TARANTOOL then
+    equals(f:read'*l', "LuajitError: MSG", "error with object")
+    equals(f:read'*l', "fatal error, exiting the event loop")
+elseif has_error52 or jit then
     equals(f:read'*l', lua .. [[: MSG]], "error with object")
 else
     equals(f:read'*l', lua .. [[: (error object is not a string)]], "error with object")
 end
-if jit then
+if jit and not _TARANTOOL then
     equals(f:read'*l', "stack traceback:", "backtrace")
 else
     equals(f:read'*l', nil, "not backtrace")
@@ -157,6 +169,10 @@ if has_error53 then
 elseif has_error52 then
     equals(f:read'*l', lua .. [[: (no error message)]], "error")
     equals(f:read'*l', nil, "not backtrace")
+elseif _TARANTOOL then
+    matches(f:read'*l', "^LuajitError: table: ", "error")
+    equals(f:read'*l', "fatal error, exiting the event loop")
+    equals(f:read'*l', nil, "not backtrace")
 else
     equals(f:read'*l', lua .. [[: (error object is not a string)]], "error")
     equals(f:read'*l', nil, "not backtrace")
@@ -184,12 +200,21 @@ f = io.popen(cmd)
 if _VERSION ~= 'Lua 5.1' then
     matches(f:read'*l', "^[^:]+: '%-e' needs argument", "-e w/o arg")
 end
-matches(f:read'*l', "^usage: ")
+if _TARANTOOL then
+    matches(f:read'*l', "^[^:]+: option requires an argument %-%- '?e'?", "-e w/o arg")
+else
+    matches(f:read'*l', "^usage: ")
+end
 f:close()
 
 cmd = lua .. [[ -v 2>&1]]
 f = io.popen(cmd)
 matches(f:read'*l', banner, "-v")
+if _TARANTOOL then
+    matches(f:read'*l', '^Target: ')
+    matches(f:read'*l', '^Build options: ')
+    matches(f:read'*l', '^Compiler: ')
+end
 f:close()
 
 cmd = lua .. [[ -v hello-241.lua 2>&1]]
@@ -200,12 +225,24 @@ if ravi then
     matches(f:read'*l', '^Portions Copyright %(C%)')
     matches(f:read'*l', '^Options')
 end
-equals(f:read'*l', 'Hello World')
+if _TARANTOOL then
+    matches(f:read'*l', '^Target: ')
+    matches(f:read'*l', '^Build options: ')
+    matches(f:read'*l', '^Compiler: ')
+    -- script is not runned
+else
+    equals(f:read'*l', 'Hello World')
+end
 f:close()
 
 cmd = lua .. [[ -v -- 2>&1]]
 f = io.popen(cmd)
 matches(f:read'*l', banner, "-v --")
+if _TARANTOOL then
+    matches(f:read'*l', '^Target: ')
+    matches(f:read'*l', '^Build options: ')
+    matches(f:read'*l', '^Compiler: ')
+end
 f:close()
 
 if has_opt_E then
@@ -222,15 +259,21 @@ f = io.popen(cmd)
 if _VERSION ~= 'Lua 5.1' then
     matches(f:read'*l', "^[^:]+: unrecognized option '%-u'", "unknown option")
 end
-matches(f:read'*l', "^usage: ")
+if _TARANTOOL then
+    matches(f:read'*l', "^[^:]+: invalid option %-%- '?u'?", "unknown option")
+else
+    matches(f:read'*l', "^usage: ")
+end
 f:close()
 
 cmd = lua .. [[ --u 2>&1]]
 f = io.popen(cmd)
-if _VERSION ~= 'Lua 5.1' then
-    matches(f:read'*l', "^[^:]+: unrecognized option '%-%-u'", "unknown option")
+if _VERSION ~= 'Lua 5.1' or _TARANTOOL then
+    matches(f:read'*l', "^[^:]+: unrecognized option [`']%-%-u'", "unknown option")
+end
+if not _TARANTOOL then
+    matches(f:read'*l', "^usage: ")
 end
-matches(f:read'*l', "^usage: ")
 f:close()
 
 f = io.open('foo.lua', 'w')
-- 
2.32.0


^ permalink raw reply	[flat|nested] 22+ messages in thread

* [Tarantool-patches] [PATCH v2 09/10] test: update lua-Harness to b7b1a9a2
  2021-07-20 16:26 [Tarantool-patches] [PATCH v2 00/10] test: lua-Harness suite patch bump Maxim Kokryashkin via Tarantool-patches
                   ` (7 preceding siblings ...)
  2021-07-20 16:26 ` [Tarantool-patches] [PATCH v2 08/10] test: support tarantool cli in lua-Harness Maxim Kokryashkin via Tarantool-patches
@ 2021-07-20 16:26 ` Maxim Kokryashkin via Tarantool-patches
  2021-07-25 21:14   ` Igor Munkin via Tarantool-patches
  2021-07-20 16:26 ` [Tarantool-patches] [PATCH v2 10/10] test: disable test/lua-Harness-tests/241-standalone.t on FreeBSD Maxim Kokryashkin via Tarantool-patches
  2021-07-25 21:03 ` [Tarantool-patches] [PATCH v2 00/10] test: lua-Harness suite patch bump Igor Munkin via Tarantool-patches
  10 siblings, 1 reply; 22+ messages in thread
From: Maxim Kokryashkin via Tarantool-patches @ 2021-07-20 16:26 UTC (permalink / raw)
  To: tarantool-patches, imun, skaplun

This patch backports several small commits from lua-Harness suite:
- follow ravi 1.0-beta4[1]
- refactor with near[2]
- follow LuaJIT[3]
- fix when no debug[4]
- check if luac exists[5]
- https[6]
- more assert[7]

[1]: https://framagit.org/fperrad/lua-Harness/-/commit/9455281b
[2]: https://framagit.org/fperrad/lua-Harness/-/commit/70404580
[3]: https://framagit.org/fperrad/lua-Harness/-/commit/ac7671b6
[4]: https://framagit.org/fperrad/lua-Harness/-/commit/4db7e539
[5]: https://framagit.org/fperrad/lua-Harness/-/commit/97e9e4c1
[6]: https://framagit.org/fperrad/lua-Harness/-/commit/673c7869
[7]: https://framagit.org/fperrad/lua-Harness/-/commit/b7b1a9a2

Part of #5970
Part of #4473
---
 test/lua-Harness-tests/200-examples.t     |  2 +-
 test/lua-Harness-tests/203-lexico.t       |  2 +-
 test/lua-Harness-tests/241-standalone.t   |  3 +-
 test/lua-Harness-tests/242-luac.t         |  4 +++
 test/lua-Harness-tests/301-basic.t        |  2 +-
 test/lua-Harness-tests/304-string.t       |  2 +-
 test/lua-Harness-tests/307-math.t         | 44 +++++++++++------------
 test/lua-Harness-tests/310-debug.t        |  2 --
 test/lua-Harness-tests/320-stdin.t        | 14 +++++---
 test/lua-Harness-tests/401-bitop.t        |  2 +-
 test/lua-Harness-tests/402-ffi.t          |  2 +-
 test/lua-Harness-tests/403-jit.t          |  2 +-
 test/lua-Harness-tests/404-ext.t          |  2 +-
 test/lua-Harness-tests/411-luajit.t       |  2 +-
 test/lua-Harness-tests/profile_ravi.lua   |  4 +--
 test/lua-Harness-tests/test_assertion.lua |  9 +++++
 16 files changed, 57 insertions(+), 41 deletions(-)

diff --git a/test/lua-Harness-tests/200-examples.t b/test/lua-Harness-tests/200-examples.t
index 7020af4d..9d7ec6d9 100755
--- a/test/lua-Harness-tests/200-examples.t
+++ b/test/lua-Harness-tests/200-examples.t
@@ -70,7 +70,7 @@ equals(iter_factorial(7), 5040, "factorial (iter)")
 --[[
 
   Knuth's "man or boy" test.
-  See http://en.wikipedia.org/wiki/Man_or_boy_test
+  See https://en.wikipedia.org/wiki/Man_or_boy_test
 
 ]]
 
diff --git a/test/lua-Harness-tests/203-lexico.t b/test/lua-Harness-tests/203-lexico.t
index 396a167f..ef6f9212 100755
--- a/test/lua-Harness-tests/203-lexico.t
+++ b/test/lua-Harness-tests/203-lexico.t
@@ -19,7 +19,7 @@
 =head2 Description
 
 See "Lua 5.3 Reference Manual", section 3.1 "Lexical Conventions",
-L<http://www.lua.org/manual/5.3/manual.html#3.1>.
+L<https://www.lua.org/manual/5.3/manual.html#3.1>.
 
 See section "Lexical Conventions"
 L<https://www.lua.org/manual/5.1/manual.html#2.1>,
diff --git a/test/lua-Harness-tests/241-standalone.t b/test/lua-Harness-tests/241-standalone.t
index e4cf83b5..afbcf5b8 100755
--- a/test/lua-Harness-tests/241-standalone.t
+++ b/test/lua-Harness-tests/241-standalone.t
@@ -45,6 +45,7 @@ end
 
 local lua = _retrieve_progname()
 local luac = jit and lua or (lua .. 'c')
+local exists_luac = io.open(luac, 'r')
 
 if not pcall(io.popen, lua .. [[ -e "a=1"]]) then
     skip_all "io.popen not supported"
@@ -78,7 +79,7 @@ else
 end
 f:close()
 
-if has_bytecode then
+if has_bytecode and exists_luac then
     if jit then
         os.execute(lua .. " -b hello-241.lua hello-241.luac")
     else
diff --git a/test/lua-Harness-tests/242-luac.t b/test/lua-Harness-tests/242-luac.t
index 526b31fe..c15c9a54 100755
--- a/test/lua-Harness-tests/242-luac.t
+++ b/test/lua-Harness-tests/242-luac.t
@@ -41,6 +41,10 @@ end
 local lua = _retrieve_progname()
 local luac = lua .. 'c'
 
+if not io.open(luac, 'r') then
+    skip_all "no luac"
+end
+
 if not pcall(io.popen, lua .. [[ -e "a=1"]]) then
     skip_all "io.popen not supported"
 end
diff --git a/test/lua-Harness-tests/301-basic.t b/test/lua-Harness-tests/301-basic.t
index 01e187d9..4adbb55c 100755
--- a/test/lua-Harness-tests/301-basic.t
+++ b/test/lua-Harness-tests/301-basic.t
@@ -167,7 +167,7 @@ end
     f:close()
     dofile('lib-301.lua')
     local n = norm(3.4, 1.0)
-    matches(twice(n), '^7%.088', "function dofile")
+    near(twice(n), 7.088, 0.001, "function dofile")
 
     os.remove('lib-301.lua') -- clean up
 
diff --git a/test/lua-Harness-tests/304-string.t b/test/lua-Harness-tests/304-string.t
index 82e0408d..ac7e802a 100755
--- a/test/lua-Harness-tests/304-string.t
+++ b/test/lua-Harness-tests/304-string.t
@@ -277,7 +277,7 @@ do -- format
     equals(string.format("%s %d", r, r:len()), r .. " 200")
 
     error_matches(function () string.format("%s %s", 1) end,
-            "^[^:]+:%d+: bad argument #3 to 'format' %(.-no value%)",
+            "^[^:]+:%d+: bad argument #3 to 'format' %(.-value.-%)",
             "function format (too few arg)")
 
     error_matches(function () string.format('%d', 'toto') end,
diff --git a/test/lua-Harness-tests/307-math.t b/test/lua-Harness-tests/307-math.t
index 08b1e5ec..757637f8 100755
--- a/test/lua-Harness-tests/307-math.t
+++ b/test/lua-Harness-tests/307-math.t
@@ -56,20 +56,20 @@ do -- abs
 end
 
 do -- acos
-    matches(math.acos(0.5), '^1%.047', "function acos")
+    near(math.acos(0.5), 1.047, 0.001, "function acos")
 end
 
 do -- asin
-    matches(math.asin(0.5), '^0%.523', "function asin")
+    near(math.asin(0.5), 0.523, 0.001, "function asin")
 end
 
 do -- atan
-    matches(math.atan(0.5), '^0%.463', "function atan")
+    near(math.atan(0.5), 0.463, 0.001, "function atan")
 end
 
 -- atan2
 if has_mathx then
-    matches(math.atan2(1.0, 2.0), '^0%.463', "function atan2")
+    near(math.atan2(1.0, 2.0), 0.463, 0.001, "function atan2")
 else
     is_nil(math.atan2, "function atan2 (removed)")
 end
@@ -84,12 +84,12 @@ do -- ceil
 end
 
 do -- cos
-    matches(math.cos(1.0), '^0%.540', "function cos")
+    near(math.cos(1.0), 0.540, 0.001, "function cos")
 end
 
 -- cosh
 if has_mathx then
-    matches(math.cosh(1.0), '^1%.543', "function cosh")
+    near(math.cosh(1.0), 1.543, 0.001, "function cosh")
 else
     is_nil(math.cosh, "function cosh (removed)")
 end
@@ -99,7 +99,7 @@ do -- deg
 end
 
 do -- exp
-    matches(math.exp(1.0), '^2%.718', "function exp")
+    near(math.exp(1.0), 2.718, 0.001, "function exp")
 end
 
 do -- floor
@@ -112,9 +112,9 @@ do -- floor
 end
 
 do -- fmod
-    matches(math.fmod(7.0001, 0.3), '^0%.100', "function fmod (float)")
-    matches(math.fmod(-7.0001, 0.3), '^-0%.100')
-    matches(math.fmod(-7.0001, -0.3), '^-0%.100')
+    near(math.fmod(7.0001, 0.3), 0.100, 0.001, "function fmod (float)")
+    near(math.fmod(-7.0001, 0.3), -0.100, 0.001)
+    near(math.fmod(-7.0001, -0.3), -0.100, 0.001)
     if math.type then
         equals(math.type(math.fmod(7.0, 0.3)), 'float')
     end
@@ -155,17 +155,17 @@ else
 end
 
 do -- log
-    matches(math.log(47), '^3%.85', "function log")
+    near(math.log(47), 3.85, 0.01, "function log")
     if has_log_with_base then
-        matches(math.log(47, math.exp(1)), '^3%.85', "function log (base e)")
-        matches(math.log(47, 2), '^5%.554', "function log (base 2)")
-        matches(math.log(47, 10), '^1%.672', "function log (base 10)")
+        near(math.log(47, math.exp(1)), 3.85, 0.01, "function log (base e)")
+        near(math.log(47, 2), 5.554, 0.001, "function log (base 2)")
+        near(math.log(47, 10), 1.672, 0.001, "function log (base 10)")
     end
 end
 
 -- log10
 if has_log10 then
-    matches(math.log10(47.0), '^1%.672', "function log10")
+    near(math.log10(47.0), 1.672, 0.001, "function log10")
 else
     is_nil(math.log10, "function log10 (removed)")
 end
@@ -223,7 +223,7 @@ do -- modf
 end
 
 do -- pi
-    matches(tostring(math.pi), '^3%.14', "variable pi")
+    near(math.pi, 3.14, 0.01, "variable pi")
 end
 
 -- pow
@@ -234,7 +234,7 @@ else
 end
 
 do -- rad
-    matches(math.rad(180), '^3%.14', "function rad")
+    near(math.rad(180), 3.14, 0.01, "function rad")
 end
 
 do -- random
@@ -291,27 +291,27 @@ do -- randomseed
 end
 
 do -- sin
-    matches(math.sin(1.0), '^0%.841', "function sin")
+    near(math.sin(1.0), 0.841, 0.001, "function sin")
 end
 
 -- sinh
 if has_mathx then
-    matches(math.sinh(1), '^1%.175', "function sinh")
+    near(math.sinh(1), 1.175, 0.001, "function sinh")
 else
     is_nil(math.sinh, "function sinh (removed)")
 end
 
 do -- sqrt
-    matches(math.sqrt(2), '^1%.414', "function sqrt")
+    near(math.sqrt(2), 1.414, 0.001, "function sqrt")
 end
 
 do -- tan
-    matches(math.tan(1.0), '^1%.557', "function tan")
+    near(math.tan(1.0), 1.557, 0.001, "function tan")
 end
 
 -- tanh
 if has_mathx then
-    matches(math.tanh(1), '^0%.761', "function tanh")
+    near(math.tanh(1), 0.761, 0.001, "function tanh")
 else
     is_nil(math.tanh, "function tanh (removed)")
 end
diff --git a/test/lua-Harness-tests/310-debug.t b/test/lua-Harness-tests/310-debug.t
index f8338d1f..a75047f2 100755
--- a/test/lua-Harness-tests/310-debug.t
+++ b/test/lua-Harness-tests/310-debug.t
@@ -42,8 +42,6 @@ local has_setmetatable52 = _VERSION >= 'Lua 5.2' or (profile.luajit_compat52 and
 local has_upvalueid = _VERSION >= 'Lua 5.2' or jit
 local has_upvaluejoin = _VERSION >= 'Lua 5.2' or jit
 
-local debug = require 'debug'
-
 if not debug then
     skip_all("no debug")
 end
diff --git a/test/lua-Harness-tests/320-stdin.t b/test/lua-Harness-tests/320-stdin.t
index f4de97fd..cc867309 100755
--- a/test/lua-Harness-tests/320-stdin.t
+++ b/test/lua-Harness-tests/320-stdin.t
@@ -32,7 +32,7 @@ if not pcall(io.popen, lua .. [[ -e "a=1"]]) then
     skip_all "io.popen not supported"
 end
 
-plan(12)
+plan'no_plan'
 
 do
     local f = io.open('lib-320.lua', 'w')
@@ -49,7 +49,7 @@ end
 
     local cmd = lua .. [[ -e "dofile(); n = norm(3.4, 1.0); print(twice(n))" < lib-320.lua]]
     f = io.popen(cmd)
-    matches(f:read'*l', '^7%.088', "function dofile (stdin)")
+    near(f:read'*n', 7.088, 0.001, "function dofile (stdin)")
     f:close()
 
     os.remove('lib-320.lua') -- clean up
@@ -102,14 +102,14 @@ do
 
     local cmd = lua .. [[ -e "while true do local n1, n2, n3 = io.read('*number', '*number', '*number'); if not n1 then break end; print(math.max(n1, n2, n3)) end" < number-320.txt]]
     f = io.popen(cmd)
-    matches(f:read'*l', '15000%.?', "function io:read *number")
-    equals(f:read'*l', '1000001')
+    equals(f:read'*n', 15000, "function io:read *number")
+    equals(f:read'*n', 1000001)
     f:close()
 
     os.remove('number-320.txt') -- clean up
 end
 
-do
+if debug then
     local f = io.open('dbg-320.txt', 'w')
     f:write("print 'ok'\n")
     f:write("error 'dbg'\n")
@@ -123,8 +123,12 @@ do
     f:close()
 
     os.remove('dbg-320.txt') -- clean up
+else
+    diag("no debug")
 end
 
+done_testing()
+
 -- Local Variables:
 --   mode: lua
 --   lua-indent-level: 4
diff --git a/test/lua-Harness-tests/401-bitop.t b/test/lua-Harness-tests/401-bitop.t
index 84259cd3..66a99eb2 100755
--- a/test/lua-Harness-tests/401-bitop.t
+++ b/test/lua-Harness-tests/401-bitop.t
@@ -18,7 +18,7 @@
 
 =head2 Description
 
-See L<http://bitop.luajit.org/>.
+See L<https://bitop.luajit.org/>.
 
 =cut
 
diff --git a/test/lua-Harness-tests/402-ffi.t b/test/lua-Harness-tests/402-ffi.t
index 48ae8c20..22d47aec 100755
--- a/test/lua-Harness-tests/402-ffi.t
+++ b/test/lua-Harness-tests/402-ffi.t
@@ -18,7 +18,7 @@
 
 =head2 Description
 
-See L<http://luajit.org/ext_ffi.html>.
+See L<https://luajit.org/ext_ffi.html>.
 
 =cut
 
diff --git a/test/lua-Harness-tests/403-jit.t b/test/lua-Harness-tests/403-jit.t
index 1724dfd1..0f986da9 100755
--- a/test/lua-Harness-tests/403-jit.t
+++ b/test/lua-Harness-tests/403-jit.t
@@ -18,7 +18,7 @@
 
 =head2 Description
 
-See L<http://luajit.org/ext_jit.html>.
+See L<https://luajit.org/ext_jit.html>.
 
 =cut
 
diff --git a/test/lua-Harness-tests/404-ext.t b/test/lua-Harness-tests/404-ext.t
index 45701671..c3b8370d 100755
--- a/test/lua-Harness-tests/404-ext.t
+++ b/test/lua-Harness-tests/404-ext.t
@@ -18,7 +18,7 @@
 
 =head2 Description
 
-See L<http://luajit.org/ext_jit.html>.
+See L<https://luajit.org/ext_jit.html>.
 
 =cut
 
diff --git a/test/lua-Harness-tests/411-luajit.t b/test/lua-Harness-tests/411-luajit.t
index da1af9ce..3a9a7b8f 100755
--- a/test/lua-Harness-tests/411-luajit.t
+++ b/test/lua-Harness-tests/411-luajit.t
@@ -18,7 +18,7 @@
 
 =head2 Description
 
-See L<http://luajit.org/running.html>
+See L<https://luajit.org/running.html>
 
 =cut
 
diff --git a/test/lua-Harness-tests/profile_ravi.lua b/test/lua-Harness-tests/profile_ravi.lua
index 8cd2464e..fcee5cb1 100644
--- a/test/lua-Harness-tests/profile_ravi.lua
+++ b/test/lua-Harness-tests/profile_ravi.lua
@@ -31,7 +31,7 @@ local profile = {
 --]]
 
     nocvtn2s = false,
-    nocvts2n = false,
+    nocvts2n = true,
 
     compat53 = false,
 --[[
@@ -51,7 +51,7 @@ package.loaded.profile = profile        -- prevents loading of default profile
 return profile
 
 --
--- Copyright (c) 2018-2019 Francois Perrad
+-- Copyright (c) 2018-2021 Francois Perrad
 --
 -- This library is licensed under the terms of the MIT/X11 license,
 -- like Lua itself.
diff --git a/test/lua-Harness-tests/test_assertion.lua b/test/lua-Harness-tests/test_assertion.lua
index 67cf37f9..a4a9c6ca 100644
--- a/test/lua-Harness-tests/test_assertion.lua
+++ b/test/lua-Harness-tests/test_assertion.lua
@@ -94,6 +94,15 @@ function not_equals (got, not_expected, name)
     end
 end
 
+function near (got, expected, tolerance, name)
+    local pass = got >= (expected - tolerance) and got <= (expected + tolerance)
+    truthy(pass, name)
+    if not pass then
+        diag("         got: " .. tostring(got))
+        diag("    expected: " .. tostring(expected) .. " +/- " .. tostring(tolerance))
+    end
+end
+
 function matches (got, pattern, name)
     local pass = tostring(got):match(pattern)
     truthy(pass, name)
-- 
2.32.0


^ permalink raw reply	[flat|nested] 22+ messages in thread

* [Tarantool-patches] [PATCH v2 10/10] test: disable test/lua-Harness-tests/241-standalone.t on FreeBSD
  2021-07-20 16:26 [Tarantool-patches] [PATCH v2 00/10] test: lua-Harness suite patch bump Maxim Kokryashkin via Tarantool-patches
                   ` (8 preceding siblings ...)
  2021-07-20 16:26 ` [Tarantool-patches] [PATCH v2 09/10] test: update lua-Harness to b7b1a9a2 Maxim Kokryashkin via Tarantool-patches
@ 2021-07-20 16:26 ` Maxim Kokryashkin via Tarantool-patches
  2021-07-25 21:17   ` Igor Munkin via Tarantool-patches
  2021-07-25 21:03 ` [Tarantool-patches] [PATCH v2 00/10] test: lua-Harness suite patch bump Igor Munkin via Tarantool-patches
  10 siblings, 1 reply; 22+ messages in thread
From: Maxim Kokryashkin via Tarantool-patches @ 2021-07-20 16:26 UTC (permalink / raw)
  To: tarantool-patches, imun, skaplun

Tarantool interactive mode misbehaviour has been found on FreeBSD (for more info see #6231).
Hence, this particular assertion is masked for FreeBSD until the mentioned issue resolves.

Resolves #5970
Part of #4473
---
Additional info: https://github.com/tarantool/tarantool/issues/5970#issuecomment-883253400

 test/lua-Harness-tests/241-standalone.t | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/test/lua-Harness-tests/241-standalone.t b/test/lua-Harness-tests/241-standalone.t
index afbcf5b8..d5373b9f 100755
--- a/test/lua-Harness-tests/241-standalone.t
+++ b/test/lua-Harness-tests/241-standalone.t
@@ -51,6 +51,10 @@ if not pcall(io.popen, lua .. [[ -e "a=1"]]) then
     skip_all "io.popen not supported"
 end
 
+if jit.os == 'BSD' then
+    skip_all "BSD is not supported yet"
+end
+
 plan'no_plan'
 diag(lua)
 
-- 
2.32.0


^ permalink raw reply	[flat|nested] 22+ messages in thread

* Re: [Tarantool-patches] [PATCH v2 00/10] test: lua-Harness suite patch bump
  2021-07-20 16:26 [Tarantool-patches] [PATCH v2 00/10] test: lua-Harness suite patch bump Maxim Kokryashkin via Tarantool-patches
                   ` (9 preceding siblings ...)
  2021-07-20 16:26 ` [Tarantool-patches] [PATCH v2 10/10] test: disable test/lua-Harness-tests/241-standalone.t on FreeBSD Maxim Kokryashkin via Tarantool-patches
@ 2021-07-25 21:03 ` Igor Munkin via Tarantool-patches
  10 siblings, 0 replies; 22+ messages in thread
From: Igor Munkin via Tarantool-patches @ 2021-07-25 21:03 UTC (permalink / raw)
  To: Maxim Kokryashkin; +Cc: tarantool-patches

Max,

Thanks for the series! Please consider the comments I left for each
patch. Besides, to differ the patches for tarantool/tarantool repo from
the patches for tarantool/luajit repo, please use 'luajit' in subject
prefix when formatting the patch (consider this patch[1] as an example).

On 20.07.21, Maxim Kokryashkin wrote:
> As our experience has been considered by the maintainer of lua-Harness
> and the issues we faced are finally fixed in mainline repo, we should
> bump lua-Harness suite up to c4451fe0.
> 
> Part of tarantool/tarantool#5970
> Part of tarantool/tarantool#4473
> 
> ---
> Changes in v2:
>   - Fixed comments as per review by Igor Munkin <imun@tarantool.org>
>   - Backported two more fixes from trunk
>   - Disabled 241-standalone.t as it is facing some issues to run 
>     properly on FreeBSD (for more information see
>     tarantool/tarantool#6231)
> 
> Github branch: 
> https://github.com/tarantool/luajit/tree/fckxorg/gh-5970-update-lua-harness
> 
> Issue:
> https://github.com/tarantool/tarantool/issues/5970
> 
> Tests: passing

It's more convenient to share the commit that triggered Tarantool CI. In
your case this is https://github.com/tarantool/tarantool/commit/344c18d.

> 
> 
> Maxim Kokryashkin (10):
>   test: port lua-Harness to Test.Assertion
>   test: rename lua-Harness tap to test_assertion
>   test: use CI friendly variables in lua-Harness
>   test: refactor with _retrieve_progname
>   test: refactor with _dofile
>   test: support tarantool in lua-Harness
>   test: backport lua-Harness directory detection
>   test: support tarantool cli in lua-Harness
>   test: update lua-Harness to b7b1a9a2
>   test: disable test/lua-Harness-tests/241-standalone.t on FreeBSD
> 
>  test/lua-Harness-tests/090-tap.t              |  10 +-
>  test/lua-Harness-tests/091-profile.t          |  12 +-
>  test/lua-Harness-tests/101-boolean.t          | 130 +--
>  test/lua-Harness-tests/102-function.t         | 222 +++---
>  test/lua-Harness-tests/103-nil.t              | 130 +--
>  test/lua-Harness-tests/104-number.t           | 274 +++----
>  test/lua-Harness-tests/105-string.t           | 312 ++++----
>  test/lua-Harness-tests/106-table.t            | 136 ++--
>  test/lua-Harness-tests/107-thread.t           | 132 +--
>  test/lua-Harness-tests/108-userdata.t         | 128 +--
>  test/lua-Harness-tests/200-examples.t         |  16 +-
>  test/lua-Harness-tests/201-assign.t           |  84 +-
>  test/lua-Harness-tests/202-expr.t             | 140 ++--
>  test/lua-Harness-tests/203-lexico.t           |  78 +-
>  test/lua-Harness-tests/204-grammar.t          |  78 +-
>  test/lua-Harness-tests/211-scope.t            |  26 +-
>  test/lua-Harness-tests/212-function.t         | 140 ++--
>  test/lua-Harness-tests/213-closure.t          |  34 +-
>  test/lua-Harness-tests/214-coroutine.t        |  98 +--
>  test/lua-Harness-tests/221-table.t            |  56 +-
>  test/lua-Harness-tests/222-constructor.t      |  36 +-
>  test/lua-Harness-tests/223-iterator.t         |  20 +-
>  test/lua-Harness-tests/231-metatable.t        | 236 +++---
>  test/lua-Harness-tests/232-object.t           |  40 +-
>  test/lua-Harness-tests/241-standalone.t       | 330 ++++++++
>  .../241-standalone.t.disabled                 | 269 -------
>  test/lua-Harness-tests/242-luac.t             |  88 +-
>  test/lua-Harness-tests/301-basic.t            | 754 +++++++++---------
>  test/lua-Harness-tests/303-package.t          | 125 +--
>  test/lua-Harness-tests/304-string.t           | 650 +++++++--------
>  test/lua-Harness-tests/305-utf8.t             |  10 +-
>  test/lua-Harness-tests/306-table.t            | 188 ++---
>  test/lua-Harness-tests/307-math.t             | 268 +++----
>  test/lua-Harness-tests/308-io.t               | 252 +++---
>  test/lua-Harness-tests/309-os.t               | 164 ++--
>  test/lua-Harness-tests/310-debug.t            | 230 +++---
>  test/lua-Harness-tests/311-bit32.t            |  72 +-
>  test/lua-Harness-tests/314-regex.t            |  12 +-
>  test/lua-Harness-tests/320-stdin.t            |  40 +-
>  test/lua-Harness-tests/401-bitop.t            |  64 +-
>  test/lua-Harness-tests/402-ffi.t              |  82 +-
>  test/lua-Harness-tests/403-jit.t              | 100 +--
>  test/lua-Harness-tests/404-ext.t              | 168 ++--
>  test/lua-Harness-tests/411-luajit.t           | 211 +++++
>  test/lua-Harness-tests/411-luajit.t.disabled  | 211 -----
>  test/lua-Harness-tests/CMakeLists.txt         |   5 -
>  test/lua-Harness-tests/lexico52/lexico.t      |  22 +-
>  test/lua-Harness-tests/lexico53/boolean.t     |  44 +-
>  test/lua-Harness-tests/lexico53/function.t    |  72 +-
>  test/lua-Harness-tests/lexico53/lexico.t      |  14 +-
>  test/lua-Harness-tests/lexico53/nil.t         |  44 +-
>  test/lua-Harness-tests/lexico53/number.t      | 224 +++---
>  test/lua-Harness-tests/lexico53/string.t      | 196 ++---
>  test/lua-Harness-tests/lexico53/table.t       |  44 +-
>  test/lua-Harness-tests/lexico53/thread.t      |  44 +-
>  test/lua-Harness-tests/lexico53/userdata.t    |  44 +-
>  test/lua-Harness-tests/lexico53/utf8.t        | 240 +++---
>  test/lua-Harness-tests/lexico54/lexico.t      |   8 +-
>  test/lua-Harness-tests/lexico54/metatable.t   |  14 +-
>  test/lua-Harness-tests/lexico54/utf8.t        |  34 +-
>  test/lua-Harness-tests/lexicojit/basic.t      |  14 +-
>  test/lua-Harness-tests/lexicojit/ext.t        |  26 +-
>  test/lua-Harness-tests/lexicojit/lexico.t     |  30 +-
>  test/lua-Harness-tests/profile_ravi.lua       |   4 +-
>  test/lua-Harness-tests/profile_tarantool.lua  |  63 ++
>  .../{tap.lua => test_assertion.lua}           | 133 +--
>  test/luajit-test-init.lua                     |   2 +
>  67 files changed, 4165 insertions(+), 4012 deletions(-)
>  create mode 100755 test/lua-Harness-tests/241-standalone.t
>  delete mode 100755 test/lua-Harness-tests/241-standalone.t.disabled
>  create mode 100755 test/lua-Harness-tests/411-luajit.t
>  delete mode 100755 test/lua-Harness-tests/411-luajit.t.disabled
>  create mode 100644 test/lua-Harness-tests/profile_tarantool.lua
>  rename test/lua-Harness-tests/{tap.lua => test_assertion.lua} (58%)
> 
> -- 
> 2.32.0
> 

[1]: https://lists.tarantool.org/tarantool-patches/5fdb4899061156f0fb4c53027d55f93be3a24759.1627144350.git.imun@tarantool.org/T/#u

-- 
Best regards,
IM

^ permalink raw reply	[flat|nested] 22+ messages in thread

* Re: [Tarantool-patches] [PATCH v2 01/10] test: port lua-Harness to Test.Assertion
  2021-07-20 16:26 ` [Tarantool-patches] [PATCH v2 01/10] test: port lua-Harness to Test.Assertion Maxim Kokryashkin via Tarantool-patches
@ 2021-07-25 21:08   ` Igor Munkin via Tarantool-patches
  0 siblings, 0 replies; 22+ messages in thread
From: Igor Munkin via Tarantool-patches @ 2021-07-25 21:08 UTC (permalink / raw)
  To: Maxim Kokryashkin; +Cc: tarantool-patches

Max,

Thanks for the patch! LGTM, except the several nits.

On 20.07.21, Maxim Kokryashkin wrote:
> Backports conversion to Test.Assertion patch[1] from lua-Harness suite

Typo: Dot is missing at the end of the sentence.

> 
> As a result out of this change out-of-source testing is broken, but the

Typo: s/As a result out of/As a result of/.

> previous assertion using package.path as a second argument worked fine.
> Because of that, this commit includes fix, that was made by this patch[2]
> in mainline lua-Harness.
> 
> [1]: https://framagit.org/fperrad/lua-Harness/-/commit/074fefa51da1276078f735fa8fb568963fe541f1
> [2]: https://framagit.org/fperrad/lua-Harness/-/commit/c4451fe06fcdc0d83a72dfa56eaae3ed26151c04

Minor: You can strip commit hash in the links above up to 7 symbols to
shorted them a bit. Feel free to ignore.

> 
> Part of tarantool/tarantool#5970
> Part of tarantool/tarantool#4473
> ---
> Additional comments on issue with out-of-source testing:
> https://github.com/tarantool/tarantool/issues/5970#issuecomment-880158605
> 
>  test/lua-Harness-tests/090-tap.t              |   8 +-
>  test/lua-Harness-tests/091-profile.t          |  10 +-
>  test/lua-Harness-tests/101-boolean.t          | 126 +--
>  test/lua-Harness-tests/102-function.t         | 218 ++---
>  test/lua-Harness-tests/103-nil.t              | 126 +--
>  test/lua-Harness-tests/104-number.t           | 270 +++----
>  test/lua-Harness-tests/105-string.t           | 308 ++++----
>  test/lua-Harness-tests/106-table.t            | 132 ++--
>  test/lua-Harness-tests/107-thread.t           | 128 +--
>  test/lua-Harness-tests/108-userdata.t         | 124 +--
>  test/lua-Harness-tests/200-examples.t         |  12 +-
>  test/lua-Harness-tests/201-assign.t           |  82 +-
>  test/lua-Harness-tests/202-expr.t             | 138 ++--
>  test/lua-Harness-tests/203-lexico.t           |  66 +-
>  test/lua-Harness-tests/204-grammar.t          |  76 +-
>  test/lua-Harness-tests/211-scope.t            |  24 +-
>  test/lua-Harness-tests/212-function.t         | 138 ++--
>  test/lua-Harness-tests/213-closure.t          |  32 +-
>  test/lua-Harness-tests/214-coroutine.t        |  96 +--
>  test/lua-Harness-tests/221-table.t            |  54 +-
>  test/lua-Harness-tests/222-constructor.t      |  34 +-
>  test/lua-Harness-tests/223-iterator.t         |  18 +-
>  test/lua-Harness-tests/231-metatable.t        | 232 +++---
>  test/lua-Harness-tests/232-object.t           |  38 +-
>  .../241-standalone.t.disabled                 | 116 +--
>  test/lua-Harness-tests/242-luac.t             |  80 +-
>  test/lua-Harness-tests/301-basic.t            | 748 +++++++++---------
>  test/lua-Harness-tests/303-package.t          | 119 +--
>  test/lua-Harness-tests/304-string.t           | 648 +++++++--------
>  test/lua-Harness-tests/305-utf8.t             |   4 +-
>  test/lua-Harness-tests/306-table.t            | 186 ++---
>  test/lua-Harness-tests/307-math.t             | 266 +++----
>  test/lua-Harness-tests/308-io.t               | 248 +++---
>  test/lua-Harness-tests/309-os.t               | 158 ++--
>  test/lua-Harness-tests/310-debug.t            | 226 +++---
>  test/lua-Harness-tests/311-bit32.t            |  70 +-
>  test/lua-Harness-tests/314-regex.t            |   8 +-
>  test/lua-Harness-tests/320-stdin.t            |  26 +-
>  test/lua-Harness-tests/401-bitop.t            |  60 +-
>  test/lua-Harness-tests/402-ffi.t              |  78 +-
>  test/lua-Harness-tests/403-jit.t              |  96 +--
>  test/lua-Harness-tests/404-ext.t              | 162 ++--
>  test/lua-Harness-tests/411-luajit.t.disabled  | 166 ++--
>  test/lua-Harness-tests/lexico52/lexico.t      |  22 +-
>  test/lua-Harness-tests/lexico53/boolean.t     |  44 +-
>  test/lua-Harness-tests/lexico53/function.t    |  72 +-
>  test/lua-Harness-tests/lexico53/lexico.t      |  14 +-
>  test/lua-Harness-tests/lexico53/nil.t         |  44 +-
>  test/lua-Harness-tests/lexico53/number.t      | 224 +++---
>  test/lua-Harness-tests/lexico53/string.t      | 196 ++---
>  test/lua-Harness-tests/lexico53/table.t       |  44 +-
>  test/lua-Harness-tests/lexico53/thread.t      |  44 +-
>  test/lua-Harness-tests/lexico53/userdata.t    |  44 +-
>  test/lua-Harness-tests/lexico53/utf8.t        | 240 +++---
>  test/lua-Harness-tests/lexico54/lexico.t      |   8 +-
>  test/lua-Harness-tests/lexico54/metatable.t   |  14 +-
>  test/lua-Harness-tests/lexico54/utf8.t        |  34 +-
>  test/lua-Harness-tests/lexicojit/basic.t      |  14 +-
>  test/lua-Harness-tests/lexicojit/ext.t        |  26 +-
>  test/lua-Harness-tests/lexicojit/lexico.t     |  30 +-
>  test/lua-Harness-tests/tap.lua                |  96 ++-
>  61 files changed, 3599 insertions(+), 3566 deletions(-)
> 

<snipped>

> -- 
> 2.32.0
> 

-- 
Best regards,
IM

^ permalink raw reply	[flat|nested] 22+ messages in thread

* Re: [Tarantool-patches] [PATCH v2 02/10] test: rename lua-Harness tap to test_assertion
  2021-07-20 16:26 ` [Tarantool-patches] [PATCH v2 02/10] test: rename lua-Harness tap to test_assertion Maxim Kokryashkin via Tarantool-patches
@ 2021-07-25 21:08   ` Igor Munkin via Tarantool-patches
  0 siblings, 0 replies; 22+ messages in thread
From: Igor Munkin via Tarantool-patches @ 2021-07-25 21:08 UTC (permalink / raw)
  To: Maxim Kokryashkin; +Cc: tarantool-patches

Max,

Thanks for the fixes! LGTM.

-- 
Best regards,
IM

^ permalink raw reply	[flat|nested] 22+ messages in thread

* Re: [Tarantool-patches] [PATCH v2 03/10] test: use CI friendly variables in lua-Harness
  2021-07-20 16:26 ` [Tarantool-patches] [PATCH v2 03/10] test: use CI friendly variables in lua-Harness Maxim Kokryashkin via Tarantool-patches
@ 2021-07-25 21:09   ` Igor Munkin via Tarantool-patches
  0 siblings, 0 replies; 22+ messages in thread
From: Igor Munkin via Tarantool-patches @ 2021-07-25 21:09 UTC (permalink / raw)
  To: Maxim Kokryashkin; +Cc: tarantool-patches

Max,

Thanks for the fixes! LGTM.

-- 
Best regards,
IM

^ permalink raw reply	[flat|nested] 22+ messages in thread

* Re: [Tarantool-patches] [PATCH v2 04/10] test: refactor with _retrieve_progname
  2021-07-20 16:26 ` [Tarantool-patches] [PATCH v2 04/10] test: refactor with _retrieve_progname Maxim Kokryashkin via Tarantool-patches
@ 2021-07-25 21:09   ` Igor Munkin via Tarantool-patches
  0 siblings, 0 replies; 22+ messages in thread
From: Igor Munkin via Tarantool-patches @ 2021-07-25 21:09 UTC (permalink / raw)
  To: Maxim Kokryashkin; +Cc: tarantool-patches

Max,

Thanks for the fixes! LGTM.

-- 
Best regards,
IM

































^ permalink raw reply	[flat|nested] 22+ messages in thread

* Re: [Tarantool-patches] [PATCH v2 05/10] test: refactor with _dofile
  2021-07-20 16:26 ` [Tarantool-patches] [PATCH v2 05/10] test: refactor with _dofile Maxim Kokryashkin via Tarantool-patches
@ 2021-07-25 21:10   ` Igor Munkin via Tarantool-patches
  0 siblings, 0 replies; 22+ messages in thread
From: Igor Munkin via Tarantool-patches @ 2021-07-25 21:10 UTC (permalink / raw)
  To: Maxim Kokryashkin; +Cc: tarantool-patches

Max,

Thanks for the fixes! LGTM, except the three typos in
luajit-test-init.lua.

On 20.07.21, Maxim Kokryashkin wrote:
> The patch[1] from lua-Harness suite is quite similar to commit
> d11c5bbc08a118b11167c5d455d4024607dab662 ('test: adjust lua-Harness
> tests that use dofile'), with the one difference (except the naming):
> `make_specific_checks()` provides the particular behaviour to run the
> tests for out-of-source build, however `_dofile()` allows user to
> overload this function considering his purposes. If user leave
> `_dofile()` untouched, it defaults to `dofile()` Lua standard library
> function.
> 
> It's worth to mention, that LuaJIT testing machinery has been using
> such approach since commit 734cc0f1d508429c2c3c46bd1860398db0051060
> ('test: adapt PUC-Rio suite for out-of-source build') and `_dofile()`
> behaviour for running tests when out of source build is used is
> already defined in luajit-test-init.lua.
> 
> [1]: https://framagit.org/fperrad/lua-Harness/-/commit/60da289
> 
> Part of tarantool/tarantool#5970
> Part of tarantool/tarantool#4473
> ---
>  test/lua-Harness-tests/101-boolean.t      |  2 +-
>  test/lua-Harness-tests/102-function.t     |  2 +-
>  test/lua-Harness-tests/103-nil.t          |  2 +-
>  test/lua-Harness-tests/104-number.t       |  2 +-
>  test/lua-Harness-tests/105-string.t       |  2 +-
>  test/lua-Harness-tests/106-table.t        |  2 +-
>  test/lua-Harness-tests/107-thread.t       |  2 +-
>  test/lua-Harness-tests/108-userdata.t     |  2 +-
>  test/lua-Harness-tests/203-lexico.t       |  8 ++++----
>  test/lua-Harness-tests/231-metatable.t    |  2 +-
>  test/lua-Harness-tests/301-basic.t        |  2 +-
>  test/lua-Harness-tests/305-utf8.t         |  4 ++--
>  test/lua-Harness-tests/404-ext.t          |  2 +-
>  test/lua-Harness-tests/test_assertion.lua | 10 ++--------
>  test/luajit-test-init.lua                 |  2 ++
>  15 files changed, 21 insertions(+), 25 deletions(-)
> 

<snipped>

> diff --git a/test/luajit-test-init.lua b/test/luajit-test-init.lua
> index 54a1f815..feec17cf 100644
> --- a/test/luajit-test-init.lua
> +++ b/test/luajit-test-init.lua
> @@ -2,6 +2,8 @@
>  -- `_loadfile()` exists and uses it for code loading from test
>  -- files. If the variable is not defined then suite uses
>  -- `loadfile()` as default. Same for the `_dofile()`.
> +-- Lua-Harness also uses the same implementation of `dofile()`

Typo: s/Lua-Harness/lua-Harness/.

> +-- fot he same reason

Typo: s/fot/for/.
Typo: Dot is missing at the end of the sentence.

>  
>  -- XXX: Some tests in PUC Rio Lua 5.1 test suite clean `arg`
>  -- variable, so evaluate this once and use later.
> -- 
> 2.32.0
> 

-- 
Best regards,
IM

^ permalink raw reply	[flat|nested] 22+ messages in thread

* Re: [Tarantool-patches] [PATCH v2 06/10] test: support tarantool in lua-Harness
  2021-07-20 16:26 ` [Tarantool-patches] [PATCH v2 06/10] test: support tarantool in lua-Harness Maxim Kokryashkin via Tarantool-patches
@ 2021-07-25 21:11   ` Igor Munkin via Tarantool-patches
  0 siblings, 0 replies; 22+ messages in thread
From: Igor Munkin via Tarantool-patches @ 2021-07-25 21:11 UTC (permalink / raw)
  To: Maxim Kokryashkin; +Cc: tarantool-patches

Max,

Thanks for the patch! The changes are fine, so no comments regarding
them, but please consider the nit regarding the commit message.

On 20.07.21, Maxim Kokryashkin wrote:
> Backports 'supoort Tarantool' patch[1] from lua-Harness.

Please, describe the changes in details. E.g. it's worth to mention that
this patch introduces lua-Harness profile for Tarantool considering the
platform specifics. Furthermore, these changes skips all CLI-related
tests for Tarantool binary, so 241-standalone.t and 411-luajit.t can be
renamed back.

> 
> [1]: https://framagit.org/fperrad/lua-Harness/-/commit/d3ceee16
> 
> Part of tarantool/tarantool#5970
> Part of tarantool/tarantool#4473
> ---
>  ...standalone.t.disabled => 241-standalone.t} |  5 ++
>  test/lua-Harness-tests/320-stdin.t            |  2 +-
>  .../{411-luajit.t.disabled => 411-luajit.t}   |  2 +-
>  test/lua-Harness-tests/profile_tarantool.lua  | 63 +++++++++++++++++++
>  4 files changed, 70 insertions(+), 2 deletions(-)
>  rename test/lua-Harness-tests/{241-standalone.t.disabled => 241-standalone.t} (99%)
>  rename test/lua-Harness-tests/{411-luajit.t.disabled => 411-luajit.t} (99%)
>  create mode 100644 test/lua-Harness-tests/profile_tarantool.lua
> 

<snipped>

> -- 
> 2.32.0
> 

-- 
Best regards,
IM

^ permalink raw reply	[flat|nested] 22+ messages in thread

* Re: [Tarantool-patches] [PATCH v2 07/10] test: backport lua-Harness directory detection
  2021-07-20 16:26 ` [Tarantool-patches] [PATCH v2 07/10] test: backport lua-Harness directory detection Maxim Kokryashkin via Tarantool-patches
@ 2021-07-25 21:12   ` Igor Munkin via Tarantool-patches
  0 siblings, 0 replies; 22+ messages in thread
From: Igor Munkin via Tarantool-patches @ 2021-07-25 21:12 UTC (permalink / raw)
  To: Maxim Kokryashkin; +Cc: tarantool-patches

Max,

Thanks for the patch! LGTM, except the three typos.

On 20.07.21, Maxim Kokryashkin wrote:
> The patch[1] from lua-Harness fixes the same issue commit

Typo: The link is missing.

> 789820aac7cecc3b5ae394aadc12a5ec25b68121('test: fix directory detection

Typo: Space is missing after the commit hash.

> in lua-Harness suite') does, but it also works on Windows, so the
> mentioned commit can be supreseded by that patch.

Typo: s/supreseded/superseded/.

> 
> Part of tarantool/tarantool#5970
> Part of tarantool/tarantool#4473
> ---
>  test/lua-Harness-tests/314-regex.t | 2 +-
>  1 file changed, 1 insertion(+), 1 deletion(-)
> 

<snipped>

> -- 
> 2.32.0
> 

-- 
Best regards,
IM

^ permalink raw reply	[flat|nested] 22+ messages in thread

* Re: [Tarantool-patches] [PATCH v2 08/10] test: support tarantool cli in lua-Harness
  2021-07-20 16:26 ` [Tarantool-patches] [PATCH v2 08/10] test: support tarantool cli in lua-Harness Maxim Kokryashkin via Tarantool-patches
@ 2021-07-25 21:13   ` Igor Munkin via Tarantool-patches
  0 siblings, 0 replies; 22+ messages in thread
From: Igor Munkin via Tarantool-patches @ 2021-07-25 21:13 UTC (permalink / raw)
  To: Maxim Kokryashkin; +Cc: tarantool-patches

Max,

Thanks for the patch! The changes are fine, but please consider the
comments below regarding the commit message.

On 20.07.21, Maxim Kokryashkin wrote:
> The patch[1] from lua-Harness suite adds some specific checks to
> lua-Harness tests, so they are compatible with Tarantool now.

Strictly saying, no *new* checks are *added*, but the *existing* ones
are *adjusted* considering Tarantool specifics.

> 
> Considering this, commit d4e12d7ac28e3bc857d30971dd77deec66a67297('test:
> disable LuaJIT CLI tests in lua-Harness suite'), which disabled
> tarantool cli tests, can be superseded.

No, it can't. The mentioned commit is superseded by "[PATCH v2 06/10]
test: support tarantool in lua-Harness" in this series.

> 
> As a result, the introduced assertion for Tarantool error message fails
> on MacOS, since getopt_long(3) yields the error message without single
> quotes wrapping the flag. Hence, this commit also includes fix for that
> from patch[2] in the trunk.
> 
> [1]: https://framagit.org/fperrad/lua-Harness/-/commit/1da5b1b3

Minor: 7 digits are enough. This is not critical, but just odd to have
two similar links with the different number of digits, so feel free to
ignore this nit.

> [2]: https://framagit.org/fperrad/lua-Harness/-/commit/a0532c5

Please mention the related issues: #5970 and #4473.

> ---
> Additional information on issue with MacOS:
> https://github.com/tarantool/tarantool/issues/5970#issuecomment-880158605
> 
> NOTICE: tests for this separate commit are failing on FreeBSD
> 
>  test/lua-Harness-tests/241-standalone.t | 79 +++++++++++++++++++------
>  1 file changed, 61 insertions(+), 18 deletions(-)
> 

<snipped>

> -- 
> 2.32.0
> 

-- 
Best regards,
IM

^ permalink raw reply	[flat|nested] 22+ messages in thread

* Re: [Tarantool-patches] [PATCH v2 09/10] test: update lua-Harness to b7b1a9a2
  2021-07-20 16:26 ` [Tarantool-patches] [PATCH v2 09/10] test: update lua-Harness to b7b1a9a2 Maxim Kokryashkin via Tarantool-patches
@ 2021-07-25 21:14   ` Igor Munkin via Tarantool-patches
  0 siblings, 0 replies; 22+ messages in thread
From: Igor Munkin via Tarantool-patches @ 2021-07-25 21:14 UTC (permalink / raw)
  To: Maxim Kokryashkin; +Cc: tarantool-patches

Max,

Thanks for the patch! Please consider the comments below.

On 20.07.21, Maxim Kokryashkin wrote:
> This patch backports several small commits from lua-Harness suite:
> - follow ravi 1.0-beta4[1]
> - refactor with near[2]
> - follow LuaJIT[3]
> - fix when no debug[4]
> - check if luac exists[5]
> - https[6]
> - more assert[7]
> 
> [1]: https://framagit.org/fperrad/lua-Harness/-/commit/9455281b
> [2]: https://framagit.org/fperrad/lua-Harness/-/commit/70404580
> [3]: https://framagit.org/fperrad/lua-Harness/-/commit/ac7671b6
> [4]: https://framagit.org/fperrad/lua-Harness/-/commit/4db7e539
> [5]: https://framagit.org/fperrad/lua-Harness/-/commit/97e9e4c1
> [6]: https://framagit.org/fperrad/lua-Harness/-/commit/673c7869
> [7]: https://framagit.org/fperrad/lua-Harness/-/commit/b7b1a9a2

The changes from the latter commit is missing.

Furthermore, you've updated lua-Harness up to c4451fe, which is
backported in scope of "[PATCH v2 01/10] test: port lua-Harness to
Test.Assertion". Hence, the commit subject need to be updated too.

> 
> Part of #5970
> Part of #4473

BTW, both issues are also mentioned the wrong way. The right format is
tarantool/tarantool#<issue-number> for both cases (see the previous
patches in the series for the examples).

> ---
>  test/lua-Harness-tests/200-examples.t     |  2 +-
>  test/lua-Harness-tests/203-lexico.t       |  2 +-
>  test/lua-Harness-tests/241-standalone.t   |  3 +-
>  test/lua-Harness-tests/242-luac.t         |  4 +++
>  test/lua-Harness-tests/301-basic.t        |  2 +-
>  test/lua-Harness-tests/304-string.t       |  2 +-
>  test/lua-Harness-tests/307-math.t         | 44 +++++++++++------------
>  test/lua-Harness-tests/310-debug.t        |  2 --
>  test/lua-Harness-tests/320-stdin.t        | 14 +++++---
>  test/lua-Harness-tests/401-bitop.t        |  2 +-
>  test/lua-Harness-tests/402-ffi.t          |  2 +-
>  test/lua-Harness-tests/403-jit.t          |  2 +-
>  test/lua-Harness-tests/404-ext.t          |  2 +-
>  test/lua-Harness-tests/411-luajit.t       |  2 +-
>  test/lua-Harness-tests/profile_ravi.lua   |  4 +--
>  test/lua-Harness-tests/test_assertion.lua |  9 +++++
>  16 files changed, 57 insertions(+), 41 deletions(-)
> 

<snipped>

> -- 
> 2.32.0
> 

-- 
Best regards,
IM

^ permalink raw reply	[flat|nested] 22+ messages in thread

* Re: [Tarantool-patches] [PATCH v2 10/10] test: disable test/lua-Harness-tests/241-standalone.t on FreeBSD
  2021-07-20 16:26 ` [Tarantool-patches] [PATCH v2 10/10] test: disable test/lua-Harness-tests/241-standalone.t on FreeBSD Maxim Kokryashkin via Tarantool-patches
@ 2021-07-25 21:17   ` Igor Munkin via Tarantool-patches
  0 siblings, 0 replies; 22+ messages in thread
From: Igor Munkin via Tarantool-patches @ 2021-07-25 21:17 UTC (permalink / raw)
  To: Maxim Kokryashkin; +Cc: tarantool-patches

Max,

Thanks for the patch! Please consider the comments below.

At first, commit subject exceeds 50 symbols and the message exceeds 72
symbols. Please check this patch against our guidelines[1].

On 20.07.21, Maxim Kokryashkin wrote:
> Tarantool interactive mode misbehaviour has been found on FreeBSD (for more info see #6231).

The issue is mentioned the wrong way. The right format is
tarantool/tarantool#6231.

> Hence, this particular assertion is masked for FreeBSD until the mentioned issue resolves.

Strictly saying, you skipped all assertions (not only those using broken
interactive mode), not the particular one.

> 
> Resolves #5970

This patch doesn't resolve the issue, since Tarantool profile introduced
in "[PATCH v2 06/10] test: support tarantool in lua-Harness" is not used
by Tarantool CI. Hence this is only "Part of" patch.

> Part of #4473

BTW, both issues are also mentioned the wrong way. The right format is
tarantool/tarantool#<issue-number> for both cases (see the previous
patches in the series for the examples).

It's also worth to add "Relates to tarantool/tarantool#6231".

> ---
> Additional info: https://github.com/tarantool/tarantool/issues/5970#issuecomment-883253400
> 
>  test/lua-Harness-tests/241-standalone.t | 4 ++++
>  1 file changed, 4 insertions(+)
> 
> diff --git a/test/lua-Harness-tests/241-standalone.t b/test/lua-Harness-tests/241-standalone.t
> index afbcf5b8..d5373b9f 100755
> --- a/test/lua-Harness-tests/241-standalone.t
> +++ b/test/lua-Harness-tests/241-standalone.t
> @@ -51,6 +51,10 @@ if not pcall(io.popen, lua .. [[ -e "a=1"]]) then
>      skip_all "io.popen not supported"
>  end
>  
> +if jit.os == 'BSD' then
> +    skip_all "BSD is not supported yet"
> +end

At first, please add a comment with the rationale for this change.
Furthermore, it's better to skip only assertions using interactive mode
and run other assertions related to CLI behaviour.

> +
>  plan'no_plan'
>  diag(lua)
>  
> -- 
> 2.32.0
> 

[1]: https://www.tarantool.io/en/doc/latest/dev_guide/developer_guidelines/

-- 
Best regards,
IM

^ permalink raw reply	[flat|nested] 22+ messages in thread

end of thread, other threads:[~2021-07-25 21:41 UTC | newest]

Thread overview: 22+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2021-07-20 16:26 [Tarantool-patches] [PATCH v2 00/10] test: lua-Harness suite patch bump Maxim Kokryashkin via Tarantool-patches
2021-07-20 16:26 ` [Tarantool-patches] [PATCH v2 01/10] test: port lua-Harness to Test.Assertion Maxim Kokryashkin via Tarantool-patches
2021-07-25 21:08   ` Igor Munkin via Tarantool-patches
2021-07-20 16:26 ` [Tarantool-patches] [PATCH v2 02/10] test: rename lua-Harness tap to test_assertion Maxim Kokryashkin via Tarantool-patches
2021-07-25 21:08   ` Igor Munkin via Tarantool-patches
2021-07-20 16:26 ` [Tarantool-patches] [PATCH v2 03/10] test: use CI friendly variables in lua-Harness Maxim Kokryashkin via Tarantool-patches
2021-07-25 21:09   ` Igor Munkin via Tarantool-patches
2021-07-20 16:26 ` [Tarantool-patches] [PATCH v2 04/10] test: refactor with _retrieve_progname Maxim Kokryashkin via Tarantool-patches
2021-07-25 21:09   ` Igor Munkin via Tarantool-patches
2021-07-20 16:26 ` [Tarantool-patches] [PATCH v2 05/10] test: refactor with _dofile Maxim Kokryashkin via Tarantool-patches
2021-07-25 21:10   ` Igor Munkin via Tarantool-patches
2021-07-20 16:26 ` [Tarantool-patches] [PATCH v2 06/10] test: support tarantool in lua-Harness Maxim Kokryashkin via Tarantool-patches
2021-07-25 21:11   ` Igor Munkin via Tarantool-patches
2021-07-20 16:26 ` [Tarantool-patches] [PATCH v2 07/10] test: backport lua-Harness directory detection Maxim Kokryashkin via Tarantool-patches
2021-07-25 21:12   ` Igor Munkin via Tarantool-patches
2021-07-20 16:26 ` [Tarantool-patches] [PATCH v2 08/10] test: support tarantool cli in lua-Harness Maxim Kokryashkin via Tarantool-patches
2021-07-25 21:13   ` Igor Munkin via Tarantool-patches
2021-07-20 16:26 ` [Tarantool-patches] [PATCH v2 09/10] test: update lua-Harness to b7b1a9a2 Maxim Kokryashkin via Tarantool-patches
2021-07-25 21:14   ` Igor Munkin via Tarantool-patches
2021-07-20 16:26 ` [Tarantool-patches] [PATCH v2 10/10] test: disable test/lua-Harness-tests/241-standalone.t on FreeBSD Maxim Kokryashkin via Tarantool-patches
2021-07-25 21:17   ` Igor Munkin via Tarantool-patches
2021-07-25 21:03 ` [Tarantool-patches] [PATCH v2 00/10] test: lua-Harness suite patch bump Igor Munkin via Tarantool-patches

Tarantool development patches archive

This inbox may be cloned and mirrored by anyone:

	git clone --mirror https://lists.tarantool.org/tarantool-patches/0 tarantool-patches/git/0.git

	# If you have public-inbox 1.1+ installed, you may
	# initialize and index your mirror using the following commands:
	public-inbox-init -V2 tarantool-patches tarantool-patches/ https://lists.tarantool.org/tarantool-patches \
		tarantool-patches@dev.tarantool.org.
	public-inbox-index tarantool-patches

Example config snippet for mirrors.


AGPL code for this site: git clone https://public-inbox.org/public-inbox.git