Tarantool development patches archive
 help / color / mirror / Atom feed
From: sergeyb@tarantool.org
To: tarantool-patches@dev.tarantool.org
Cc: Vladislav Shpilevoy <v.shpilevoy@tarantool.org>,
	o.piskunov@tarantool.org
Subject: [Tarantool-patches] [PATCH v5 08/10] Fix luacheck warnings in test/
Date: Tue, 12 May 2020 12:50:07 +0300	[thread overview]
Message-ID: <afaf7c097d3e004c26a9ad90c56c0717fb7863ed.1589275364.git.sergeyb@tarantool.org> (raw)
In-Reply-To: <cover.1589275364.git.sergeyb@tarantool.org>

From: Sergey Bronnikov <sergeyb@tarantool.org>

Closes #4681

Reviewed-by: Vladislav Shpilevoy <v.shpilevoy@tarantool.org>
Reviewed-by: Igor Munkin <imun@tarantool.org>

Co-authored-by: Vladislav Shpilevoy <v.shpilevoy@tarantool.org>
Co-authored-by: Igor Munkin <imun@tarantool.org>
---
 .luacheckrc                                   |  29 +-
 test/app-tap/cfg.test.lua                     |   2 +-
 test/app-tap/clock.test.lua                   |   4 +-
 test/app-tap/console.test.lua                 |  16 +-
 test/app-tap/console_lua.test.lua             |  22 +-
 test/app-tap/csv.test.lua                     |  56 +-
 test/app-tap/debug.test.lua                   |  10 +-
 test/app-tap/errno.test.lua                   |  24 +-
 test/app-tap/fail_main.test.lua               |   6 +-
 .../gh-4761-json-per-call-options.test.lua    |  11 +-
 test/app-tap/http_client.test.lua             | 297 +++++------
 test/app-tap/iconv.test.lua                   |   6 +-
 test/app-tap/init_script.test.lua             |  14 +-
 test/app-tap/inspector.test.lua               |   5 +-
 test/app-tap/json.test.lua                    |   1 -
 test/app-tap/logger.test.lua                  |  21 +-
 test/app-tap/minimal.test.lua                 |   4 +-
 test/app-tap/module_api.test.lua              |  12 +-
 test/app-tap/msgpackffi.test.lua              |   3 +-
 test/app-tap/pcall.test.lua                   |   6 +-
 test/app-tap/popen.test.lua                   |  35 +-
 test/app-tap/snapshot.test.lua                |  17 +-
 test/app-tap/string.test.lua                  | 502 +++++++++---------
 test/app-tap/tap.test.lua                     |  26 +-
 test/app-tap/tarantoolctl.test.lua            |  82 ++-
 test/app-tap/trigger.test.lua                 |  48 +-
 test/app-tap/yaml.test.lua                    |  16 +-
 test/box-py/box.lua                           |   2 +-
 test/box-tap/auth.test.lua                    |  36 +-
 test/box-tap/cfg.test.lua                     |  34 +-
 test/box-tap/cfgup.test.lua                   |   2 +-
 test/box-tap/extended_error.test.lua          |  11 +-
 test/box-tap/feedback_daemon.test.lua         |   4 +-
 test/box-tap/gc.test.lua                      |   6 +-
 test/box-tap/gh-4785-syslog.test.lua          |   4 +-
 test/box-tap/key_def.test.lua                 | 132 ++---
 test/box-tap/merger.test.lua                  | 112 ++--
 test/box-tap/on_schema_init.test.lua          |   4 +-
 test/box-tap/schema_mt.test.lua               |  18 +-
 test/box-tap/session.storage.test.lua         |  10 +-
 test/box-tap/session.test.lua                 |  59 +-
 test/box-tap/trigger_atexit.test.lua          |  10 +-
 test/box-tap/trigger_yield.test.lua           |  10 +-
 test/box/box.lua                              |   2 +-
 test/box/hash_multipart.result                |   2 +-
 test/box/hash_multipart.test.lua              |   2 +-
 test/box/lua/bitset.lua                       |   7 +-
 test/box/lua/cfg_bad_vinyl_dir.lua            |   2 +-
 test/box/lua/cfg_rtree.lua                    |   2 +-
 test/box/lua/cfg_test1.lua                    |   2 +-
 test/box/lua/cfg_test2.lua                    |   2 +-
 test/box/lua/cfg_test3.lua                    |   2 +-
 test/box/lua/cfg_test4.lua                    |   2 +-
 test/box/lua/cfg_test5.lua                    |   4 +-
 test/box/lua/cfg_test6.lua                    |   2 +-
 test/box/lua/fifo.lua                         |   2 +-
 test/box/lua/identifier.lua                   |   9 +-
 test/box/lua/index_random_test.lua            |   2 +-
 test/box/lua/require_init.lua                 |   3 -
 test/box/lua/test_init.lua                    |  10 +-
 test/box/lua/utils.lua                        |  13 +-
 test/box/on_schema_init.lua                   |   2 +-
 test/box/proxy.lua                            |   2 +-
 test/box/tiny.lua                             |   2 +-
 test/box/tree_pk.result                       |   4 +-
 test/box/tree_pk.test.lua                     |   4 +-
 test/engine/box.lua                           |   8 +-
 test/engine/conflict.lua                      |   6 +-
 test/engine/tree_min_max_count.result         |   2 +-
 test/engine/tree_min_max_count.test.lua       |   2 +-
 test/engine_long/suite.lua                    |   4 +-
 test/long_run-py/lua/finalizers.lua           |   8 +-
 test/long_run-py/suite.lua                    |   6 +-
 test/replication-py/master.lua                |   2 +-
 test/replication-py/panic.lua                 |   2 +-
 test/replication-py/replica.lua               |   4 -
 test/replication/lua/fast_replica.lua         |   3 +-
 test/replication/lua/rlimit.lua               |   2 +-
 test/replication/master.lua                   |   2 +-
 test/replication/master_quorum.lua            |   4 +-
 test/replication/on_replace.lua               |   6 +-
 test/replication/replica.lua                  |   4 +-
 test/replication/replica_on_schema_init.lua   |   4 +-
 test/replication/replicaset_ro_mostly.result  |   2 +-
 .../replication/replicaset_ro_mostly.test.lua |   2 +-
 test/sql-tap/alter.test.lua                   |   4 +-
 test/sql-tap/analyze3.test.lua                |   6 +-
 test/sql-tap/analyze5.test.lua                |   2 +-
 test/sql-tap/analyze9.test.lua                |  30 +-
 test/sql-tap/between.test.lua                 |   4 +-
 test/sql-tap/date.test.lua                    |   3 +-
 test/sql-tap/delete1.test.lua                 |   2 +-
 test/sql-tap/e_delete.test.lua                |   2 +-
 test/sql-tap/e_expr.test.lua                  |  22 +-
 test/sql-tap/func.test.lua                    |   2 +-
 test/sql-tap/func3.test.lua                   |  24 +-
 test/sql-tap/gh-2723-concurrency.test.lua     |   8 +-
 .../gh-3083-ephemeral-unref-tuples.test.lua   |   2 +-
 .../gh-3307-xfer-optimization-issue.test.lua  |  16 +-
 .../gh-3332-tuple-format-leak.test.lua        |   2 +-
 .../gh-4077-iproto-execute-no-bind.test.lua   |   7 +-
 .../gh2127-indentifier-max-length.test.lua    |  10 +-
 test/sql-tap/identifier-characters.test.lua   |   2 +-
 test/sql-tap/index1.test.lua                  |   3 +-
 test/sql-tap/index7.test.lua                  |   2 +-
 test/sql-tap/join3.test.lua                   |   2 +-
 test/sql-tap/lua-tables.test.lua              |   2 +-
 test/sql-tap/lua/sqltester.lua                |  28 +-
 test/sql-tap/misc1.test.lua                   |  10 +-
 test/sql-tap/misc5.test.lua                   |   2 +-
 test/sql-tap/select1.test.lua                 |  10 +-
 test/sql-tap/select2.test.lua                 |   8 +-
 test/sql-tap/select4.test.lua                 |   1 -
 test/sql-tap/select5.test.lua                 |   1 -
 test/sql-tap/select9.test.lua                 |  12 +-
 test/sql-tap/selectA.test.lua                 |   8 +-
 test/sql-tap/selectB.test.lua                 |  14 +-
 test/sql-tap/selectG.test.lua                 |   1 -
 test/sql-tap/sort.test.lua                    |   2 +-
 test/sql-tap/sql-errors.test.lua              |   2 +-
 test/sql-tap/table.test.lua                   |   3 +-
 test/sql-tap/tkt-38cb5df375.test.lua          |   1 -
 test/sql-tap/tkt-91e2e8ba6f.test.lua          |   3 -
 test/sql-tap/tkt-9a8b09f8e6.test.lua          |   3 -
 test/sql-tap/tkt-bd484a090c.test.lua          |   3 +-
 test/sql-tap/tkt-fa7bf5ec.test.lua            |   6 +-
 test/sql-tap/tkt2192.test.lua                 |   3 +-
 test/sql-tap/tkt3493.test.lua                 |   3 -
 test/sql-tap/trigger2.test.lua                |   4 +-
 test/sql-tap/triggerA.test.lua                |   1 -
 test/sql-tap/where2.test.lua                  |   9 +-
 test/sql-tap/where3.test.lua                  |   2 +-
 test/sql-tap/where4.test.lua                  |   4 +-
 test/sql-tap/where5.test.lua                  |   2 +-
 test/sql-tap/where6.test.lua                  |   2 +-
 test/sql-tap/where7.test.lua                  |  16 +-
 test/sql-tap/whereA.test.lua                  |   2 +-
 test/sql-tap/whereB.test.lua                  |   2 +-
 test/sql-tap/whereC.test.lua                  |   5 +-
 test/sql-tap/whereD.test.lua                  |   4 +-
 test/sql-tap/whereF.test.lua                  |   4 +-
 test/sql-tap/whereG.test.lua                  |   4 +-
 test/sql-tap/whereI.test.lua                  |   4 +-
 test/sql-tap/whereK.test.lua                  |   4 +-
 test/sql-tap/with1.test.lua                   |  14 +-
 test/sql-tap/with2.test.lua                   |  18 +-
 test/sql/lua/sql_tokenizer.lua                |   2 +-
 test/sql/savepoints.result                    |   6 +-
 test/sql/savepoints.test.lua                  |   6 +-
 test/sql/triggers.result                      |   2 +-
 test/sql/triggers.test.lua                    |   2 +-
 test/swim/box.lua                             |   4 +-
 test/vinyl/large.lua                          |   3 +-
 test/vinyl/stress.lua                         |  22 +-
 test/vinyl/txn_proxy.lua                      |   6 +-
 test/vinyl/upgrade/fill.lua                   |   8 +-
 test/vinyl/vinyl.lua                          |  17 -
 test/wal_off/rtree_benchmark.result           |   2 +-
 test/wal_off/rtree_benchmark.test.lua         |   2 +-
 test/xlog-py/box.lua                          |   2 +-
 test/xlog/panic.lua                           |   2 +-
 test/xlog/reader.result                       |   2 +-
 test/xlog/reader.test.lua                     |   2 +-
 test/xlog/snap_io_rate.test.lua               |   2 +-
 test/xlog/transaction.result                  |   2 +-
 test/xlog/transaction.test.lua                |   2 +-
 .../2.1.3/gh-4771-upgrade-sequence/fill.lua   |  12 +-
 test/xlog/xlog.lua                            |   2 +-
 168 files changed, 1145 insertions(+), 1233 deletions(-)

diff --git a/.luacheckrc b/.luacheckrc
index e5c4c4509..26986ffb1 100644
--- a/.luacheckrc
+++ b/.luacheckrc
@@ -6,18 +6,18 @@ include_files = {
 exclude_files = {
     "build/**/*.lua",
     "src/box/lua/serpent.lua", -- third-party source code
-    "test/app/*.lua",
+    "test/app/*.test.lua",
     "test/app-tap/lua/serializer_test.lua",
     "test/box/**/*.lua",
-    "test/engine/*.lua",
+    "test/engine/*.test.lua",
     "test/engine_long/*.lua",
     "test/long_run-py/**/*.lua",
-    "test/vinyl/*.lua",
-    "test/replication/*.lua",
-    "test/sql/*.lua",
-    "test/swim/*.lua",
-    "test/xlog/*.lua",
-    "test/wal_off/*.lua",
+    "test/vinyl/*.test.lua",
+    "test/replication/*.test.lua",
+    "test/sql/*.test.lua",
+    "test/swim/*.test.lua",
+    "test/xlog/*.test.lua",
+    "test/wal_off/*.test.lua",
     "test/var/**/*.lua",
     "test-run/**/*.lua",
     "third_party/**/*.lua",
@@ -41,15 +41,18 @@ files["src/box/lua/load_cfg.lua"] = {ignore = {"542"}}
 files["src/box/lua/net_box.lua"] = {ignore = {"431", "432", "411"}}
 files["src/box/lua/schema.lua"] = {globals = {"tonumber64"}, ignore = {"431", "432"}}
 files["test/app/lua/fiber.lua"] = {globals = {"box_fiber_run_test"}}
-files["test/app-tap/console.test.lua"] = {globals = {"long_func"}}
 files["test/app-tap/lua/require_mod.lua"] = {globals = {"exports"}}
 files["test/app-tap/module_api.test.lua"] = {ignore = {"311"}}
 files["test/app-tap/string.test.lua"] = {globals = {"utf8"}}
-files["test/app-tap/tarantoolctl.test.lua"] = {ignore = {"113", "421"}}
 files["test/box-tap/session.test.lua"] = {
 	globals = {"active_connections", "session", "space", "f1", "f2"},
 	ignore = {"211"}
 }
+files["test/box-tap/extended_error.test.lua"] = {
+	globals = {"error_new", "error_throw", "error_new_stacked", "error_throw_stacked",
+	"error_access_denied", "error_throw_access_denied", "forbidden_function"},
+	ignore = {"211"}
+}
 files["test/box/lua/push.lua"] = {globals = {"push_collection"}}
 files["test/box/lua/index_random_test.lua"] = {globals = {"index_random_test"}}
 files["test/box/lua/utils.lua"] = {
@@ -63,8 +66,9 @@ files["test/box/lua/bitset.lua"] = {
 files["test/box/lua/fifo.lua"] = {globals = {"fifomax", "find_or_create_fifo", "fifo_push", "fifo_top"}}
 files["test/box/lua/identifier.lua"] = {globals = {"run_test"}}
 files["test/box/lua/require_mod.lua"] = {globals = {"exports"}}
-files["test/luajit-tap/gh-4476-fix-string-find-recording.test.lua"] = {ignore = {"231"}}
-files["test/luajit-tap/or-232-unsink-64-kptr.test.lua"] = {ignore = {"542"}}
+files["test/engine/conflict.lua"] = {globals = {"test_conflict"}}
+files["test/replication/replica_quorum.lua"] = {globals = {"INSTANCE_URI", "nonexistent_uri"}}
+files["test/replication/replica_on_schema_init.lua"] = {globals = {"trig_local", "trig_engine"}}
 files["test/replication/lua/fast_replica.lua"] = {
 	globals = {"join", "start_all", "stop_all", "wait_all",
 	"drop_all", "drop_all", "vclock_diff", "unregister",
@@ -74,3 +78,4 @@ files["test/replication/lua/fast_replica.lua"] = {
 files["test/sql-tap/*.lua"] = {ignore = {"611", "612", "613", "614", "621", "631", "211", "113", "111"}}
 files["test/sql-tap/lua/sqltester.lua"] = {globals = {"table_match_regex_p"}}
 files["test/sql-tap/e_expr.test.lua"] = {ignore = {"512"}}
+files["test/swim/box.lua"] = {globals = {"listen_port", "listen_uri", "uuid", "uri", "swim", "fiber"}}
diff --git a/test/app-tap/cfg.test.lua b/test/app-tap/cfg.test.lua
index ba6b735ab..14e040f9f 100755
--- a/test/app-tap/cfg.test.lua
+++ b/test/app-tap/cfg.test.lua
@@ -12,7 +12,7 @@ test:plan(11)
 local nil_uuid = '00000000-0000-0000-0000-000000000000'
 local ok = pcall(box.cfg, {instance_uuid = nil_uuid})
 test:ok(not ok, 'nil instance UUID is not allowed')
-ok, err = pcall(box.cfg, {replicaset_uuid = nil_uuid})
+ok = pcall(box.cfg, {replicaset_uuid = nil_uuid})
 test:ok(not ok, 'nil replicaset UUID is not allowed')
 
 test:is(type(box.ctl), "table", "box.ctl is available before box.cfg")
diff --git a/test/app-tap/clock.test.lua b/test/app-tap/clock.test.lua
index fd1c4f272..d1ea4f0a8 100755
--- a/test/app-tap/clock.test.lua
+++ b/test/app-tap/clock.test.lua
@@ -1,7 +1,7 @@
 #!/usr/bin/env tarantool
 
-clock = require("clock")
-test = require("tap").test("csv")
+local clock = require("clock")
+local test = require("tap").test("csv")
 test:plan(10)
 test:ok(clock.realtime() > 0, "realtime")
 test:ok(clock.thread() > 0, "thread")
diff --git a/test/app-tap/console.test.lua b/test/app-tap/console.test.lua
index 4feadfa5e..454d5a892 100755
--- a/test/app-tap/console.test.lua
+++ b/test/app-tap/console.test.lua
@@ -5,7 +5,6 @@ local console = require('console')
 local socket = require('socket')
 local yaml = require('yaml')
 local fiber = require('fiber')
-local ffi = require('ffi')
 local log = require('log')
 local fio = require('fio')
 
@@ -19,7 +18,8 @@ os.remove(IPROTO_SOCKET)
 --
 local EOL = "\n...\n"
 
-test = tap.test("console")
+local test = tap.test("console")
+local _
 
 test:plan(80)
 
@@ -59,7 +59,8 @@ test:is(client:read(";"), 'true;', "pushed message")
 client:write('\\set output lua\n')
 client:read(";")
 
-long_func_f = nil
+local long_func_f
+-- luacheck: globals long_func (is called via client socket)
 function long_func()
     long_func_f = fiber.self()
     box.session.push('push')
@@ -95,12 +96,9 @@ test:is(#client:read(EOL) > 0, true, "_G")
 client:write("require('fiber').id()\n")
 local fid1 = yaml.decode(client:read(EOL))[1]
 local state = fiber.find(fid1).storage.console
-local server_info = state.client:peer()
 local client_info = state.client:name()
 test:is(client_info.host, client_info.host, "state.socker:peer().host")
 test:is(client_info.port, client_info.port, "state.socker:peer().port")
-server_info = nil
-client_info = nil
 
 -- Check console.delimiter()
 client:write("require('console').delimiter(';')\n")
@@ -233,13 +231,13 @@ box.cfg{listen = ''}
 os.remove(IPROTO_SOCKET)
 
 local s = console.listen('127.0.0.1:0')
-addr = s:name()
+local addr = s:name()
 test:is(addr.family, 'AF_INET', 'console.listen uri support')
 test:is(addr.host, '127.0.0.1', 'console.listen uri support')
 test:isnt(addr.port, 0, 'console.listen uri support')
 s:close()
 
-local s = console.listen('console://unix/:'..CONSOLE_SOCKET)
+s = console.listen('console://unix/:'..CONSOLE_SOCKET)
 addr = s:name()
 test:is(addr.family, 'AF_UNIX', 'console.listen uri support')
 test:is(addr.host, 'unix/', 'console.listen uri support')
@@ -279,7 +277,7 @@ box.session.on_disconnect(console_on_disconnect)
 box.session.on_auth(console_on_auth)
 
 -- check on_connect/on_disconnect/on_auth triggers
-local server = console.listen('console://unix/:'..CONSOLE_SOCKET)
+server = console.listen('console://unix/:'..CONSOLE_SOCKET)
 client = socket.tcp_connect("unix/", CONSOLE_SOCKET)
 _ = client:read(128)
 client:write("1\n")
diff --git a/test/app-tap/console_lua.test.lua b/test/app-tap/console_lua.test.lua
index 3ed6aad97..d3ba17779 100755
--- a/test/app-tap/console_lua.test.lua
+++ b/test/app-tap/console_lua.test.lua
@@ -13,7 +13,7 @@ local CONSOLE_SOCKET = 'console-lua.sock'
 --
 -- Set Lua output mode.
 local function set_lua_output(client, opts)
-    local opts = opts or {}
+    opts = opts or {}
     local mode = opts.block and 'lua,block' or 'lua'
     client:write(('\\set output %s\n'):format(mode))
     assert(client:read(EOL), 'true' .. EOL, 'set lua output mode')
@@ -57,8 +57,8 @@ end
 
 --
 -- Execute a list of statements, show requests and responses.
-local function execute_statements(test, client, statements, name)
-    test:test(name, function(test)
+local function execute_statements(testcase, client, statements, name)
+    testcase:test(name, function(test)
         test:plan(2 * #statements)
 
         for _, stmt in ipairs(statements) do
@@ -75,15 +75,15 @@ end
 
 --
 -- Execute a statement and verify its response.
-local function execute_and_verify(test, client, input, exp_output, name)
-    test:test(name, function(test)
+local function execute_and_verify(testcase, client, input, exp_output, name)
+    testcase:test(name, function(test)
         test:plan(2)
 
         local res = client:write(input .. '\n')
         test:ok(res ~= nil, ('-> [[%s]]'):format(input))
 
         local exp = exp_output .. EOL
-        local res = client:read(EOL)
+        res = client:read(EOL)
         test:is(res, exp, ('<- [[%s]]'):format(exp:gsub('\n', '\\n')))
     end)
 end
@@ -134,15 +134,15 @@ test:plan(#cases)
 local server, client = start_console()
 
 for _, case in ipairs(cases) do
-    test:test(case.name, function(test)
-        test:plan(3)
+    test:test(case.name, function(testcase)
+        testcase:plan(3)
 
-        execute_statements(test, client, totable(case.prepare), 'prepare')
+        execute_statements(testcase, client, totable(case.prepare), 'prepare')
 
         set_lua_output(client, case.opts)
-        execute_and_verify(test, client, case.input, case.expected, 'run')
+        execute_and_verify(testcase, client, case.input, case.expected, 'run')
 
-        execute_statements(test, client, totable(case.cleanup), 'cleanup')
+        execute_statements(testcase, client, totable(case.cleanup), 'cleanup')
     end)
 end
 
diff --git a/test/app-tap/csv.test.lua b/test/app-tap/csv.test.lua
index a7f17b1ea..eb180f95d 100755
--- a/test/app-tap/csv.test.lua
+++ b/test/app-tap/csv.test.lua
@@ -2,9 +2,9 @@
 
 local function table2str(t)
     local res = ""
-    for k, line in pairs(t) do
+    for _, line in pairs(t) do
         local s = ""
-        for k2, field in pairs(line) do
+        for _, field in pairs(line) do
             s = s .. '|' .. field .. '|\t'
         end
         res = res .. s .. '\n'
@@ -12,9 +12,9 @@ local function table2str(t)
     return res
 end
 
-local function myread(self, bytes) 
+local function myread(self, bytes)
     self.i = self.i + bytes
-    return self.v:sub(self.i - bytes + 1, self.i) 
+    return self.v:sub(self.i - bytes + 1, self.i)
 end
 local csv = require('csv')
 local fio = require('fio')
@@ -27,18 +27,18 @@ local test4_ans = '|123|\t|5|\t|92|\t|0|\t|0|\t\n|1|\t|12  34|\t|56|\t' ..
 local test5_ans = "|1|\t\n|23|\t|456|\t|abcac|\t|'multiword field 4'|\t\n" ..
                   "|none|\t|none|\t|0|\t\n||\t||\t||\t\n|aba|\t|adda|\t|f" ..
                   "3|\t|0|\t\n|local res = internal.pwrite(self.fh|\t|dat" ..
-                  "a|\t|len|\t|offset)|\t\n|iflag = bit.bor(iflag|\t|fio." .. 
+                  "a|\t|len|\t|offset)|\t\n|iflag = bit.bor(iflag|\t|fio." ..
                   "c.flag[ flag ])|\t\n||\t||\t||\t\n"
 local test6_ans = "|23|\t|456|\t|abcac|\t|'multiword field 4'|\t\n|none|" ..
-                  "\t|none|\t|0|\t\n||\t||\t||\t\n|aba|\t|adda|\t|f3|\t|" .. 
+                  "\t|none|\t|0|\t\n||\t||\t||\t\n|aba|\t|adda|\t|f3|\t|" ..
                   "0|\t\n|local res = internal.pwrite(self.fh|\t|data|\t" ..
                   "|len|\t|offset)|\t\n|iflag = bit.bor(iflag|\t|fio.c.f" ..
                   "lag[ flag ])|\t\n||\t||\t||\t\n"
 
-test = tap.test("csv")
+local test = tap.test("csv")
 test:plan(12)
 
-readable = {}
+local readable = {}
 readable.read = myread
 readable.v = "a,b\n1,\"ha\n\"\"ha\"\"\nha\"\n3,4\n"
 readable.i = 0
@@ -52,17 +52,17 @@ readable.v = ", \r\nkp\"\"v"
 readable.i = 0
 test:is(table2str(csv.load(readable, {chunk_size = 3})), test3_ans, "obj test3")
 
-tmpdir = fio.tempdir()
-file1 = fio.pathjoin(tmpdir, 'file.1')
-file2 = fio.pathjoin(tmpdir, 'file.2')
-file3 = fio.pathjoin(tmpdir, 'file.3')
-file4 = fio.pathjoin(tmpdir, 'file.4')
+local tmpdir = fio.tempdir()
+local file1 = fio.pathjoin(tmpdir, 'file.1')
+local file2 = fio.pathjoin(tmpdir, 'file.2')
+local file3 = fio.pathjoin(tmpdir, 'file.3')
+local file4 = fio.pathjoin(tmpdir, 'file.4')
 
 local f = fio.open(file1, { 'O_WRONLY', 'O_TRUNC', 'O_CREAT' }, tonumber('0777', 8))
 f:write("123 , 5  ,       92    , 0, 0\n" ..
         "1, 12  34, 56, \"quote , \", 66\nok")
 f:close()
-f = fio.open(file1, {'O_RDONLY'}) 
+f = fio.open(file1, {'O_RDONLY'})
 test:is(table2str(csv.load(f, {chunk_size = 10})), test4_ans, "fio test1")
 f:close()
 
@@ -77,31 +77,31 @@ f:write("1\n23,456,abcac,\'multiword field 4\'\n" ..
         ",,"
 )
 f:close()
-f = fio.open(file2, {'O_RDONLY'}) 
+f = fio.open(file2, {'O_RDONLY'})
 --symbol by symbol reading
-test:is(table2str(csv.load(f, {chunk_size = 1})), test5_ans, "fio test2") 
+test:is(table2str(csv.load(f, {chunk_size = 1})), test5_ans, "fio test2")
 f:close()
 
-f = fio.open(file2, {'O_RDONLY'}) 
-opts = {chunk_size = 7, skip_head_lines = 1}
+f = fio.open(file2, {'O_RDONLY'})
+local opts = {chunk_size = 7, skip_head_lines = 1}
 --7 symbols per chunk
-test:is(table2str(csv.load(f, opts)), test6_ans, "fio test3") 
+test:is(table2str(csv.load(f, opts)), test6_ans, "fio test3")
 f:close()
 
-t = {
-    {'quote" d', ',and, comma', 'both " of " t,h,e,m'}, 
-    {'"""', ',","'}, 
-    {'mul\nti\nli\r\nne\n\n', 'field'},
-    {""},
-    {'"'},
-    {"\n"}
+local t = {
+          {'quote" d', ',and, comma', 'both " of " t,h,e,m'},
+          {'"""', ',","'},
+          {'mul\nti\nli\r\nne\n\n', 'field'},
+          {""},
+          {'"'},
+          {"\n"}
 }
 
 f = require("fio").open(file3, { "O_WRONLY", "O_TRUNC" , "O_CREAT"}, 0x1FF)
 csv.dump(t, {}, f)
 f:close()
-f = fio.open(file3, {'O_RDONLY'}) 
-t2 = csv.load(f, {chunk_size = 5})
+f = fio.open(file3, {'O_RDONLY'})
+local t2 = csv.load(f, {chunk_size = 5})
 f:close()
 
 test:is(table2str(t), table2str(t2), "test roundtrip")
diff --git a/test/app-tap/debug.test.lua b/test/app-tap/debug.test.lua
index 0d199e55b..0f9b881f0 100755
--- a/test/app-tap/debug.test.lua
+++ b/test/app-tap/debug.test.lua
@@ -44,7 +44,7 @@ print(('debug.sourcefile() => %s; %s'):format(tostring(result), tostring(err)))
 assert(result == box.NULL, 'debug.sourcefile() returns box.NULL')
 assert(err == nil, 'debug.sourcefile() returns no error')
 
-local result, err = conn:call('debug.sourcedir')
+result, err = conn:call('debug.sourcedir')
 print(('debug.sourcedir() => %s; %s'):format(tostring(result), tostring(err)))
 assert(result == '.', 'debug.sourcedir() returns "."')
 assert(err == nil, 'debug.sourcedir() returns no error')
@@ -58,10 +58,10 @@ print('When running lua code from console')
 print('==================================')
 -- debug.sourcefile() returns cwd when running within console
 for _, test in ipairs(tests) do
-    local cmd = string.format('%s -e "%s; os.exit(0)"', TNTBIN, test)
-    print('Exec: '..cmd)
+    local cmdline = string.format('%s -e "%s; os.exit(0)"', TNTBIN, test)
+    print('Exec: '..cmdline)
     io.flush()
-    assert(os.execute(cmd) == 0, string.format('cmd: "%s" must execute successfully', cmd))
+    assert(os.execute(cmdline) == 0, string.format('cmd: "%s" must execute successfully', cmdline))
 end
 
 local fio = require('fio')
@@ -74,7 +74,7 @@ if not dirstat then
 end
 assert(dirstat:is_dir(), dirname..' must be a directory')
 
-local cmd = TNTBIN..' '..filename
+cmd = TNTBIN..' '..filename
 print('======================================')
 print('When running lua code from script file')
 print('======================================')
diff --git a/test/app-tap/errno.test.lua b/test/app-tap/errno.test.lua
index 5fd8eaca4..41f8c7d15 100755
--- a/test/app-tap/errno.test.lua
+++ b/test/app-tap/errno.test.lua
@@ -6,16 +6,16 @@ local errno = require('errno')
 local test = tap.test("errno")
 
 test:plan(1)
-test:test("primary", function(test)
-    test:plan(10)
-    test:is(type(errno), "table", "type of table")
-    test:ok(errno.EINVAL ~= nil, "errno.EINVAL is available")
-    test:ok(errno.EBADF ~= nil , "errno.EBADF is available" )
-    test:ok(errno(0) ~= nil, "errno set to 0")
-    test:is(errno(errno.EBADF), 0, "setting errno.EBADF")
-    test:is(errno(), errno.EBADF, "checking errno.EBADF")
-    test:is(errno(errno.EINVAL), errno.EBADF, "setting errno.EINVAL")
-    test:is(errno(), errno.EINVAL, "checking errno.EINVAL")
-    test:is(errno.strerror(), "Invalid argument", "checking strerror without argument")
-    test:is(errno.strerror(errno.EBADF), "Bad file descriptor", "checking strerror with argument")
+test:test("primary", function(testcase)
+    testcase:plan(10)
+    testcase:is(type(errno), "table", "type of table")
+    testcase:ok(errno.EINVAL ~= nil, "errno.EINVAL is available")
+    testcase:ok(errno.EBADF ~= nil , "errno.EBADF is available" )
+    testcase:ok(errno(0) ~= nil, "errno set to 0")
+    testcase:is(errno(errno.EBADF), 0, "setting errno.EBADF")
+    testcase:is(errno(), errno.EBADF, "checking errno.EBADF")
+    testcase:is(errno(errno.EINVAL), errno.EBADF, "setting errno.EINVAL")
+    testcase:is(errno(), errno.EINVAL, "checking errno.EINVAL")
+    testcase:is(errno.strerror(), "Invalid argument", "checking strerror without argument")
+    testcase:is(errno.strerror(errno.EBADF), "Bad file descriptor", "checking strerror with argument")
 end)
diff --git a/test/app-tap/fail_main.test.lua b/test/app-tap/fail_main.test.lua
index f8c45bf6f..3fe0971eb 100755
--- a/test/app-tap/fail_main.test.lua
+++ b/test/app-tap/fail_main.test.lua
@@ -7,7 +7,7 @@ local tarantool_bin = arg[-1]
 
 test:plan(1)
 
-function run_script(code)
+local function run_script(code)
     local dir = fio.tempdir()
     local script_path = fio.pathjoin(dir, 'script.lua')
     local script = fio.open(script_path, {'O_CREAT', 'O_WRONLY', 'O_APPEND'},
@@ -16,7 +16,7 @@ function run_script(code)
     script:close()
     local output_file = fio.pathjoin(fio.cwd(), 'out.txt')
     local cmd = [[/bin/sh -c 'cd "%s" && "%s" ./script.lua 0> %s 2> %s']]
-    local code = os.execute(
+    code = os.execute(
         string.format(cmd, dir, tarantool_bin, output_file, output_file)
     )
     fio.rmtree(dir)
@@ -30,7 +30,7 @@ end
 -- gh-4382: an error in main script should be handled gracefully,
 -- with proper logging.
 --
-local code, output = run_script("error('Error in the main script')")
+local _, output = run_script("error('Error in the main script')")
 
 test:ok(output:match("fatal error, exiting the event loop"),
         "main script error is handled gracefully")
diff --git a/test/app-tap/gh-4761-json-per-call-options.test.lua b/test/app-tap/gh-4761-json-per-call-options.test.lua
index 1fb24744e..bd710b76f 100755
--- a/test/app-tap/gh-4761-json-per-call-options.test.lua
+++ b/test/app-tap/gh-4761-json-per-call-options.test.lua
@@ -13,23 +13,24 @@ local res = tap.test('gh-4761-json-per-call-options', function(test)
     test:plan(2)
 
     -- Preparation code: call :decode() with a custom option.
-    local ok, err = pcall(json.decode, '{"foo": {"bar": 1}}',
+    local ok = pcall(json.decode, '{"foo": {"bar": 1}}',
                           {decode_max_depth = 1})
     assert(not ok, 'expect "too many nested data structures" error')
 
     -- Verify that the instance option remains unchanged.
     local exp_res = {foo = {bar = 1}}
-    local ok, res = pcall(json.decode, '{"foo": {"bar": 1}}')
+    local res
+    ok, res = pcall(json.decode, '{"foo": {"bar": 1}}')
     test:is_deeply({ok, res}, {true, exp_res},
                    'json instance settings remain unchanged after :decode()')
 
     -- Same check for json.encode.
     local nan = 1/0
-    local ok, err = pcall(json.encode, {a = nan},
+    ok = pcall(json.encode, {a = nan},
                           {encode_invalid_numbers = false})
     assert(not ok, 'expected "number must not be NaN or Inf" error')
-    local exp_res = '{"a":inf}'
-    local ok, res = pcall(json.encode, {a = nan})
+    exp_res = '{"a":inf}'
+    ok, res = pcall(json.encode, {a = nan})
     test:is_deeply({ok, res}, {true, exp_res},
                    'json instance settings remain unchanged after :encode()')
 end)
diff --git a/test/app-tap/http_client.test.lua b/test/app-tap/http_client.test.lua
index b85b605cf..b44876b39 100755
--- a/test/app-tap/http_client.test.lua
+++ b/test/app-tap/http_client.test.lua
@@ -22,8 +22,8 @@ local function merge(...)
     return res
 end
 
-local function start_server(test, sock_family, sock_addr)
-    test:diag("starting HTTP server on %s...", sock_addr)
+local function start_server(testcase, sock_family, sock_addr)
+    testcase:diag("starting HTTP server on %s...", sock_addr)
     local arg, url, opts
     if sock_family == 'AF_INET' then
         arg = string.format("--inet %s", sock_addr)
@@ -39,51 +39,51 @@ local function start_server(test, sock_family, sock_addr)
     local cmd = string.format("%s/test/app-tap/httpd.py %s",
                               TARANTOOL_SRC_DIR, arg)
     local server = io.popen(cmd)
-    test:is(server:read("*l"), "heartbeat", "server started")
-    test:diag("trying to connect to %s", url)
+    testcase:is(server:read("*l"), "heartbeat", "server started")
+    testcase:diag("trying to connect to %s", url)
     local r
-    for i=1,10 do
+    for _=1,10 do
         r = client.get(url, merge(opts, {timeout = 0.01}))
         if r.status == 200 then
             break
         end
         fiber.sleep(0.01)
     end
-    test:is(r.status, 200, "connection is ok")
+    testcase:is(r.status, 200, "connection is ok")
     if r.status ~= 200 then
         os.exit(1)
     end
     return server, url, opts
 end
 
-local function stop_server(test, server)
-    test:diag("stopping HTTP server")
+local function stop_server(testcase, server)
+    testcase:diag("stopping HTTP server")
     server:close()
 end
 
-local function test_http_client(test, url, opts)
-    test:plan(11)
+local function test_http_client(testcase, url, opts)
+    testcase:plan(11)
 
     -- gh-4136: confusing httpc usage error message
     local ok, err = pcall(client.request, client)
     local usage_err = "request(method, url[, body, [options]])"
-    test:is_deeply({ok, err:split(': ')[2]}, {false, usage_err},
+    testcase:is_deeply({ok, err:split(': ')[2]}, {false, usage_err},
                    "test httpc usage error")
 
-    test:isnil(rawget(_G, 'http'), "global namespace is not polluted");
-    test:isnil(rawget(_G, 'http.client'), "global namespace is not polluted");
+    testcase:isnil(rawget(_G, 'http'), "global namespace is not polluted");
+    testcase:isnil(rawget(_G, 'http.client'), "global namespace is not polluted");
     local r = client.get(url, opts)
-    test:is(r.status, 200, 'simple 200')
-    test:is(r.reason, 'Ok', '200 - Ok')
-    test:is(r.proto[1], 1, 'proto major http 1.1')
-    test:is(r.proto[2], 1, 'proto major http 1.1')
-    test:ok(r.body:match("hello") ~= nil, "body")
-    test:ok(tonumber(r.headers["content-length"]) > 0,
+    testcase:is(r.status, 200, 'simple 200')
+    testcase:is(r.reason, 'Ok', '200 - Ok')
+    testcase:is(r.proto[1], 1, 'proto major http 1.1')
+    testcase:is(r.proto[2], 1, 'proto major http 1.1')
+    testcase:ok(r.body:match("hello") ~= nil, "body")
+    testcase:ok(tonumber(r.headers["content-length"]) > 0,
         "content-length > 0")
-    test:is(client.get("http://localhost:1/").status, 595, 'cannot connect')
+    testcase:is(client.get("http://localhost:1/").status, 595, 'cannot connect')
 
-    local r = client.request('GET', url, nil, opts)
-    test:is(r.status, 200, 'request')
+    r = client.request('GET', url, nil, opts)
+    testcase:is(r.status, 200, 'request')
 
     -- XXX: enable after resolving of gh-4180: httpc: redirects
     -- are broken with libcurl-7.30 and older
@@ -118,36 +118,36 @@ end
 -- gh-3955: Check that httpc module doesn't redefine http headers
 --          set explicitly by the caller.
 --
-local function test_http_client_headers_redefine(test, url, opts)
-    test:plan(9)
-    local opts = table.deepcopy(opts)
+local function test_http_client_headers_redefine(testcase, url, opts)
+    testcase:plan(9)
+    opts = table.deepcopy(opts)
     -- Test defaults
     opts.headers = {['Connection'] = nil, ['Accept'] = nil}
     local r = client.post(url, nil, opts)
-    test:is(r.status, 200, 'simple 200')
-    test:is(r.headers['connection'], 'close', 'Default Connection header')
-    test:is(r.headers['accept'], '*/*', 'Default Accept header for POST request')
+    testcase:is(r.status, 200, 'simple 200')
+    testcase:is(r.headers['connection'], 'close', 'Default Connection header')
+    testcase:is(r.headers['accept'], '*/*', 'Default Accept header for POST request')
     -- Test that in case of conflicting headers, user variant is
     -- prefered
     opts.headers={['Connection'] = 'close'}
     opts.keepalive_idle = 2
     opts.keepalive_interval = 1
-    local r = client.get(url, opts)
-    test:is(r.status, 200, 'simple 200')
-    test:is(r.headers['connection'], 'close', 'Redefined Connection header')
-    test:is(r.headers['keep_alive'], 'timeout=2',
+    r = client.get(url, opts)
+    testcase:is(r.status, 200, 'simple 200')
+    testcase:is(r.headers['connection'], 'close', 'Redefined Connection header')
+    testcase:is(r.headers['keep_alive'], 'timeout=2',
             'Automatically set Keep-Alive header')
     -- Test that user-defined Connection and Acept headers
     -- are used
     opts.headers={['Connection'] = 'Keep-Alive', ['Accept'] = 'text/html'}
-    local r = client.get(url, opts)
-    test:is(r.status, 200, 'simple 200')
-    test:is(r.headers['accept'], 'text/html', 'Redefined Accept header')
-    test:is(r.headers['connection'], 'Keep-Alive', 'Redefined Connection header')
+    r = client.get(url, opts)
+    testcase:is(r.status, 200, 'simple 200')
+    testcase:is(r.headers['accept'], 'text/html', 'Redefined Accept header')
+    testcase:is(r.headers['connection'], 'Keep-Alive', 'Redefined Connection header')
 end
 
-local function test_cancel_and_errinj(test, url, opts)
-    test:plan(3)
+local function test_cancel_and_errinj(testcase, url, opts)
+    testcase:plan(3)
     local ch = fiber.channel(1)
     local http = client:new()
     local func  = function(fopts)
@@ -156,31 +156,30 @@ local function test_cancel_and_errinj(test, url, opts)
     local f = fiber.create(func, opts)
     f:cancel()
     local r = ch:get()
-    test:ok(r.status == 408 and string.find(r.reason, "Timeout"),
+    testcase:ok(r.status == 408 and string.find(r.reason, "Timeout"),
                     "After cancel fiber timeout is returned")
     r = http:get(url, merge(opts, {timeout = 0.0001}))
-    test:ok(r.status == 408 and string.find(r.reason, "Timeout"),
+    testcase:ok(r.status == 408 and string.find(r.reason, "Timeout"),
                                                        "Timeout check")
     local errinj = box.error.injection
     errinj.set('ERRINJ_HTTP_RESPONSE_ADD_WAIT', true)
     local topts = merge(opts, {timeout = 1200})
-    f = fiber.create(func, topts)
+    fiber.create(func, topts)
     r = ch:get()
-    test:is(r.status, 200, "No hangs in errinj")
+    testcase:is(r.status, 200, "No hangs in errinj")
     errinj.set('ERRINJ_HTTP_RESPONSE_ADD_WAIT', false)
 end
 
-local function test_post_and_get(test, url, opts)
-    test:plan(21)
+local function test_post_and_get(testcase, url, opts)
+    testcase:plan(21)
 
     local http = client.new()
-    test:ok(http ~= nil, "client is created")
+    testcase:ok(http ~= nil, "client is created")
 
     local headers = { header1 = "1", header2 = "2" }
     local my_body = { key = "value" }
     local json_body = json.encode(my_body)
     local responses = {}
-    local data = {a = 'b'}
     headers['Content-Type'] = 'application/json'
     local fibers = 7
     local ch = fiber.channel(fibers)
@@ -213,70 +212,69 @@ local function test_post_and_get(test, url, opts)
         responses.absent_get = http:get(url .. 'absent', opts)
         ch:put(1)
     end)
-    for i=1,fibers do
+    for _=1,fibers do
         ch:get()
     end
     local r = responses.good_get
-    test:is(r.status, 200, "GET: default http code page exists")
-    test:is(r.body, "hello world", "GET: default right body")
+    testcase:is(r.status, 200, "GET: default http code page exists")
+    testcase:is(r.body, "hello world", "GET: default right body")
 
     r = responses.get2
-    test:is(r.status, 200, "GET: http code page exists")
-    test:is(r.body, "abc", "GET: right body")
+    testcase:is(r.status, 200, "GET: http code page exists")
+    testcase:is(r.body, "abc", "GET: right body")
 
     r = responses.absent_get
-    test:is(r.status, 500, "GET: absent method http code page exists")
-    test:is(r.reason, 'Unknown', '500 - Unknown')
-    test:is(r.body, "No such method", "GET: absent method right body")
+    testcase:is(r.status, 500, "GET: absent method http code page exists")
+    testcase:is(r.reason, 'Unknown', '500 - Unknown')
+    testcase:is(r.body, "No such method", "GET: absent method right body")
 
     r = responses.empty_post
-    test:is(r.status, 200, "POST: good status")
-    test:ok(r.headers['header1'] == headers.header1 and
+    testcase:is(r.status, 200, "POST: good status")
+    testcase:ok(r.headers['header1'] == headers.header1 and
         r.headers['header2'] == headers.header2, "POST: good headers")
-    test:isnil(r.body, "POST: empty body")
+    testcase:isnil(r.body, "POST: empty body")
 
     r = responses.good_post
-    test:is(r.status, 200, "POST: good status")
-    test:ok(r.headers['header1'] == headers.header1 and
+    testcase:is(r.status, 200, "POST: good status")
+    testcase:ok(r.headers['header1'] == headers.header1 and
         r.headers['header2'] == headers.header2, "POST: good headers")
-    test:is(r.body, json_body, "POST: body")
+    testcase:is(r.body, json_body, "POST: body")
 
     r = responses.good_put
-    test:is(r.status, 200, "PUT: good status")
-    test:ok(r.headers['header'] == headers.header and
+    testcase:is(r.status, 200, "PUT: good status")
+    testcase:ok(r.headers['header'] == headers.header and
         r.headers['header2'] == headers.header2, "PUT: good headers")
 
     r = responses.bad_get
-    test:is(r.status, 404, "GET: http page not exists")
-    test:is(r.reason, 'Unknown', '404 - Unknown')
-    test:isnt(r.body:len(), 0, "GET: not empty body page not exists")
-    test:ok(string.find(r.body, "Not Found"),
+    testcase:is(r.status, 404, "GET: http page not exists")
+    testcase:is(r.reason, 'Unknown', '404 - Unknown')
+    testcase:isnt(r.body:len(), 0, "GET: not empty body page not exists")
+    testcase:ok(string.find(r.body, "Not Found"),
                 "GET: right body page not exists")
 
     local st = http:stat()
-    test:ok(st.sockets_added == st.sockets_deleted and
+    testcase:ok(st.sockets_added == st.sockets_deleted and
         st.active_requests == 0,
         "stats checking")
 end
 
-local function test_errors(test)
-    test:plan(2)
+local function test_errors(testcase)
+    testcase:plan(2)
     local http = client:new()
     local status, err = pcall(http.get, http, "htp://mail.ru")
-    test:ok(not status and string.find(json.encode(err),
+    testcase:ok(not status and string.find(json.encode(err),
                         "Unsupported protocol"),
                         "GET: exception on bad protocol")
     status, err = pcall(http.post, http, "htp://mail.ru", "")
-    test:ok(not status and string.find(json.encode(err),
+    testcase:ok(not status and string.find(json.encode(err),
                         "Unsupported protocol"),
                         "POST: exception on bad protocol")
-    local r = http:get("http://do_not_exist_8ffad33e0cb01e6a01a03d00089e71e5b2b7e9930dfcba.ru")
 end
 
 -- gh-3679 Check that opts.headers values can be strings only.
 -- gh-4281 Check that opts.headers can be a table and opts.headers
 -- keys can be strings only.
-local function test_request_headers(test, url, opts)
+local function test_request_headers(testcase, url, opts)
     local exp_err_bad_opts_headers = 'opts.headers should be a table'
     local exp_err_bad_key = 'opts.headers keys should be strings'
     local exp_err_bad_value = 'opts.headers values should be strings'
@@ -350,53 +348,53 @@ local function test_request_headers(test, url, opts)
             exp_err = exp_err_bad_value,
         },
     }
-    test:plan(#cases)
+    testcase:plan(#cases)
 
     local http = client:new()
 
     for _, case in ipairs(cases) do
-        local opts = merge(table.copy(opts), case.opts)
+        opts = merge(table.copy(opts), case.opts)
         local ok, err = pcall(http.get, http, url, opts)
         if case.postrequest_check ~= nil then
             case.postrequest_check(opts)
         end
         if case.exp_err == nil then
             -- expect success
-            test:ok(ok, case[1])
+            testcase:ok(ok, case[1])
         else
             -- expect fail
             assert(type(err) == 'string')
             err = err:gsub('^builtin/[a-z._]+.lua:[0-9]+: ', '')
-            test:is_deeply({ok, err}, {false, case.exp_err}, case[1])
+            testcase:is_deeply({ok, err}, {false, case.exp_err}, case[1])
         end
     end
 end
 
-local function test_headers(test, url, opts)
-    test:plan(21)
+local function test_headers(testcase, url, opts)
+    testcase:plan(21)
     local http = client:new()
     local r = http:get(url .. 'headers', opts)
-    test:is(type(r.headers["set-cookie"]), 'string', "set-cookie check")
-    test:ok(r.headers["set-cookie"]:match("likes=cheese"), "set-cookie check")
-    test:ok(r.headers["set-cookie"]:match("age = 17"), "set-cookie check")
-    test:is(r.headers["content-type"], "application/json", "content-type check")
-    test:is(r.headers["my_header"], "value1,value2", "other header check")
-    test:isnil(r.headers["11200ok"], "http status line not included in headers")
-    test:is(r.cookies["likes"][1], "cheese", "cookie value check")
-    test:ok(r.cookies["likes"][2][1]:match("Expires"), "cookie option check")
-    test:ok(r.cookies["likes"][2][3]:match("HttpOnly"), "cookie option check")
-    test:is(r.cookies["age"][1], "17", "cookie value check")
-    test:is(#r.cookies["age"][2], 1, "cookie option check")
-    test:is(r.cookies["age"][2][1], "Secure", "cookie option check")
-    test:ok(r.cookies["good_name"] ~= nil , "cookie name check")
-    test:ok(r.cookies["bad@name"] == nil , "cookie name check")
-    test:ok(r.cookies["badname"] == nil , "cookie name check")
-    test:ok(r.cookies["badcookie"] == nil , "cookie name check")
-    test:isnil(r.headers["very_very_very_long_headers_name1"], "no long header name")
-    test:is(r.headers["very_very_very_long_headers_name"], "true", "truncated name")
+    testcase:is(type(r.headers["set-cookie"]), 'string', "set-cookie check")
+    testcase:ok(r.headers["set-cookie"]:match("likes=cheese"), "set-cookie check")
+    testcase:ok(r.headers["set-cookie"]:match("age = 17"), "set-cookie check")
+    testcase:is(r.headers["content-type"], "application/json", "content-type check")
+    testcase:is(r.headers["my_header"], "value1,value2", "other header check")
+    testcase:isnil(r.headers["11200ok"], "http status line not included in headers")
+    testcase:is(r.cookies["likes"][1], "cheese", "cookie value check")
+    testcase:ok(r.cookies["likes"][2][1]:match("Expires"), "cookie option check")
+    testcase:ok(r.cookies["likes"][2][3]:match("HttpOnly"), "cookie option check")
+    testcase:is(r.cookies["age"][1], "17", "cookie value check")
+    testcase:is(#r.cookies["age"][2], 1, "cookie option check")
+    testcase:is(r.cookies["age"][2][1], "Secure", "cookie option check")
+    testcase:ok(r.cookies["good_name"] ~= nil , "cookie name check")
+    testcase:ok(r.cookies["bad@name"] == nil , "cookie name check")
+    testcase:ok(r.cookies["badname"] == nil , "cookie name check")
+    testcase:ok(r.cookies["badcookie"] == nil , "cookie name check")
+    testcase:isnil(r.headers["very_very_very_long_headers_name1"], "no long header name")
+    testcase:is(r.headers["very_very_very_long_headers_name"], "true", "truncated name")
     opts["max_header_name_length"] = 64
-    local r = http:get(url .. 'headers', opts)
-    test:is(r.headers["very_very_very_long_headers_name1"], "true", "truncated max_header_name_length")
+    r = http:get(url .. 'headers', opts)
+    testcase:is(r.headers["very_very_very_long_headers_name1"], "true", "truncated max_header_name_length")
     opts["max_header_name_length"] = nil
 
     -- Send large headers.
@@ -406,26 +404,25 @@ local function test_headers(test, url, opts)
     -- "${hname}: ${hvalue}" is 8192 bytes length
     local hvalue = string.rep('x', MAX_HEADER_NAME - hname:len() - 2)
     local headers = {[hname] = hvalue}
-    local r = http:post(url, nil, merge(opts, {headers = headers}))
-    test:is(r.headers[hname], hvalue, '8192 bytes header: success')
+    r = http:post(url, nil, merge(opts, {headers = headers}))
+    testcase:is(r.headers[hname], hvalue, '8192 bytes header: success')
 
     -- "${hname}: ${hvalue}" is 8193 bytes length
     local exp_err = 'header is too large'
-    local hvalue = string.rep('x', MAX_HEADER_NAME - hname:len() - 1)
-    local headers = {[hname] = hvalue}
+    hvalue = string.rep('x', MAX_HEADER_NAME - hname:len() - 1)
+    headers = {[hname] = hvalue}
     local ok, err = pcall(http.post, http, url, nil,
                           merge(opts, {headers = headers}))
-    test:is_deeply({ok, tostring(err)}, {false, exp_err},
+    testcase:is_deeply({ok, tostring(err)}, {false, exp_err},
                    '8193 KiB header: error')
 end
 
-local function test_special_methods(test, url, opts)
-    test:plan(14)
+local function test_special_methods(testcase, url, opts)
+    testcase:plan(14)
     local http = client.new()
     local responses = {}
     local fibers = 7
     local ch = fiber.channel(fibers)
-    local _
     fiber.create(function()
         responses.patch_data = http:patch(url, "{\"key\":\"val\"}", opts)
         ch:put(1)
@@ -454,39 +451,35 @@ local function test_special_methods(test, url, opts)
         responses.custom_data = http:request("CUSTOM", url, nil, opts)
         ch:put(1)
     end)
-    for i = 1, fibers do
+    for _ = 1, fibers do
         ch:get()
     end
 
-    test:is(responses.patch_data.status, 200, "HTTP:PATCH request")
-    test:ok(json.decode(responses.patch_data.body).key == "val",
+    testcase:is(responses.patch_data.status, 200, "HTTP:PATCH request")
+    testcase:ok(json.decode(responses.patch_data.body).key == "val",
         "HTTP:PATCH request content")
-    test:is(responses.delete_data.status, 200, "HTTP:DELETE request")
-    test:ok(responses.delete_data.headers.method == "DELETE",
+    testcase:is(responses.delete_data.status, 200, "HTTP:DELETE request")
+    testcase:ok(responses.delete_data.headers.method == "DELETE",
         "HTTP:DELETE request content")
-    test:is(responses.options_data.status, 200, "HTTP:OPTIONS request")
-    test:ok(responses.options_data.headers.method == "OPTIONS",
+    testcase:is(responses.options_data.status, 200, "HTTP:OPTIONS request")
+    testcase:ok(responses.options_data.headers.method == "OPTIONS",
         "HTTP:OPTIONS request content")
-    test:is(responses.head_data.status, 200, "HTTP:HEAD request code")
-    test:ok(responses.head_data.headers.method == "HEAD",
+    testcase:is(responses.head_data.status, 200, "HTTP:HEAD request code")
+    testcase:ok(responses.head_data.headers.method == "HEAD",
         "HTTP:HEAD request content")
-    test:is(responses.connect_data.status, 200, "HTTP:CONNECT request")
-    test:ok(responses.connect_data.headers.method == "CONNECT",
+    testcase:is(responses.connect_data.status, 200, "HTTP:CONNECT request")
+    testcase:ok(responses.connect_data.headers.method == "CONNECT",
         "HTTP:OPTIONS request content")
-    test:is(responses.trace_data.status, 200, "HTTP:TRACE request")
-    test:ok(responses.trace_data.headers.method == "TRACE",
+    testcase:is(responses.trace_data.status, 200, "HTTP:TRACE request")
+    testcase:ok(responses.trace_data.headers.method == "TRACE",
         "HTTP:TRACE request content")
-    test:is(responses.custom_data.status, 400, "HTTP:CUSTOM request")
-    test:ok(responses.custom_data.headers.method == "CUSTOM",
+    testcase:is(responses.custom_data.status, 400, "HTTP:CUSTOM request")
+    testcase:ok(responses.custom_data.headers.method == "CUSTOM",
         "HTTP:CUSTOM request content")
 end
 
-local function test_concurrent(test, url, opts)
-    test:plan(3)
-    local http = client.new()
-    local headers = { my_header = "1", my_header2 = "2" }
-    local my_body = { key = "value" }
-    local json_body = json.encode(my_body)
+local function test_concurrent(testcase, url, opts)
+    testcase:plan(3)
     local num_test = 10
     local num_load = 10
     local curls   = { }
@@ -497,7 +490,7 @@ local function test_concurrent(test, url, opts)
         headers["My-header" .. i] = "my-value"
     end
 
-    for i = 1, num_test do
+    for _ = 1, num_test do
         table.insert(curls, {
             url = url,
             http = client.new(),
@@ -515,7 +508,7 @@ local function test_concurrent(test, url, opts)
     -- Creating concurrent clients
     for i=1,num_test do
         local obj = curls[i]
-        for j=1,num_load do
+        for _=1,num_load do
             fiber.create(function()
                 local r = obj.http:post(obj.url, obj.body, merge(opts, {
                     headers = obj.headers,
@@ -540,13 +533,11 @@ local function test_concurrent(test, url, opts)
     end
     local ok_sockets_added = true
     local ok_active = true
-    local ok_timeout = true
     local ok_req = true
 
     -- Join test
     local rest = num_test
     while true do
-        local ticks = 0
         for i = 1, num_load do
             local obj = curls[i]
             -- checking that stats in concurrent are ok
@@ -577,23 +568,23 @@ local function test_concurrent(test, url, opts)
             break
         end
     end
-    test:is(ok_req, true, "All requests are ok")
-    test:ok(ok_sockets_added, "free sockets")
-    test:ok(ok_active, "no active requests")
+    testcase:is(ok_req, true, "All requests are ok")
+    testcase:ok(ok_sockets_added, "free sockets")
+    testcase:ok(ok_active, "no active requests")
 end
 
-function run_tests(test, sock_family, sock_addr)
-    test:plan(11)
-    local server, url, opts = start_server(test, sock_family, sock_addr)
-    test:test("http.client", test_http_client, url, opts)
-    test:test("http.client headers redefine", test_http_client_headers_redefine,
+local function run_tests(testcase, sock_family, sock_addr)
+    testcase:plan(11)
+    local server, url, opts = start_server(testcase, sock_family, sock_addr)
+    testcase:test("http.client", test_http_client, url, opts)
+    testcase:test("http.client headers redefine", test_http_client_headers_redefine,
               url, opts)
-    test:test("cancel and errinj", test_cancel_and_errinj, url .. 'long_query', opts)
-    test:test("basic http post/get", test_post_and_get, url, opts)
-    test:test("errors", test_errors)
-    test:test("request_headers", test_request_headers, url, opts)
-    test:test("headers", test_headers, url, opts)
-    test:test("special methods", test_special_methods, url, opts)
+    testcase:test("cancel and errinj", test_cancel_and_errinj, url .. 'long_query', opts)
+    testcase:test("basic http post/get", test_post_and_get, url, opts)
+    testcase:test("errors", test_errors)
+    testcase:test("request_headers", test_request_headers, url, opts)
+    testcase:test("headers", test_headers, url, opts)
+    testcase:test("special methods", test_special_methods, url, opts)
     if sock_family == 'AF_UNIX' and jit.os ~= "Linux" then
         --
         -- BSD-based operating systems (including OS X) will fail
@@ -604,25 +595,25 @@ function run_tests(test, sock_family, sock_addr)
         -- however, is fine - instead of returning ECONNEREFUSED
         -- it will suspend connect() until backlog is processed.
         --
-        test:skip("concurrent")
+        testcase:skip("concurrent")
     else
-        test:test("concurrent", test_concurrent, url, opts)
+        testcase:test("concurrent", test_concurrent, url, opts)
     end
-    stop_server(test, server)
+    stop_server(testcase, server)
 end
 
 test:plan(2)
 
-test:test("http over AF_INET", function(test)
+test:test("http over AF_INET", function(testcase)
     local s = socketlib('AF_INET', 'SOCK_STREAM', 0)
     s:bind('127.0.0.1', 0)
     local host = s:name().host
     local port = s:name().port
     s:close()
-    run_tests(test, 'AF_INET', string.format("%s:%d", host, port))
+    run_tests(testcase, 'AF_INET', string.format("%s:%d", host, port))
 end)
 
-test:test("http over AF_UNIX", function(test)
+test:test("http over AF_UNIX", function(testcase)
     local path = os.tmpname()
     os.remove(path)
     local status = pcall(client.get, 'http://localhost/', {unix_socket = path})
@@ -630,7 +621,7 @@ test:test("http over AF_UNIX", function(test)
         -- Unix domain sockets are not supported, skip the test.
         return
     end
-    run_tests(test, 'AF_UNIX', path)
+    run_tests(testcase, 'AF_UNIX', path)
     os.remove(path)
 end)
 
diff --git a/test/app-tap/iconv.test.lua b/test/app-tap/iconv.test.lua
index 6f6a04b14..b4e8e7339 100755
--- a/test/app-tap/iconv.test.lua
+++ b/test/app-tap/iconv.test.lua
@@ -3,7 +3,7 @@
 local tap   = require('tap')
 local iconv = require('iconv')
 
-test = tap.test("iconv")
+local test = tap.test("iconv")
 test:plan(11)
 
 local simple_str  = 'ascii string'
@@ -34,7 +34,7 @@ test:is(c8_1251(c1251_16(c16_16be(c16be_8(cyrillic_str)))), cyrillic_str,
         'complex multi-format conversion')
 
 -- test huge string
-huge_str = string.rep(cyrillic_str, 50)
+local huge_str = string.rep(cyrillic_str, 50)
 
 test:is(c16be_8(c8_16be(huge_str)), huge_str, "huge string")
 
@@ -42,7 +42,7 @@ local stat, err = pcall(iconv.new, 'NOT EXISTS', 'UTF-8')
 test:is(stat, false, 'error was thrown on bad encoding')
 test:ok(err:match('Invalid') ~= nil, 'correct error')
 
-local stat, err = pcall(c_ascii_8, cyrillic_str)
+stat, err = pcall(c_ascii_8, cyrillic_str)
 test:is(stat, false, 'error was thrown on sequence')
 test:ok(err:match('Incomplete multibyte sequence') ~= nil, 'correct error')
 
diff --git a/test/app-tap/init_script.test.lua b/test/app-tap/init_script.test.lua
index 155f149a7..5831ffa77 100755
--- a/test/app-tap/init_script.test.lua
+++ b/test/app-tap/init_script.test.lua
@@ -9,14 +9,14 @@ box.cfg{
     log="tarantool.log"
 }
 
-yaml = require('yaml')
-fiber = require('fiber')
+local yaml = require('yaml')
+local fiber = require('fiber')
 
 if box.space.tweedledum ~= nil then
     box.space.space1:drop()
 end
 
-space = box.schema.space.create('tweedledum')
+local space = box.schema.space.create('tweedledum')
 space:create_index('primary', { type = 'hash' })
 
 print[[
@@ -24,7 +24,7 @@ print[[
 -- Access to box.cfg from init script
 --
 ]]
-t = {}
+local t = {}
 
 for k,v in pairs(box.cfg) do
     if k == 'listen' then
@@ -44,7 +44,7 @@ local function do_insert()
     space:insert{1, 2, 4, 8}
 end
 
-fiber1 = fiber.create(do_insert)
+fiber.create(do_insert)
 
 print[[
 --
@@ -71,12 +71,12 @@ print[[
 -- Check that require function(math.floor) reachable in the init script
 --
 ]]
-floor = require("math").floor
+local floor = require("math").floor
 print(floor(0.5))
 print(floor(0.9))
 print(floor(1.1))
 
-mod = require('require_mod')
+local mod = require('require_mod')
 print(mod.test(10, 15))
 --
 -- A test case for https://github.com/tarantool/tarantool/issues/53
diff --git a/test/app-tap/inspector.test.lua b/test/app-tap/inspector.test.lua
index ed10020a2..cda3eda2c 100755
--- a/test/app-tap/inspector.test.lua
+++ b/test/app-tap/inspector.test.lua
@@ -1,9 +1,6 @@
 #!/usr/bin/env tarantool
 
-local socket = require('socket')
-
-test_run = require('test_run')
-inspector = test_run.new()
+local inspector = require('test_run').new()
 
 print('create instance')
 print(inspector:cmd("create server replica with rpl_master=default, script='box/box.lua'\n"))
diff --git a/test/app-tap/json.test.lua b/test/app-tap/json.test.lua
index fadfc74ec..186d6ad46 100755
--- a/test/app-tap/json.test.lua
+++ b/test/app-tap/json.test.lua
@@ -2,7 +2,6 @@
 
 package.path = "lua/?.lua;"..package.path
 
-local ffi = require('ffi')
 local tap = require('tap')
 local common = require('serializer_test')
 
diff --git a/test/app-tap/logger.test.lua b/test/app-tap/logger.test.lua
index 492d5ea0b..87cde953b 100755
--- a/test/app-tap/logger.test.lua
+++ b/test/app-tap/logger.test.lua
@@ -26,7 +26,7 @@ end
 log.info(message)
 local line = file:read()
 test:is(line:sub(-message:len()), message, "message")
-s, err = pcall(json.decode, line)
+local s = pcall(json.decode, line)
 test:ok(not s, "plain")
 --
 -- gh-700: Crash on calling log.info() with formatting characters
@@ -45,7 +45,7 @@ test:is(file:read():match('I>%s+(.*)'), '{"key":"value"}', "table is handled as
 log.info({message="value"})
 test:is(file:read():match('I>%s+(.*)'), '{"message":"value"}', "table is handled as json")
 
-function help() log.info("gh-2340: %s %s", 'help') end
+local function help() log.info("gh-2340: %s %s", 'help') end
 
 xpcall(help, function(err)
     test:ok(err:match("bad argument #3"), "found error string")
@@ -56,34 +56,34 @@ file:close()
 
 test:ok(log.pid() >= 0, "pid()")
 
--- logger uses 'debug', try to set it to nil
+-- luacheck: ignore (logger uses 'debug', try to set it to nil)
 debug = nil
 log.info("debug is nil")
 debug = require('debug')
 
 test:ok(log.info(true) == nil, 'check tarantool crash (gh-2516)')
 
-s, err = pcall(box.cfg, {log_format='json', log="syslog:identity:tarantool"})
+s = pcall(box.cfg, {log_format='json', log="syslog:identity:tarantool"})
 test:ok(not s, "check json not in syslog")
 
 box.cfg{log=filename,
     memtx_memory=107374182,
     log_format = "json"}
 
-local file = io.open(filename)
+file = io.open(filename)
 while file:read() do
 end
 
 log.error("error")
 
-local line = file:read()
+line = file:read()
 message = json.decode(line)
 test:is(type(message), 'table', "json valid in log.error")
 test:is(message.level, "ERROR", "check type error")
 test:is(message.message, "error", "check error message")
 
 log.info({key="value", level=48})
-local line = file:read()
+line = file:read()
 message = json.decode(line)
 test:is(type(message), 'table', "json valid in log.info")
 test:is(message.level, "INFO", "check type info")
@@ -91,7 +91,7 @@ test:is(message.message, nil, "check message is nil")
 test:is(message.key, "value", "custom table encoded")
 
 log.info('this is "')
-local line = file:read()
+line = file:read()
 message = json.decode(line)
 test:is(message.message, "this is \"", "check message with escaped character")
 
@@ -101,13 +101,14 @@ line = file:read()
 test:ok(line:len() < 20000, "big line truncated")
 
 log.info("json")
-local line = file:read()
+line = file:read()
 message = json.decode(line)
 test:is(message.message, "json", "check message with internal key word")
 log.log_format("plain")
 log.info("hello")
 line = file:read()
 test:ok(not line:match("{"), "log change format")
+local e
 s, e = pcall(log.log_format, "non_format")
 test:ok(not s, "bad format")
 file:close()
@@ -120,7 +121,7 @@ file = fio.open(filename)
 while file == nil do file = fio.open(filename) fiber.sleep(0.0001) end
 line = file:read()
 while line == nil or line == ""  do line = file:read() fiber.sleep(0.0001) end
-index = line:find('\n')
+local index = line:find('\n')
 line = line:sub(1, index)
 message = json.decode(line)
 test:is(message.message, "log file has been reopened", "check message after log.rotate()")
diff --git a/test/app-tap/minimal.test.lua b/test/app-tap/minimal.test.lua
index e44a0f6a7..8b261a03e 100755
--- a/test/app-tap/minimal.test.lua
+++ b/test/app-tap/minimal.test.lua
@@ -24,13 +24,13 @@ os.execute("tarantool ./script-args.lua 1 2 3")
 --
 -- LUA_PATH and LUA_CPATH argument handling
 --
-local script = io.open('script-path.lua', 'w')
+script = io.open('script-path.lua', 'w')
 script:write([[
 print(package.path)
 os.exit(0)
 ]])
 script:close()
-local script = io.open('script-cpath.lua', 'w')
+script = io.open('script-cpath.lua', 'w')
 script:write([[
 print(package.cpath)
 os.exit(0)
diff --git a/test/app-tap/module_api.test.lua b/test/app-tap/module_api.test.lua
index a6658cc61..d7be56a9b 100755
--- a/test/app-tap/module_api.test.lua
+++ b/test/app-tap/module_api.test.lua
@@ -5,7 +5,7 @@ local fio = require('fio')
 box.cfg{log = "tarantool.log"}
 -- Use BUILDDIR passed from test-run or cwd when run w/o
 -- test-run to find test/app-tap/module_api.{so,dylib}.
-build_path = os.getenv("BUILDDIR") or '.'
+local build_path = os.getenv("BUILDDIR") or '.'
 package.cpath = fio.pathjoin(build_path, 'test/app-tap/?.so'   ) .. ';' ..
                 fio.pathjoin(build_path, 'test/app-tap/?.dylib') .. ';' ..
                 package.cpath
@@ -17,10 +17,10 @@ local function test_pushcdata(test, module)
     local gc_counter = 0;
     local ct = ffi.typeof('struct module_api_test')
     ffi.metatype(ct, {
-        __tostring = function(obj)
+        __tostring = function()
             return 'ok'
         end;
-        __gc = function(obj)
+        __gc = function()
             gc_counter = gc_counter + 1;
         end
     })
@@ -33,7 +33,7 @@ local function test_pushcdata(test, module)
     test:is(ctid, ctid2, 'checkcdata type')
     test:is(ptr, ptr2, 'checkcdata value')
     test:is(gc_counter, 0, 'pushcdata gc')
-    obj = nil
+    obj = nil -- luacheck: ignore
     collectgarbage('collect')
     test:is(gc_counter, 1, 'pushcdata gc')
 end
@@ -116,7 +116,7 @@ local function test_iscallable(test, module)
     end
 end
 
-local test = require('tap').test("module_api", function(test)
+require('tap').test("module_api", function(test)
     test:plan(24)
     local status, module = pcall(require, 'module_api')
     test:is(status, true, "module")
@@ -138,7 +138,7 @@ local test = require('tap').test("module_api", function(test)
         end
     end
 
-    local status, msg = pcall(module.check_error)
+    local _, msg = pcall(module.check_error)
     test:like(msg, 'luaT_error', 'luaT_error')
 
     test:test("pushcdata", test_pushcdata, module)
diff --git a/test/app-tap/msgpackffi.test.lua b/test/app-tap/msgpackffi.test.lua
index 0ee5f5edc..058b74f3d 100755
--- a/test/app-tap/msgpackffi.test.lua
+++ b/test/app-tap/msgpackffi.test.lua
@@ -4,7 +4,6 @@ package.path = "lua/?.lua;"..package.path
 
 local tap = require('tap')
 local common = require('serializer_test')
-local ffi = require('ffi')
 
 local function is_map(s)
     local b = string.byte(string.sub(s, 1, 1))
@@ -76,7 +75,7 @@ local function test_other(test, s)
     --
     local function check_depth(depth_to_try)
         local t = nil
-        for i = 1, depth_to_try do t = {t} end
+        for _ = 1, depth_to_try do t = {t} end
         t = s.decode_unchecked(s.encode(t))
         local level = 0
         while t ~= nil do level = level + 1 t = t[1] end
diff --git a/test/app-tap/pcall.test.lua b/test/app-tap/pcall.test.lua
index 30163a41a..3ae16c8aa 100755
--- a/test/app-tap/pcall.test.lua
+++ b/test/app-tap/pcall.test.lua
@@ -12,7 +12,7 @@ box.cfg{
     log="tarantool.log",
     memtx_memory=107374182,
 }
-function pcalltest()
+local function pcalltest()
     local ERRMSG = "module 'some_invalid_module' not found"
     local status, msg = pcall(require, 'some_invalid_module')
     if status == false and msg ~= nil and msg:match(ERRMSG) ~= nil then
@@ -27,10 +27,10 @@ local status, msg = xpcall(pcalltest, function(msg)
 end)
 print('pcall inside xpcall:', status, msg)
 
-local status, msg = pcall(function() error('some message') end)
+status, msg = pcall(function() error('some message') end)
 print('pcall with Lua error():', status, msg:match('some message'))
 
-local status, msg = pcall(function()
+status, msg = pcall(function()
     box.error(box.error.ILLEGAL_PARAMS, 'some message')
 end)
 print('pcall with box.error():', status, msg)
diff --git a/test/app-tap/popen.test.lua b/test/app-tap/popen.test.lua
index e1aef9ef9..8bec6aab6 100755
--- a/test/app-tap/popen.test.lua
+++ b/test/app-tap/popen.test.lua
@@ -90,12 +90,13 @@ local function test_trivial_echo_output(test)
     test:ok(is_dead, 'the process is killed after close()')
 
     -- Verify that :close() is idempotent.
-    local res, err = ph:close()
+    res, err = ph:close()
     test:is_deeply({res, err}, {true, nil}, 'close() is idempotent')
 
     -- Sending a signal using a closed handle gives an error.
     local exp_err = 'popen: attempt to operate on a closed handle'
-    local ok, err = pcall(ph.signal, ph, popen.signal.SIGTERM)
+    local ok
+    ok, err = pcall(ph.signal, ph, popen.signal.SIGTERM)
     test:is_deeply({ok, err.type, tostring(err)},
                    {false, 'IllegalParams', exp_err},
                    'signal() on closed handle gives an error')
@@ -195,28 +196,28 @@ local function test_read_write(test)
     test:is_deeply({res, err}, {true, nil}, 'write() succeeds')
     local ok = ph:shutdown({stdin = true})
     test:ok(ok, 'shutdown() succeeds')
-    local res, err = ph:read()
+    res, err = ph:read()
     test:is_deeply({res, err}, {payload, nil}, 'read() from stdout succeeds')
 
     ph:close()
 
     -- The script copies data from stdin to stderr.
-    local script = 'prompt=""; read -r prompt; printf "$prompt" 1>&2'
-    local ph = popen.shell(script, 'Rw')
+    script = 'prompt=""; read -r prompt; printf "$prompt" 1>&2'
+    ph = popen.shell(script, 'Rw')
 
     -- Write to stdin, read from stderr.
-    local res, err = ph:write(payload .. '\n')
+    res, err = ph:write(payload .. '\n')
     test:is_deeply({res, err}, {true, nil}, 'write() succeeds')
-    local ok = ph:shutdown({stdin = true})
+    ok = ph:shutdown({stdin = true})
     test:ok(ok, 'shutdown() succeeds')
-    local res, err = ph:read({stderr = true})
+    res, err = ph:read({stderr = true})
     test:is_deeply({res, err}, {payload, nil}, 'read() from stderr succeeds')
 
     ph:close()
 
     -- The same script: copy from stdin to stderr.
-    local script = 'prompt=""; read -r prompt; printf "$prompt" 1>&2'
-    local ph = popen.shell(script, 'Rw')
+    script = 'prompt=""; read -r prompt; printf "$prompt" 1>&2'
+    ph = popen.shell(script, 'Rw')
 
     -- Ensure that read waits for data and does not return
     -- prematurely.
@@ -226,7 +227,7 @@ local function test_read_write(test)
         res_w, err_w = ph:write(payload .. '\n')
         ph:shutdown({stdin = true})
     end)
-    local res, err = ph:read({stderr = true})
+    res, err = ph:read({stderr = true})
     test:is_deeply({res_w, err_w}, {true, nil}, 'write() succeeds')
     test:is_deeply({res, err}, {payload, nil}, 'read() from stderr succeeds')
 
@@ -251,10 +252,10 @@ local function test_read_timeout(test)
                    'timeout error')
 
     -- Write and read after the timeout error.
-    local res, err = ph:write(payload .. '\n')
+    res, err = ph:write(payload .. '\n')
     test:is_deeply({res, err}, {true, nil}, 'write data')
     ph:shutdown({stdin = true})
-    local res, err = ph:read()
+    res, err = ph:read()
     test:is_deeply({res, err}, {payload, nil}, 'read data')
 
     ph:close()
@@ -294,13 +295,13 @@ local function test_shutdown(test)
     test:plan(9)
 
     -- Verify std* status.
-    local function test_stream_status(test, ph, pstream, exp_pstream)
-        test:plan(6)
+    local function test_stream_status(testcase, ph, pstream, exp_pstream)
+        testcase:plan(6)
         local info = ph:info()
         for _, s in ipairs({'stdin', 'stdout', 'stderr'}) do
             local exp_status = s == pstream and exp_pstream or nil
-            test:is(ph[s], exp_status, ('%s open'):format(s))
-            test:is(info[s], exp_status, ('%s open'):format(s))
+            testcase:is(ph[s], exp_status, ('%s open'):format(s))
+            testcase:is(info[s], exp_status, ('%s open'):format(s))
         end
     end
 
diff --git a/test/app-tap/snapshot.test.lua b/test/app-tap/snapshot.test.lua
index 587f8279b..6cae662c6 100755
--- a/test/app-tap/snapshot.test.lua
+++ b/test/app-tap/snapshot.test.lua
@@ -3,7 +3,6 @@
 local math = require('math')
 local fiber = require('fiber')
 local tap = require('tap')
-local ffi = require('ffi')
 local fio = require('fio')
 
 box.cfg{ log="tarantool.log", memtx_memory=107374182}
@@ -75,18 +74,18 @@ snap_chan:get()
 test:ok(true, 'gh-695: avoid overwriting tuple data necessary for smfree()')
 
 -------------------------------------------------------------------------------
--- gh-1185: Crash in matras_touch in snapshot_daemon.test 
+-- gh-1185: Crash in matras_touch in snapshot_daemon.test
 -------------------------------------------------------------------------------
 
 local s1 = box.schema.create_space('test1', { engine = 'memtx'})
-local i1 = s1:create_index('test', { type = 'tree', parts = {1, 'unsigned'} })
+s1:create_index('test', { type = 'tree', parts = {1, 'unsigned'} })
 
 local s2 = box.schema.create_space('test2', { engine = 'memtx'})
-local i2 = s2:create_index('test', { type = 'tree', parts = {1, 'unsigned'} })
+s2:create_index('test', { type = 'tree', parts = {1, 'unsigned'} })
 
 for i = 1,1000 do s1:insert{i, i, i} end
 
-local snap_chan = fiber.channel()
+snap_chan = fiber.channel()
 fiber.create(function () box.snapshot() snap_chan:put(true) end)
 
 fiber.sleep(0)
@@ -126,11 +125,11 @@ local function gh1094()
             break
         end
     end
-    local sf, mf = pcall(box.snapshot)
-    for i, f in pairs(files) do
+    local sf = pcall(box.snapshot)
+    for _, f in pairs(files) do
         f:close()
     end
-    local ss, ms = pcall(box.snapshot)
+    local ss = pcall(box.snapshot)
     test:ok(not sf and ss, msg)
 end
 gh1094()
@@ -141,7 +140,7 @@ box.snapshot()
 box.snapshot()
 box.snapshot()
 test:ok(true, 'No crash for second snapshot w/o any changes')
-files = fio.glob(box.cfg.memtx_dir .. '/*.snap')
+local files = fio.glob(box.cfg.memtx_dir .. '/*.snap')
 table.sort(files)
 fio.unlink(files[#files])
 box.snapshot()
diff --git a/test/app-tap/string.test.lua b/test/app-tap/string.test.lua
index 02a1a84d7..be489fbc2 100755
--- a/test/app-tap/string.test.lua
+++ b/test/app-tap/string.test.lua
@@ -5,40 +5,40 @@ local test = tap.test("string extensions")
 
 test:plan(7)
 
-test:test("split", function(test)
-    test:plan(10)
+test:test("split", function(testcase)
+    testcase:plan(10)
 
     -- testing basic split (works over gsplit)
-    test:ok(not pcall(string.split, "", ""), "empty separator")
-    test:ok(not pcall(string.split, "a", ""), "empty separator")
-    test:is_deeply((""):split("z"), {""},  "empty split")
-    test:is_deeply(("a"):split("a"), {"", ""}, "split self")
-    test:is_deeply(
+    testcase:ok(not pcall(string.split, "", ""), "empty separator")
+    testcase:ok(not pcall(string.split, "a", ""), "empty separator")
+    testcase:is_deeply((""):split("z"), {""},  "empty split")
+    testcase:is_deeply(("a"):split("a"), {"", ""}, "split self")
+    testcase:is_deeply(
         (" 1 2  3  "):split(),
         {"1", "2", "3"},
         "complex split on empty separator"
     )
-    test:is_deeply(
+    testcase:is_deeply(
         (" 1 2  3  "):split(" "),
         {"", "1", "2", "", "3", "", ""},
         "complex split on space separator"
     )
-    test:is_deeply(
+    testcase:is_deeply(
         (" 1 2  \n\n\n\r\t\n3  "):split(),
         {"1", "2", "3"},
         "complex split on empty separator"
     )
-    test:is_deeply(
+    testcase:is_deeply(
         ("a*bb*c*ddd"):split("*"),
         {"a", "bb", "c", "ddd"},
         "another * separator"
     )
-    test:is_deeply(
+    testcase:is_deeply(
         ("dog:fred:bonzo:alice"):split(":", 2),
         {"dog", "fred", "bonzo:alice"},
         "testing max separator"
     )
-    test:is_deeply(
+    testcase:is_deeply(
         ("///"):split("/"),
         {"", "", "", ""},
         "testing splitting on one char"
@@ -46,231 +46,231 @@ test:test("split", function(test)
 end)
 
 -- gh-2214 - string.ljust()/string.rjust() Lua API
-test:test("ljust/rjust/center", function(test)
-    test:plan(18)
+test:test("ljust/rjust/center", function(testcase)
+    testcase:plan(18)
 
-    test:is(("help"):ljust(0),  "help", "ljust, length 0, do nothing")
-    test:is(("help"):rjust(0),  "help", "rjust, length 0, do nothing")
-    test:is(("help"):center(0), "help", "center, length 0, do nothing")
+    testcase:is(("help"):ljust(0),  "help", "ljust, length 0, do nothing")
+    testcase:is(("help"):rjust(0),  "help", "rjust, length 0, do nothing")
+    testcase:is(("help"):center(0), "help", "center, length 0, do nothing")
 
-    test:is(("help"):ljust(3),  "help", "ljust, length 3, do nothing")
-    test:is(("help"):rjust(3),  "help", "rjust, length 3, do nothing")
-    test:is(("help"):center(3), "help", "center, length 3, do nothing")
+    testcase:is(("help"):ljust(3),  "help", "ljust, length 3, do nothing")
+    testcase:is(("help"):rjust(3),  "help", "rjust, length 3, do nothing")
+    testcase:is(("help"):center(3), "help", "center, length 3, do nothing")
 
-    test:is(("help"):ljust(5),  "help ", "ljust, length 5, one extra charachter")
-    test:is(("help"):rjust(5),  " help", "rjust, length 5, one extra charachter")
-    test:is(("help"):center(5), "help ", "center, length 5, one extra charachter")
+    testcase:is(("help"):ljust(5),  "help ", "ljust, length 5, one extra charachter")
+    testcase:is(("help"):rjust(5),  " help", "rjust, length 5, one extra charachter")
+    testcase:is(("help"):center(5), "help ", "center, length 5, one extra charachter")
 
-    test:is(("help"):ljust(6),  "help  ", "ljust, length 6, two extra charachters")
-    test:is(("help"):rjust(6),  "  help", "rjust, length 6, two extra charachters")
-    test:is(("help"):center(6), " help ", "center, length 6, two extra charachters")
+    testcase:is(("help"):ljust(6),  "help  ", "ljust, length 6, two extra charachters")
+    testcase:is(("help"):rjust(6),  "  help", "rjust, length 6, two extra charachters")
+    testcase:is(("help"):center(6), " help ", "center, length 6, two extra charachters")
 
-    test:is(("help"):ljust(6, '.'),  "help..", "ljust, length 6, two extra charachters, custom fill char")
-    test:is(("help"):rjust(6, '.'),  "..help", "rjust, length 6, two extra charachters, custom fill char")
-    test:is(("help"):center(6, '.'), ".help.", "center, length 6, two extra charachters, custom fill char")
+    testcase:is(("help"):ljust(6, '.'),  "help..", "ljust, length 6, two extra charachters, custom fill char")
+    testcase:is(("help"):rjust(6, '.'),  "..help", "rjust, length 6, two extra charachters, custom fill char")
+    testcase:is(("help"):center(6, '.'), ".help.", "center, length 6, two extra charachters, custom fill char")
     local errmsg = "%(char expected, got string%)"
     local _, err = pcall(function() ("help"):ljust(6, "XX") end)
-    test:ok(err and err:match(errmsg), "wrong params")
+    testcase:ok(err and err:match(errmsg), "wrong params")
     _, err = pcall(function() ("help"):rjust(6, "XX") end)
-    test:ok(err and err:match(errmsg), "wrong params")
+    testcase:ok(err and err:match(errmsg), "wrong params")
     _, err = pcall(function() ("help"):center(6, "XX") end)
-    test:ok(err and err:match(errmsg), "wrong params")
+    testcase:ok(err and err:match(errmsg), "wrong params")
 end)
 
 -- gh-2215 - string.startswith()/string.endswith() Lua API
-test:test("startswith/endswith", function(test)
-    test:plan(21)
-
-    test:ok((""):startswith(""),      "empty+empty startswith")
-    test:ok((""):endswith(""),        "empty+empty endswith")
-    test:ok(not (""):startswith("a"), "empty+non-empty startswith")
-    test:ok(not (""):endswith("a"),   "empty+non-empty endswith")
-    test:ok(("a"):startswith(""),     "non-empty+empty startswith")
-    test:ok(("a"):endswith(""),       "non-empty+empty endswith")
-
-    test:ok(("12345"):startswith("123")            , "simple startswith")
-    test:ok(("12345"):startswith("123", 1, 5)      , "startswith with good begin/end")
-    test:ok(("12345"):startswith("123", 1, 3)      , "startswith with good begin/end")
-    test:ok(("12345"):startswith("123", -5, 3)     , "startswith with good negative begin/end")
-    test:ok(("12345"):startswith("123", -5, -3)    , "startswith with good negative begin/end")
-    test:ok(not ("12345"):startswith("123", 2, 5)  , "bad startswith with good begin/end")
-    test:ok(not ("12345"):startswith("123", 1, 2)  , "bad startswith with good begin/end")
-
-    test:ok(("12345"):endswith("345")              , "simple endswith")
-    test:ok(("12345"):endswith("345", 1, 5)        , "endswith with good begin/end")
-    test:ok(("12345"):endswith("345", 3, 5)        , "endswith with good begin/end")
-    test:ok(("12345"):endswith("345", -3, 5)       , "endswith with good begin/end")
-    test:ok(("12345"):endswith("345", -3, -1)      , "endswith with good begin/end")
-    test:ok(not ("12345"):endswith("345", 1, 4)    , "bad endswith with good begin/end")
-    test:ok(not ("12345"):endswith("345", 4, 5)    , "bad endswith with good begin/end")
+test:test("startswith/endswith", function(testcase)
+    testcase:plan(21)
+
+    testcase:ok((""):startswith(""),      "empty+empty startswith")
+    testcase:ok((""):endswith(""),        "empty+empty endswith")
+    testcase:ok(not (""):startswith("a"), "empty+non-empty startswith")
+    testcase:ok(not (""):endswith("a"),   "empty+non-empty endswith")
+    testcase:ok(("a"):startswith(""),     "non-empty+empty startswith")
+    testcase:ok(("a"):endswith(""),       "non-empty+empty endswith")
+
+    testcase:ok(("12345"):startswith("123")            , "simple startswith")
+    testcase:ok(("12345"):startswith("123", 1, 5)      , "startswith with good begin/end")
+    testcase:ok(("12345"):startswith("123", 1, 3)      , "startswith with good begin/end")
+    testcase:ok(("12345"):startswith("123", -5, 3)     , "startswith with good negative begin/end")
+    testcase:ok(("12345"):startswith("123", -5, -3)    , "startswith with good negative begin/end")
+    testcase:ok(not ("12345"):startswith("123", 2, 5)  , "bad startswith with good begin/end")
+    testcase:ok(not ("12345"):startswith("123", 1, 2)  , "bad startswith with good begin/end")
+
+    testcase:ok(("12345"):endswith("345")              , "simple endswith")
+    testcase:ok(("12345"):endswith("345", 1, 5)        , "endswith with good begin/end")
+    testcase:ok(("12345"):endswith("345", 3, 5)        , "endswith with good begin/end")
+    testcase:ok(("12345"):endswith("345", -3, 5)       , "endswith with good begin/end")
+    testcase:ok(("12345"):endswith("345", -3, -1)      , "endswith with good begin/end")
+    testcase:ok(not ("12345"):endswith("345", 1, 4)    , "bad endswith with good begin/end")
+    testcase:ok(not ("12345"):endswith("345", 4, 5)    , "bad endswith with good begin/end")
 
     local _, err = pcall(function() ("help"):startswith({'n', 1}) end)
-    test:ok(err and err:match("%(string expected, got table%)"), "wrong params")
+    testcase:ok(err and err:match("%(string expected, got table%)"), "wrong params")
 end)
 
-test:test("hex", function(test)
-    test:plan(2)
-    test:is(string.hex("hello"), "68656c6c6f", "hex non-empty string")
-    test:is(string.hex(""), "", "hex empty string")
+test:test("hex", function(testcase)
+    testcase:plan(2)
+    testcase:is(string.hex("hello"), "68656c6c6f", "hex non-empty string")
+    testcase:is(string.hex(""), "", "hex empty string")
 end)
 
-test:test("fromhex", function(test)
-    test:plan(11)
-    test:is(string.fromhex("48656c6c6f"), "Hello", "from hex to bin")
-    test:is(string.fromhex("4c696e7578"), "Linux", "from hex to bin")
-    test:is(string.fromhex("6C6F72656D"), "lorem", "from hex to bin")
-    test:is(string.fromhex("697073756D"), "ipsum", "from hex to bin")
-    test:is(string.fromhex("6c6f72656d"), "lorem", "from hex to bin")
-    test:is(string.fromhex("697073756d"), "ipsum", "from hex to bin")
-    test:is(string.fromhex("6A6B6C6D6E6F"), "jklmno", "from hex to bin")
-    test:is(string.fromhex("6a6b6c6d6e6f"), "jklmno", "from hex to bin")
+test:test("fromhex", function(testcase)
+    testcase:plan(11)
+    testcase:is(string.fromhex("48656c6c6f"), "Hello", "from hex to bin")
+    testcase:is(string.fromhex("4c696e7578"), "Linux", "from hex to bin")
+    testcase:is(string.fromhex("6C6F72656D"), "lorem", "from hex to bin")
+    testcase:is(string.fromhex("697073756D"), "ipsum", "from hex to bin")
+    testcase:is(string.fromhex("6c6f72656d"), "lorem", "from hex to bin")
+    testcase:is(string.fromhex("697073756d"), "ipsum", "from hex to bin")
+    testcase:is(string.fromhex("6A6B6C6D6E6F"), "jklmno", "from hex to bin")
+    testcase:is(string.fromhex("6a6b6c6d6e6f"), "jklmno", "from hex to bin")
     local _, err = pcall(string.fromhex, "aaa")
-    test:ok(err and err:match("(even amount of chars expected," ..
+    testcase:ok(err and err:match("(even amount of chars expected," ..
                               " got odd amount)"))
-    local _, err = pcall(string.fromhex, "qq")
-    test:ok(err and err:match("(hex string expected, got non hex chars)"))
-    local _, err = pcall(string.fromhex, 795)
-    test:ok(err and err:match("(string expected, got number)"))
+    _, err = pcall(string.fromhex, "qq")
+    testcase:ok(err and err:match("(hex string expected, got non hex chars)"))
+    _, err = pcall(string.fromhex, 795)
+    testcase:ok(err and err:match("(string expected, got number)"))
 end)
 
-test:test("strip", function(test)
-    test:plan(45)
+test:test("strip", function(testcase)
+    testcase:plan(45)
     local str = "  Hello world! "
-    test:is(string.strip(str), "Hello world!", "strip (without chars)")
-    test:is(string.lstrip(str), "Hello world! ", "lstrip (without chars)")
-    test:is(string.rstrip(str), "  Hello world!", "rstrip (without chars)")
+    testcase:is(string.strip(str), "Hello world!", "strip (without chars)")
+    testcase:is(string.lstrip(str), "Hello world! ", "lstrip (without chars)")
+    testcase:is(string.rstrip(str), "  Hello world!", "rstrip (without chars)")
     str = ""
-    test:is(string.strip(str), str, "strip (0-len inp without chars)")
-    test:is(string.lstrip(str), str, "lstrip (0-len inp without chars)")
-    test:is(string.rstrip(str), str, "rstrip (0-len inp without chars)")
+    testcase:is(string.strip(str), str, "strip (0-len inp without chars)")
+    testcase:is(string.lstrip(str), str, "lstrip (0-len inp without chars)")
+    testcase:is(string.rstrip(str), str, "rstrip (0-len inp without chars)")
     str = " "
-    test:is(string.strip(str), "", "strip (1-len inp without chars)")
-    test:is(string.lstrip(str), "", "lstrip (1-len inp without chars)")
-    test:is(string.rstrip(str), "", "rstrip (1-len inp without chars)")
+    testcase:is(string.strip(str), "", "strip (1-len inp without chars)")
+    testcase:is(string.lstrip(str), "", "lstrip (1-len inp without chars)")
+    testcase:is(string.rstrip(str), "", "rstrip (1-len inp without chars)")
     str = "\t\v"
-    test:is(string.strip(str), "", "strip (strip everything without chars)")
-    test:is(string.lstrip(str), "", "lstrip (strip everything without chars)")
-    test:is(string.rstrip(str), "", "rstrip (strip everything without chars)")
+    testcase:is(string.strip(str), "", "strip (strip everything without chars)")
+    testcase:is(string.lstrip(str), "", "lstrip (strip everything without chars)")
+    testcase:is(string.rstrip(str), "", "rstrip (strip everything without chars)")
     str = "hello"
-    test:is(string.strip(str), str, "strip (strip nothing without chars)")
-    test:is(string.lstrip(str), str, "lstrip (strip nothing without chars)")
-    test:is(string.rstrip(str), str, "rstrip (strip nothing without chars)")
+    testcase:is(string.strip(str), str, "strip (strip nothing without chars)")
+    testcase:is(string.lstrip(str), str, "lstrip (strip nothing without chars)")
+    testcase:is(string.rstrip(str), str, "rstrip (strip nothing without chars)")
     str = " \t\n\v\f\rTEST \t\n\v\f\r"
-    test:is(string.strip(str), "TEST", "strip (all space characters without chars)")
-    test:is(string.lstrip(str), "TEST \t\n\v\f\r", "lstrip (all space characters without chars)")
-    test:is(string.rstrip(str), " \t\n\v\f\rTEST", "rstrip (all space characters without chars)")
+    testcase:is(string.strip(str), "TEST", "strip (all space characters without chars)")
+    testcase:is(string.lstrip(str), "TEST \t\n\v\f\r", "lstrip (all space characters without chars)")
+    testcase:is(string.rstrip(str), " \t\n\v\f\rTEST", "rstrip (all space characters without chars)")
 
     local chars = "#\0"
     str = "##Hello world!#"
-    test:is(string.strip(str, chars), "Hello world!", "strip (with chars)")
-    test:is(string.lstrip(str, chars), "Hello world!#", "lstrip (with chars)")
-    test:is(string.rstrip(str, chars), "##Hello world!", "rstrip (with chars)")
+    testcase:is(string.strip(str, chars), "Hello world!", "strip (with chars)")
+    testcase:is(string.lstrip(str, chars), "Hello world!#", "lstrip (with chars)")
+    testcase:is(string.rstrip(str, chars), "##Hello world!", "rstrip (with chars)")
     str = ""
-    test:is(string.strip(str, chars), str, "strip (0-len inp with chars)")
-    test:is(string.lstrip(str, chars), str, "lstrip (0-len inp with chars)")
-    test:is(string.rstrip(str, chars), str, "rstrip (0-len inp with chars)")
+    testcase:is(string.strip(str, chars), str, "strip (0-len inp with chars)")
+    testcase:is(string.lstrip(str, chars), str, "lstrip (0-len inp with chars)")
+    testcase:is(string.rstrip(str, chars), str, "rstrip (0-len inp with chars)")
     str = "#"
-    test:is(string.strip(str, chars), "", "strip (1-len inp with chars)")
-    test:is(string.lstrip(str, chars), "", "lstrip (1-len inp with chars)")
-    test:is(string.rstrip(str, chars), "", "rstrip (1-len inp with chars)")
+    testcase:is(string.strip(str, chars), "", "strip (1-len inp with chars)")
+    testcase:is(string.lstrip(str, chars), "", "lstrip (1-len inp with chars)")
+    testcase:is(string.rstrip(str, chars), "", "rstrip (1-len inp with chars)")
     str = "##"
-    test:is(string.strip(str, chars), "", "strip (strip everything with chars)")
-    test:is(string.lstrip(str, chars), "", "lstrip (strip everything with chars)")
-    test:is(string.rstrip(str, chars), "", "rstrip (strip everything with chars)")
+    testcase:is(string.strip(str, chars), "", "strip (strip everything with chars)")
+    testcase:is(string.lstrip(str, chars), "", "lstrip (strip everything with chars)")
+    testcase:is(string.rstrip(str, chars), "", "rstrip (strip everything with chars)")
     str = "hello"
-    test:is(string.strip(str, chars), str, "strip (strip nothing with chars)")
-    test:is(string.lstrip(str, chars), str, "lstrip (strip nothing with chars)")
-    test:is(string.rstrip(str, chars), str, "rstrip (strip nothing with chars)")
+    testcase:is(string.strip(str, chars), str, "strip (strip nothing with chars)")
+    testcase:is(string.lstrip(str, chars), str, "lstrip (strip nothing with chars)")
+    testcase:is(string.rstrip(str, chars), str, "rstrip (strip nothing with chars)")
     str = "\0\0\0TEST\0"
-    test:is(string.strip(str, chars), "TEST", "strip (embedded 0s with chars)")
-    test:is(string.lstrip(str, chars), "TEST\0", "lstrip (embedded 0s with chars)")
-    test:is(string.rstrip(str, chars), "\0\0\0TEST", "rstrip (embedded 0s with chars)")
+    testcase:is(string.strip(str, chars), "TEST", "strip (embedded 0s with chars)")
+    testcase:is(string.lstrip(str, chars), "TEST\0", "lstrip (embedded 0s with chars)")
+    testcase:is(string.rstrip(str, chars), "\0\0\0TEST", "rstrip (embedded 0s with chars)")
     chars = ""
-    test:is(string.strip(str, chars), str, "strip (0-len chars)")
-    test:is(string.lstrip(str, chars), str, "lstrip (0-len chars)")
-    test:is(string.rstrip(str, chars), str, "rstrip (0-len chars)")
+    testcase:is(string.strip(str, chars), str, "strip (0-len chars)")
+    testcase:is(string.lstrip(str, chars), str, "lstrip (0-len chars)")
+    testcase:is(string.rstrip(str, chars), str, "rstrip (0-len chars)")
 
     local _, err = pcall(string.strip, 12)
-    test:ok(err and err:match("#1 to '.-%.strip' %(string expected, got number%)"), "strip err 1")
+    testcase:ok(err and err:match("#1 to '.-%.strip' %(string expected, got number%)"), "strip err 1")
     _, err = pcall(string.lstrip, 12)
-    test:ok(err and err:match("#1 to '.-%.lstrip' %(string expected, got number%)"), "lstrip err 1")
+    testcase:ok(err and err:match("#1 to '.-%.lstrip' %(string expected, got number%)"), "lstrip err 1")
     _, err = pcall(string.rstrip, 12)
-    test:ok(err and err:match("#1 to '.-%.rstrip' %(string expected, got number%)"), "rstrip err 1")
+    testcase:ok(err and err:match("#1 to '.-%.rstrip' %(string expected, got number%)"), "rstrip err 1")
 
     _, err = pcall(string.strip, "foo", 12)
-    test:ok(err and err:match("#2 to '.-%.strip' %(string expected, got number%)"), "strip err 2")
+    testcase:ok(err and err:match("#2 to '.-%.strip' %(string expected, got number%)"), "strip err 2")
     _, err = pcall(string.lstrip, "foo", 12)
-    test:ok(err and err:match("#2 to '.-%.lstrip' %(string expected, got number%)"), "lstrip err 2")
+    testcase:ok(err and err:match("#2 to '.-%.lstrip' %(string expected, got number%)"), "lstrip err 2")
     _, err = pcall(string.rstrip, "foo", 12)
-    test:ok(err and err:match("#2 to '.-%.rstrip' %(string expected, got number%)"), "rstrip err 2")
+    testcase:ok(err and err:match("#2 to '.-%.rstrip' %(string expected, got number%)"), "rstrip err 2")
 end)
 
-test:test("unicode", function(test)
-    test:plan(104)
+test:test("unicode", function(testcase)
+    testcase:plan(104)
     local str = 'хеЛлоу вОрЛд ё Ё я Я э Э ъ Ъ hElLo WorLd 1234 i I İ 勺#☢༺'
     local upper_res = 'ХЕЛЛОУ ВОРЛД Ё Ё Я Я Э Э Ъ Ъ HELLO WORLD 1234 I I İ 勺#☢༺'
     local lower_res = 'хеллоу ворлд ё ё я я э э ъ ъ hello world 1234 i i i̇ 勺#☢༺'
     local s = utf8.upper(str)
-    test:is(s, upper_res, 'default locale upper')
+    testcase:is(s, upper_res, 'default locale upper')
     s = utf8.lower(str)
-    test:is(s, lower_res, 'default locale lower')
-    test:is(utf8.upper(''), '', 'empty string upper')
-    test:is(utf8.lower(''), '', 'empty string lower')
-    local err
-    s, err = pcall(utf8.upper, true)
-    test:isnt(err:find('Usage'), nil, 'upper usage is checked')
-    s, err = pcall(utf8.lower, true)
-    test:isnt(err:find('Usage'), nil, 'lower usage is checked')
-
-    test:is(utf8.isupper('a'), false, 'isupper("a")')
-    test:is(utf8.isupper('A'), true, 'isupper("A")')
-    test:is(utf8.islower('a'), true, 'islower("a")')
-    test:is(utf8.islower('A'), false, 'islower("A")')
-    test:is(utf8.isalpha('a'), true, 'isalpha("a")')
-    test:is(utf8.isalpha('A'), true, 'isalpha("A")')
-    test:is(utf8.isalpha('aa'), false, 'isalpha("aa")')
-    test:is(utf8.isalpha('勺'), true, 'isalpha("勺")')
-    test:is(utf8.isupper('Ё'), true, 'isupper("Ё")')
-    test:is(utf8.islower('ё'), true, 'islower("ё")')
-    test:is(utf8.isdigit('a'), false, 'isdigit("a")')
-    test:is(utf8.isdigit('1'), true, 'isdigit("1")')
-    test:is(utf8.isdigit('9'), true, 'isdigit("9")')
-
-    test:is(utf8.len(str), 56, 'len works on complex string')
+    testcase:is(s, lower_res, 'default locale lower')
+    testcase:is(utf8.upper(''), '', 'empty string upper')
+    testcase:is(utf8.lower(''), '', 'empty string lower')
+    local err, _
+    _, err = pcall(utf8.upper, true)
+    testcase:isnt(err:find('Usage'), nil, 'upper usage is checked')
+    _, err = pcall(utf8.lower, true)
+    testcase:isnt(err:find('Usage'), nil, 'lower usage is checked')
+
+    testcase:is(utf8.isupper('a'), false, 'isupper("a")')
+    testcase:is(utf8.isupper('A'), true, 'isupper("A")')
+    testcase:is(utf8.islower('a'), true, 'islower("a")')
+    testcase:is(utf8.islower('A'), false, 'islower("A")')
+    testcase:is(utf8.isalpha('a'), true, 'isalpha("a")')
+    testcase:is(utf8.isalpha('A'), true, 'isalpha("A")')
+    testcase:is(utf8.isalpha('aa'), false, 'isalpha("aa")')
+    testcase:is(utf8.isalpha('勺'), true, 'isalpha("勺")')
+    testcase:is(utf8.isupper('Ё'), true, 'isupper("Ё")')
+    testcase:is(utf8.islower('ё'), true, 'islower("ё")')
+    testcase:is(utf8.isdigit('a'), false, 'isdigit("a")')
+    testcase:is(utf8.isdigit('1'), true, 'isdigit("1")')
+    testcase:is(utf8.isdigit('9'), true, 'isdigit("9")')
+
+    testcase:is(utf8.len(str), 56, 'len works on complex string')
     s = '12İ☢勺34'
-    test:is(utf8.len(s), 7, 'len works no options')
-    test:is(utf8.len(s, 1), 7, 'default start is 1')
-    test:is(utf8.len(s, 2), 6, 'start 2')
-    test:is(utf8.len(s, 3), 5, 'start 3')
+    testcase:is(utf8.len(s), 7, 'len works no options')
+    testcase:is(utf8.len(s, 1), 7, 'default start is 1')
+    testcase:is(utf8.len(s, 2), 6, 'start 2')
+    testcase:is(utf8.len(s, 3), 5, 'start 3')
     local c
     c, err = utf8.len(s, 4)
-    test:isnil(c, 'middle of symbol offset is error')
-    test:is(err, 4, 'error on 4 byte')
-    test:is(utf8.len(s, 5), 4, 'start 5')
-    c, err = utf8.len(s, 6)
-    test:is(err, 6, 'error on 6 byte')
-    c, err = utf8.len(s, 0)
-    test:is(err, 'position is out of string', 'range is out of string')
-    test:is(utf8.len(s, #s), 1, 'start from the end')
-    test:is(utf8.len(s, #s + 1), 0, 'position is out of string')
-    test:is(utf8.len(s, 1, -1), 7, 'default end is -1')
-    test:is(utf8.len(s, 1, -2), 6, 'end -2')
-    test:is(utf8.len(s, 1, -3), 5, 'end -3')
-    test:is(utf8.len(s, 1, -4), 5, 'end in the middle of symbol')
-    test:is(utf8.len(s, 1, -5), 5, 'end in the middle of symbol')
-    test:is(utf8.len(s, 1, -6), 5, 'end in the middle of symbol')
-    test:is(utf8.len(s, 1, -7), 4, 'end -7')
-    test:is(utf8.len(s, 2, -7), 3, '[2, -7]')
-    test:is(utf8.len(s, 3, -7), 2, '[3, -7]')
-    c, err = utf8.len(s, 4, -7)
-    test:is(err, 4, '[4, -7] is error - start from the middle of symbol')
-    test:is(utf8.len(s, 10, -100), 0, 'it is ok to be out of str by end pos')
-    test:is(utf8.len(s, 10, -10), 0, 'it is ok to swap end and start pos')
-    test:is(utf8.len(''), 0, 'empty len')
-    test:is(utf8.len(s, -6, -1), 3, 'pass both negative offsets')
-    test:is(utf8.len(s, 3, 3), 1, "end in the middle on the same symbol as start")
-    c, err = utf8.len('a\xF4')
-    test:is(err, 2, "invalid unicode in the middle of the string")
+    testcase:isnil(c, 'middle of symbol offset is error')
+    testcase:is(err, 4, 'error on 4 byte')
+    testcase:is(utf8.len(s, 5), 4, 'start 5')
+    _, err = utf8.len(s, 6)
+    testcase:is(err, 6, 'error on 6 byte')
+    _, err = utf8.len(s, 0)
+    testcase:is(err, 'position is out of string', 'range is out of string')
+    testcase:is(utf8.len(s, #s), 1, 'start from the end')
+    testcase:is(utf8.len(s, #s + 1), 0, 'position is out of string')
+    testcase:is(utf8.len(s, 1, -1), 7, 'default end is -1')
+    testcase:is(utf8.len(s, 1, -2), 6, 'end -2')
+    testcase:is(utf8.len(s, 1, -3), 5, 'end -3')
+    testcase:is(utf8.len(s, 1, -4), 5, 'end in the middle of symbol')
+    testcase:is(utf8.len(s, 1, -5), 5, 'end in the middle of symbol')
+    testcase:is(utf8.len(s, 1, -6), 5, 'end in the middle of symbol')
+    testcase:is(utf8.len(s, 1, -7), 4, 'end -7')
+    testcase:is(utf8.len(s, 2, -7), 3, '[2, -7]')
+    testcase:is(utf8.len(s, 3, -7), 2, '[3, -7]')
+    _, err = utf8.len(s, 4, -7)
+    testcase:is(err, 4, '[4, -7] is error - start from the middle of symbol')
+    testcase:is(utf8.len(s, 10, -100), 0, 'it is ok to be out of str by end pos')
+    testcase:is(utf8.len(s, 10, -10), 0, 'it is ok to swap end and start pos')
+    testcase:is(utf8.len(''), 0, 'empty len')
+    testcase:is(utf8.len(s, -6, -1), 3, 'pass both negative offsets')
+    testcase:is(utf8.len(s, 3, 3), 1, "end in the middle on the same symbol as start")
+    _, err = utf8.len('a\xF4')
+    testcase:is(err, 2, "invalid unicode in the middle of the string")
 
     local chars = {}
     local codes = {}
@@ -278,21 +278,21 @@ test:test("unicode", function(test)
         table.insert(chars, utf8.char(code))
         table.insert(codes, code)
     end
-    test:is(table.concat(chars), s, "next and char works")
-    c, err = pcall(utf8.char, 'kek')
-    test:isnt(err:find('bad argument'), nil, 'char usage is checked')
-    c, err = pcall(utf8.next, true)
-    test:isnt(err:find('Usage'), nil, 'next usage is checked')
-    c, err = pcall(utf8.next, '1234', true)
-    test:isnt(err:find('bad argument'), nil, 'next usage is checked')
+    testcase:is(table.concat(chars), s, "next and char works")
+    _, err = pcall(utf8.char, 'kek')
+    testcase:isnt(err:find('bad argument'), nil, 'char usage is checked')
+    _, err = pcall(utf8.next, true)
+    testcase:isnt(err:find('Usage'), nil, 'next usage is checked')
+    _, err = pcall(utf8.next, '1234', true)
+    testcase:isnt(err:find('bad argument'), nil, 'next usage is checked')
     local offset
     offset, c = utf8.next('')
-    test:isnil(offset, 'next on empty - nil offset')
-    test:isnil(c, 'next on empty - nil code')
+    testcase:isnil(offset, 'next on empty - nil offset')
+    testcase:isnil(c, 'next on empty - nil code')
     offset, c = utf8.next('123', 100)
-    test:isnil(offset, 'out of string - nil offset')
-    test:isnil(c, 'out of string - nil code')
-    test:is(utf8.char(unpack(codes)), s, 'char with multiple values')
+    testcase:isnil(offset, 'out of string - nil offset')
+    testcase:isnil(c, 'out of string - nil code')
+    testcase:is(utf8.char(unpack(codes)), s, 'char with multiple values')
 
     local uppers = 0
     local lowers = 0
@@ -304,70 +304,70 @@ test:test("unicode", function(test)
         if utf8.isalpha(code) then letters = letters + 1 end
         if utf8.isdigit(code) then digits = digits + 1 end
     end
-    test:is(uppers, 13, 'uppers by code')
-    test:is(lowers, 19, 'lowers by code')
-    test:is(letters, 33, 'letters by code')
-    test:is(digits, 4, 'digits by code')
+    testcase:is(uppers, 13, 'uppers by code')
+    testcase:is(lowers, 19, 'lowers by code')
+    testcase:is(letters, 33, 'letters by code')
+    testcase:is(digits, 4, 'digits by code')
 
     s = '12345678'
-    test:is(utf8.sub(s, 1, 1), '1', 'sub [1]')
-    test:is(utf8.sub(s, 1, 2), '12', 'sub [1:2]')
-    test:is(utf8.sub(s, 2, 2), '2', 'sub [2:2]')
-    test:is(utf8.sub(s, 0, 2), '12', 'sub [0:2]')
-    test:is(utf8.sub(s, 3, 7), '34567', 'sub [3:7]')
-    test:is(utf8.sub(s, 7, 3), '', 'sub [7:3]')
-    test:is(utf8.sub(s, 3, 100), '345678', 'sub [3:100]')
-    test:is(utf8.sub(s, 100, 3), '', 'sub [100:3]')
-
-    test:is(utf8.sub(s, 5), '5678', 'sub [5:]')
-    test:is(utf8.sub(s, 1, -1), s, 'sub [1:-1]')
-    test:is(utf8.sub(s, 1, -2), '1234567', 'sub [1:-2]')
-    test:is(utf8.sub(s, 2, -2), '234567', 'sub [2:-2]')
-    test:is(utf8.sub(s, 3, -3), '3456', 'sub [3:-3]')
-    test:is(utf8.sub(s, 5, -4), '5', 'sub [5:-4]')
-    test:is(utf8.sub(s, 7, -7), '', 'sub[7:-7]')
-
-    test:is(utf8.sub(s, -2, -1), '78', 'sub [-2:-1]')
-    test:is(utf8.sub(s, -1, -1), '8', 'sub [-1:-1]')
-    test:is(utf8.sub(s, -4, -2), '567', 'sub [-4:-2]')
-    test:is(utf8.sub(s, -400, -2), '1234567', 'sub [-400:-2]')
-    test:is(utf8.sub(s, -3, -5), '', 'sub [-3:-5]')
-
-    test:is(utf8.sub(s, -6, 5), '345', 'sub [-6:5]')
-    test:is(utf8.sub(s, -5, 4), '4', 'sub [-5:4]')
-    test:is(utf8.sub(s, -2, 2), '', 'sub [-2:2]')
-    test:is(utf8.sub(s, -1, 8), '8', 'sub [-1:8]')
-
-    c, err = pcall(utf8.sub)
-    test:isnt(err:find('Usage'), nil, 'usage is checked')
-    c, err = pcall(utf8.sub, true)
-    test:isnt(err:find('Usage'), nil, 'usage is checked')
-    c, err = pcall(utf8.sub, '123')
-    test:isnt(err:find('Usage'), nil, 'usage is checked')
-    c, err = pcall(utf8.sub, '123', true)
-    test:isnt(err:find('bad argument'), nil, 'usage is checked')
-    c, err = pcall(utf8.sub, '123', 1, true)
-    test:isnt(err:find('bad argument'), nil, 'usage is checked')
+    testcase:is(utf8.sub(s, 1, 1), '1', 'sub [1]')
+    testcase:is(utf8.sub(s, 1, 2), '12', 'sub [1:2]')
+    testcase:is(utf8.sub(s, 2, 2), '2', 'sub [2:2]')
+    testcase:is(utf8.sub(s, 0, 2), '12', 'sub [0:2]')
+    testcase:is(utf8.sub(s, 3, 7), '34567', 'sub [3:7]')
+    testcase:is(utf8.sub(s, 7, 3), '', 'sub [7:3]')
+    testcase:is(utf8.sub(s, 3, 100), '345678', 'sub [3:100]')
+    testcase:is(utf8.sub(s, 100, 3), '', 'sub [100:3]')
+
+    testcase:is(utf8.sub(s, 5), '5678', 'sub [5:]')
+    testcase:is(utf8.sub(s, 1, -1), s, 'sub [1:-1]')
+    testcase:is(utf8.sub(s, 1, -2), '1234567', 'sub [1:-2]')
+    testcase:is(utf8.sub(s, 2, -2), '234567', 'sub [2:-2]')
+    testcase:is(utf8.sub(s, 3, -3), '3456', 'sub [3:-3]')
+    testcase:is(utf8.sub(s, 5, -4), '5', 'sub [5:-4]')
+    testcase:is(utf8.sub(s, 7, -7), '', 'sub[7:-7]')
+
+    testcase:is(utf8.sub(s, -2, -1), '78', 'sub [-2:-1]')
+    testcase:is(utf8.sub(s, -1, -1), '8', 'sub [-1:-1]')
+    testcase:is(utf8.sub(s, -4, -2), '567', 'sub [-4:-2]')
+    testcase:is(utf8.sub(s, -400, -2), '1234567', 'sub [-400:-2]')
+    testcase:is(utf8.sub(s, -3, -5), '', 'sub [-3:-5]')
+
+    testcase:is(utf8.sub(s, -6, 5), '345', 'sub [-6:5]')
+    testcase:is(utf8.sub(s, -5, 4), '4', 'sub [-5:4]')
+    testcase:is(utf8.sub(s, -2, 2), '', 'sub [-2:2]')
+    testcase:is(utf8.sub(s, -1, 8), '8', 'sub [-1:8]')
+
+    _, err = pcall(utf8.sub)
+    testcase:isnt(err:find('Usage'), nil, 'usage is checked')
+    _, err = pcall(utf8.sub, true)
+    testcase:isnt(err:find('Usage'), nil, 'usage is checked')
+    _, err = pcall(utf8.sub, '123')
+    testcase:isnt(err:find('Usage'), nil, 'usage is checked')
+    _, err = pcall(utf8.sub, '123', true)
+    testcase:isnt(err:find('bad argument'), nil, 'usage is checked')
+    _, err = pcall(utf8.sub, '123', 1, true)
+    testcase:isnt(err:find('bad argument'), nil, 'usage is checked')
 
     local s1 = '☢'
     local s2 = 'İ'
-    test:is(s1 < s2, false, 'test binary cmp')
-    test:is(utf8.cmp(s1, s2) < 0, true, 'test unicode <')
-    test:is(utf8.cmp(s1, s1) == 0, true, 'test unicode eq')
-    test:is(utf8.cmp(s2, s1) > 0, true, 'test unicode >')
-    test:is(utf8.casecmp('a', 'A') == 0, true, 'test icase ==')
-    test:is(utf8.casecmp('b', 'A') > 0, true, 'test icase >, first')
-    test:is(utf8.casecmp('B', 'a') > 0, true, 'test icase >, second >')
-    test:is(utf8.cmp('', '') == 0, true, 'test empty compare')
-    test:is(utf8.cmp('', 'a') < 0, true, 'test left empty compare')
-    test:is(utf8.cmp('a', '') > 0, true, 'test right empty compare')
-    test:is(utf8.casecmp('', '') == 0, true, 'test empty icompare')
-    test:is(utf8.casecmp('', 'a') < 0, true, 'test left empty icompare')
-    test:is(utf8.casecmp('a', '') > 0, true, 'test right empty icompare')
+    testcase:is(s1 < s2, false, 'testcase binary cmp')
+    testcase:is(utf8.cmp(s1, s2) < 0, true, 'testcase unicode <')
+    testcase:is(utf8.cmp(s1, s1) == 0, true, 'testcase unicode eq')
+    testcase:is(utf8.cmp(s2, s1) > 0, true, 'testcase unicode >')
+    testcase:is(utf8.casecmp('a', 'A') == 0, true, 'testcase icase ==')
+    testcase:is(utf8.casecmp('b', 'A') > 0, true, 'testcase icase >, first')
+    testcase:is(utf8.casecmp('B', 'a') > 0, true, 'testcase icase >, second >')
+    testcase:is(utf8.cmp('', '') == 0, true, 'testcase empty compare')
+    testcase:is(utf8.cmp('', 'a') < 0, true, 'testcase left empty compare')
+    testcase:is(utf8.cmp('a', '') > 0, true, 'testcase right empty compare')
+    testcase:is(utf8.casecmp('', '') == 0, true, 'testcase empty icompare')
+    testcase:is(utf8.casecmp('', 'a') < 0, true, 'testcase left empty icompare')
+    testcase:is(utf8.casecmp('a', '') > 0, true, 'testcase right empty icompare')
 
     -- gh-3709: utf8 can not handle an empty string.
-    test:is(utf8.lower(''), '', 'lower empty')
-    test:is(utf8.upper(''), '', 'upper empty')
+    testcase:is(utf8.lower(''), '', 'lower empty')
+    testcase:is(utf8.upper(''), '', 'upper empty')
 end)
 
 os.exit(test:check() == true and 0 or -1)
diff --git a/test/app-tap/tap.test.lua b/test/app-tap/tap.test.lua
index e2a78f630..0a8d8c6a1 100755
--- a/test/app-tap/tap.test.lua
+++ b/test/app-tap/tap.test.lua
@@ -11,7 +11,7 @@ local tap = require "tap"
 --
 -- Create a root test
 --
-test = tap.test("root test")
+local test = tap.test("root test")
 -- Disable stack traces for this test because Tarantool test system also
 -- checks test output.
 test.trace = false
@@ -88,7 +88,7 @@ end)
 --
 -- Subtest without callbacks.
 --
-sub2 = test:test("subtest 2")
+local sub2 = test:test("subtest 2")
     sub2:plan(1)
     sub2:ok(true, 'true in subtest')
     sub2:diag('hello from subtest')
@@ -97,17 +97,17 @@ sub2 = test:test("subtest 2")
 --
 -- Multisubtest
 --
-test:test("1 level", function(t)
-    t:plan(1)
-    t:test("2 level", function(t)
-        t:plan(1)
-        t:test("3 level", function(t)
-            t:plan(1)
-            t:test("4 level", function(t)
-                t:plan(1)
-                t:test("5 level", function(t)
-                    t:plan(1)
-                    t:ok(true, 'ok')
+test:test("1 level", function(t1)
+    t1:plan(1)
+    t1:test("2 level", function(t2)
+        t2:plan(1)
+        t2:test("3 level", function(t3)
+            t3:plan(1)
+            t3:test("4 level", function(t4)
+                t4:plan(1)
+                t4:test("5 level", function(t5)
+                    t5:plan(1)
+                    t5:ok(true, 'ok')
                 end)
             end)
         end)
diff --git a/test/app-tap/tarantoolctl.test.lua b/test/app-tap/tarantoolctl.test.lua
index 4d7059559..5797b4e6b 100755
--- a/test/app-tap/tarantoolctl.test.lua
+++ b/test/app-tap/tarantoolctl.test.lua
@@ -4,7 +4,6 @@ local ffi      = require('ffi')
 local fio      = require('fio')
 local tap      = require('tap')
 local uuid     = require('uuid')
-local yaml     = require('yaml')
 local errno    = require('errno')
 local fiber    = require('fiber')
 local ok, test_run = pcall(require, 'test_run')
@@ -33,7 +32,7 @@ local function recursive_rmdir(path)
         end
     end
     if fio.rmdir(path) == false then
-        print(string.format('!!! failed to rmdir path "%s"', file))
+        print(string.format('!!! failed to rmdir path "%s"', path))
         print(string.format('!!! [errno %s]: %s', errno(), errno.strerror()))
     end
 end
@@ -51,7 +50,7 @@ int execvp(const char *file, char *const argv[]);
 ]]
 
 -- background checks
-tctlcfg_code = [[default_cfg = {
+local tctlcfg_code = [[default_cfg = {
     pid_file  = '.', wal_dir = '.', memtx_dir   = '.' ,
     vinyl_dir = '.', log  = '.', background = true,
 }
@@ -97,23 +96,14 @@ local function tctl_wait_start(dir, name)
             fiber.sleep(0.01)
         end
         ::again::
-        while true do
-            local stat, nb = pcall(require('net.box').new, path, {
-                wait_connected = true, console = true
-            })
-            if stat == false then
-                fiber.sleep(0.01)
-                goto again
-            else
-                break
-            end
-            local stat, msg = pcall(nb.eval, nb, 'require("fiber").time()')
-            if stat == false then
-                fiber.sleep(0.01)
-            else
-                break
-            end
+        local stat, _ = pcall(require('net.box').new, path, {
+            wait_connected = true, console = true
+        })
+        if stat == false then
+            fiber.sleep(0.01)
+            goto again
         end
+        return
     end
 end
 
@@ -124,8 +114,7 @@ local function tctl_wait_stop(dir, name)
     end
 end
 
-local function tctl_command(dir, cmd, args, name)
-    local pid = nil
+local function tctl_command(dir, cmd, args)
     if not fio.stat(fio.pathjoin(dir, '.tarantoolctl')) then
         create_script(dir, '.tarantoolctl', tctlcfg_code)
     end
@@ -224,7 +213,7 @@ do
     -- bad code
     local code = [[ box.cfg{ ]]
     create_script(dir, 'bad_script.lua',  code)
-    local code = [[ box.cfg{memtx_memory = 104857600} ]]
+    code = [[ box.cfg{memtx_memory = 104857600} ]]
     create_script(dir, 'good_script.lua', code)
 
     local status, err = pcall(function()
@@ -258,9 +247,9 @@ do
     -- bad code
     local code = [[ error('help'); return 1]]
     create_script(dir, 'bad_script.lua',  code)
-    local code = [[ return 1]]
+    code = [[ return 1]]
     create_script(dir, 'ok_script.lua',  code)
-    local code = [[ box.cfg{memtx_memory = 104857600} box.once('help', function() end)]]
+    code = [[ box.cfg{memtx_memory = 104857600} box.once('help', function() end)]]
     create_script(dir, 'good_script.lua', code)
 
     local status, err = pcall(function()
@@ -327,12 +316,12 @@ end
 do
     local dir = fio.tempdir()
 
-    local function test_help(test, dir, cmd, e_stderr)
-        local desc = dir and 'with config' or 'without config'
-        dir = dir or './'
-        local res, stdout, stderr = run_command(dir, cmd)
+    local function test_help(testcase, directory, cmd, e_stderr)
+        local desc = directory and 'with config' or 'without config'
+        directory = directory or './'
+        local _, _, stderr = run_command(directory, cmd)
         if e_stderr ~= nil then
-            if not test:ok(stderr:find(e_stderr), ("check stderr of '%s' %s"):format(cmd, desc)) then
+            if not testcase:ok(stderr:find(e_stderr), ("check stderr of '%s' %s"):format(cmd, desc)) then
                 print(("Expected to find '%s' in '%s'"):format(e_stderr, stderr))
             end
         end
@@ -381,22 +370,22 @@ do
 
     create_script(dir, 'filler.lua', filler_code)
 
-    local function check_ctlcat_xlog(test, dir, args, delim, lc)
+    local function check_ctlcat_xlog(testcase, directory, args, delim, lc)
         local command_base = 'tarantoolctl cat filler/00000000000000000000.xlog'
         local desc = args and "cat + " .. args or "cat"
         args = args and " " .. args or ""
-        local res, stdout, stderr = run_command(dir, command_base .. args)
-        test:is(res, 0, desc .. " result")
-        test:is(select(2, stdout:gsub(delim, delim)), lc, desc .. " line count")
+        local res, stdout, _ = run_command(directory, command_base .. args)
+        testcase:is(res, 0, desc .. " result")
+        testcase:is(select(2, stdout:gsub(delim, delim)), lc, desc .. " line count")
     end
 
-    local function check_ctlcat_snap(test, dir, args, delim, lc)
+    local function check_ctlcat_snap(testcase, directory, args, delim, lc)
         local command_base = 'tarantoolctl cat filler/00000000000000000000.snap'
         local desc = args and "cat + " .. args or "cat"
         args = args and " " .. args or ""
-        local res, stdout, stderr = run_command(dir, command_base .. args)
-        test:is(res, 0, desc .. " result")
-        test:is(select(2, stdout:gsub(delim, delim)), lc, desc .. " line count")
+        local res, stdout, _ = run_command(directory, command_base .. args)
+        testcase:is(res, 0, desc .. " result")
+        testcase:is(select(2, stdout:gsub(delim, delim)), lc, desc .. " line count")
     end
 
     local status, err = pcall(function()
@@ -413,7 +402,8 @@ do
             check_ctlcat_xlog(test_i, dir, "--from=3 --to=6 --format=json --show-system", "\n", 3)
             check_ctlcat_xlog(test_i, dir, "--from=6 --to=3 --format=json --show-system", "\n", 0)
             check_ctlcat_xlog(test_i, dir, "--from=3 --to=6 --format=json --show-system --replica 1", "\n", 3)
-            check_ctlcat_xlog(test_i, dir, "--from=3 --to=6 --format=json --show-system --replica 1 --replica 2", "\n", 3)
+            check_ctlcat_xlog(test_i, dir,
+		"--from=3 --to=6 --format=json --show-system --replica 1 --replica 2", "\n", 3)
             check_ctlcat_xlog(test_i, dir, "--from=3 --to=6 --format=json --show-system --replica 2", "\n", 0)
             check_ctlcat_snap(test_i, dir, "--space=280", "---\n", 25)
             check_ctlcat_snap(test_i, dir, "--space=288", "---\n", 53)
@@ -478,10 +468,10 @@ else
             check_ok(test_i, dir, 'start', 'filler', 0)
             local lsn_before = test_run:get_lsn("remote", 1)
             test_i:is(lsn_before, 4, "check lsn before")
-            local res, stdout, stderr = run_command(dir, command_base)
+            local res, _, _ = run_command(dir, command_base)
             test_i:is(res, 0, "execution result")
             test_i:is(test_run:get_lsn("remote", 1), 10, "check lsn after")
-            local res, stdout, stderr = run_command(dir, command_base)
+            res, _, _ = run_command(dir, command_base)
             test_i:is(res, 0, "execution result")
             test_i:is(test_run:get_lsn("remote", 1), 16, "check lsn after")
         end)
@@ -497,7 +487,7 @@ else
     end
 end
 
-test:test('filter_xlog', function(test)
+test:test('filter_xlog', function(testcase)
     local xlog_data = {
         -- [1] =
         {
@@ -615,13 +605,13 @@ test:test('filter_xlog', function(test)
             exp_result = {x[7], x[9]},
         },
     }
-    test:plan(#cases)
+    testcase:plan(#cases)
 
     rawset(_G, 'TARANTOOLCTL_UNIT_TEST', true)
     local tarantoolctl = dofile(TARANTOOLCTL_PATH)
 
     -- Like xlog.pairs().
-    local function gen(param, lsn)
+    local function gen(param)
         local row = param.data[param.idx]
         if row == nil then
             return
@@ -635,14 +625,14 @@ test:test('filter_xlog', function(test)
     end
 
     for _, case in ipairs(cases) do
-        local gen, param, state = xlog_data_pairs(xlog_data)
+        local data_pairs, param, state = xlog_data_pairs(xlog_data)
         local res = {}
-        tarantoolctl.internal.filter_xlog(gen, param, state, case.opts,
+        tarantoolctl.internal.filter_xlog(data_pairs, param, state, case.opts,
             function(record)
                 table.insert(res, record)
             end
         )
-        test:is_deeply(res, case.exp_result, case[1])
+        testcase:is_deeply(res, case.exp_result, case[1])
     end
 end)
 
diff --git a/test/app-tap/trigger.test.lua b/test/app-tap/trigger.test.lua
index a31d45e5f..ea23b3325 100755
--- a/test/app-tap/trigger.test.lua
+++ b/test/app-tap/trigger.test.lua
@@ -14,8 +14,8 @@ test:plan(3)
 local trigger_list = trigger.new("sweet trigger")
 test:ok(trigger_list ~= nil, "test that trigger list is created")
 
-test:test("simple trigger test", function(test)
-    test:plan(10)
+test:test("simple trigger test", function(testcase)
+    testcase:plan(10)
 
     local cnt = 0
     local function trigger_cnt() cnt = cnt + 1 end
@@ -23,35 +23,35 @@ test:test("simple trigger test", function(test)
     -- Append first trigger
     trigger_list(trigger_cnt)
     trigger_list:run()
-    test:is(cnt, 1, "check first run")
+    testcase:is(cnt, 1, "check first run")
     -- Append second trigger
     trigger_list(trigger_cnt)
     trigger_list:run()
-    test:is(cnt, 3, "check first run")
+    testcase:is(cnt, 3, "check first run")
     -- Check listing
     local list_copy = trigger_list()
-    test:is(#list_copy, 2, "trigger() count")
+    testcase:is(#list_copy, 2, "trigger() count")
     table.remove(list_copy)
-    test:is(#trigger_list(), 2, "check that we've returned copy")
+    testcase:is(#trigger_list(), 2, "check that we've returned copy")
 
     -- Delete both triggers
-    test:is(trigger_list(nil, trigger_cnt), trigger_cnt, "pop trigger")
+    testcase:is(trigger_list(nil, trigger_cnt), trigger_cnt, "pop trigger")
     trigger_list:run()
-    test:is(#trigger_list(), 1, "check trigger count after delete")
-    test:is(cnt, 4, "check third run")
-    test:is(trigger_list(nil, trigger_cnt), trigger_cnt, "pop trigger")
+    testcase:is(#trigger_list(), 1, "check trigger count after delete")
+    testcase:is(cnt, 4, "check third run")
+    testcase:is(trigger_list(nil, trigger_cnt), trigger_cnt, "pop trigger")
     trigger_list:run()
-    test:is(#trigger_list(), 0, "check trigger count after delete")
+    testcase:is(#trigger_list(), 0, "check trigger count after delete")
 
 
     -- Check that we've failed to delete trigger
-    local stat, err = pcall(getmetatable(trigger_list).__call, trigger_list,
+    local _, err = pcall(getmetatable(trigger_list).__call, trigger_list,
                             nil, trigger_cnt)
-    test:ok(string.find(err, "is not found"), "check error")
+    testcase:ok(string.find(err, "is not found"), "check error")
 end)
 
-test:test("errored trigger test", function(test)
-    test:plan(6)
+test:test("errored trigger test", function(testcase)
+    testcase:plan(6)
 
     --
     -- Check that trigger:run() fails on the first error
@@ -61,27 +61,27 @@ test:test("errored trigger test", function(test)
     local function trigger_cnt() cnt = cnt + 1 end
     local function trigger_errored() error("test error") end
 
-    test:is(#trigger_list(), 0, "check for empty triggers")
+    testcase:is(#trigger_list(), 0, "check for empty triggers")
 
     -- Append first trigger
     trigger_list(trigger_cnt)
     trigger_list:run()
-    test:is(cnt, 1, "check simple trigger")
+    testcase:is(cnt, 1, "check simple trigger")
     -- Append errored trigger
     trigger_list(trigger_errored)
-    local status = pcall(function() trigger_list:run() end)
-    test:is(cnt, 2, "check simple+error trigger")
+    pcall(function() trigger_list:run() end)
+    testcase:is(cnt, 2, "check simple+error trigger")
     -- Flush triggers
     table_clear(trigger_list)
-    test:is(#trigger_list(), 0, "successfull flush")
+    testcase:is(#trigger_list(), 0, "successfull flush")
     -- Append first trigger
     trigger_list(trigger_errored)
-    local status = pcall(function() trigger_list:run() end)
-    test:is(cnt, 2, "check error trigger")
+    pcall(function() trigger_list:run() end)
+    testcase:is(cnt, 2, "check error trigger")
     -- Append errored trigger
     trigger_list(trigger_cnt)
-    local status = pcall(function() trigger_list:run() end)
-    test:is(cnt, 2, "check error+simple trigger")
+    pcall(function() trigger_list:run() end)
+    testcase:is(cnt, 2, "check error+simple trigger")
 end)
 
 os.exit(test:check() == true and 0 or -1)
diff --git a/test/app-tap/yaml.test.lua b/test/app-tap/yaml.test.lua
index 4669b6102..82fcb90c0 100755
--- a/test/app-tap/yaml.test.lua
+++ b/test/app-tap/yaml.test.lua
@@ -37,8 +37,6 @@ local function test_compact(test, s)
         "---\n- {'k': 'v'}\n...\n", "flow map")
     test:is(getmetatable(ss.decode(ss.encode({k = 'v'}))).__serialize, "map",
         "decoded __serialize is map")
-
-    ss = nil
 end
 
 local function test_output(test, s)
@@ -83,11 +81,11 @@ local function test_tagged(test, s)
     -- Test encoding tags.
     --
     local prefix = 'tag:tarantool.io/push,2018'
-    local ok, err = pcall(s.encode, 200, {tag_handle = true, tag_prefix = 100})
+    local _, err = pcall(s.encode, 200, {tag_handle = true, tag_prefix = 100})
     test:isnt(err:find('Usage'), nil, "encode usage")
-    ok, err = pcall(s.encode, 100, {tag_handle = 'handle'})
+    _, err = pcall(s.encode, 100, {tag_handle = 'handle'})
     test:isnt(err:find('Usage'), nil, "encode usage, no prefix")
-    ok, err = pcall(s.encode, 100, {tag_prefix = 'prefix'})
+    _, err = pcall(s.encode, 100, {tag_prefix = 'prefix'})
     test:isnt(err:find('Usage'), nil, "encode usage, no handle")
     local ret
     ret, err = s.encode(300, {tag_handle = '!push', tag_prefix = prefix})
@@ -100,11 +98,12 @@ local function test_tagged(test, s)
     --
     -- Test decoding tags.
     --
-    ok, err = pcall(s.decode)
+    _, err = pcall(s.decode)
     test:isnt(err:find('Usage'), nil, "decode usage")
-    ok, err = pcall(s.decode, false)
+    _, err = pcall(s.decode, false)
     test:isnt(err:find('Usage'), nil, "decode usage")
-    local handle, prefix = s.decode(ret, {tag_only = true})
+    local handle
+    handle, prefix = s.decode(ret, {tag_only = true})
     test:is(handle, "!print!", "handle is decoded ok")
     test:is(prefix, "tag:tarantool.io/push,2018", "prefix is decoded ok")
     local several_tags =
@@ -114,6 +113,7 @@ local function test_tagged(test, s)
 - 100
 ...
 ]]
+    local ok
     ok, err = s.decode(several_tags, {tag_only = true})
     test:is(ok, nil, "can not decode multiple tags")
     test:is(err, "can not decode multiple tags", "same")
diff --git a/test/box-py/box.lua b/test/box-py/box.lua
index e9403774c..35a087de9 100644
--- a/test/box-py/box.lua
+++ b/test/box-py/box.lua
@@ -1,5 +1,5 @@
 #!/usr/bin/env tarantool
-os = require('os')
+local os = require('os')
 
 box.cfg{
     listen              = os.getenv("LISTEN"),
diff --git a/test/box-tap/auth.test.lua b/test/box-tap/auth.test.lua
index 4e9879408..6c14d1981 100755
--- a/test/box-tap/auth.test.lua
+++ b/test/box-tap/auth.test.lua
@@ -18,22 +18,24 @@ local test = tap.test("auth")
 test:plan(42)
 
 local space = box.schema.space.create('tweedledum')
-local index = space:create_index('primary', { type = 'hash' })
+space:create_index('primary', { type = 'hash' })
 box.schema.user.create('test', {password='pass'})
 box.schema.user.create('test2', {password=''})
 
 -- check how authentication trigger work
 local msg, counter, succeeded
-function auth_trigger(user_name)
+local function auth_trigger(user_name)
     counter = counter + 1
+    msg = 'user ' .. user_name .. ' is there'
 end
 -- get user name as argument
-function auth_trigger2(user_name)
+local function auth_trigger2(user_name)
     msg = 'user ' .. user_name .. ' is there'
 end
 -- get user name and result of authentication as arguments
-function auth_trigger3(user_name, success)
-        succeeded = success
+local function auth_trigger3(user_name, success)
+    succeeded = success
+    msg = 'user ' .. user_name .. ' is there'
 end
 -- set trigger
 local handle = session.on_auth(auth_trigger)
@@ -57,68 +59,61 @@ test:is(counter, 1, "on_auth has been fired once")
 test:is(msg, "user test is there", "on_auth username param")
 test:ok(succeeded, "on_auth success param")
 conn:close()
-conn = nil
 
 -- check failing authentication
 counter = 0
 succeeded = true
-local conn = netbox.connect('test:pas@' .. HOST .. ':' .. PORT)
+conn = netbox.connect('test:pas@' .. HOST .. ':' .. PORT)
 while counter < 1 do fiber.sleep(0.001) end
 test:is(counter, 1, "on_auth has been fired once")
 test:is(msg, "user test is there", "on_auth username param")
 test:ok(not succeeded, "on_auth success param")
 conn:close()
-conn = nil
 
 counter = 0
 succeeded = false
-local conn = netbox.connect('test2:@' .. HOST .. ':' .. PORT)
+conn = netbox.connect('test2:@' .. HOST .. ':' .. PORT)
 while counter < 1 do fiber.sleep(0.001) end
 test:is(counter, 1, "on_auth has been fired once")
 test:is(msg, "user test2 is there", "on_auth username param")
 test:ok(succeeded, "on_auth success param")
 conn:close()
-conn = nil
 
 counter = 0
 succeeded = false
-local conn = netbox.connect('test2@' .. HOST .. ':' .. PORT)
+conn = netbox.connect('test2@' .. HOST .. ':' .. PORT)
 while counter < 1 do fiber.sleep(0.001) end
 test:is(counter, 1, "on_auth has been fired once")
 test:is(msg, "user test2 is there", "on_auth username param")
 test:ok(succeeded, "on_auth success param")
 conn:close()
-conn = nil
 
 counter = 0
 succeeded = false
-local conn = netbox.connect(HOST, PORT, {user='test2'})
+conn = netbox.connect(HOST, PORT, {user='test2'})
 while counter < 1 do fiber.sleep(0.001) end
 test:is(counter, 1, "on_auth has been fired once")
 test:is(msg, "user test2 is there", "on_auth username param")
 test:ok(succeeded, "on_auth success param")
 conn:close()
-conn = nil
 
 counter = 0
 succeeded = false
-local conn = netbox.connect('guest@' .. HOST .. ':' .. PORT)
+conn = netbox.connect('guest@' .. HOST .. ':' .. PORT)
 while counter < 1 do fiber.sleep(0.001) end
 test:is(counter, 1, "on_auth has been fired once")
 test:is(msg, "user guest is there", "on_auth username param")
 test:ok(succeeded, "on_auth success param")
 conn:close()
-conn = nil
 
 counter = 0
 succeeded = false
-local conn = netbox.connect('guest:@' .. HOST .. ':' .. PORT)
+conn = netbox.connect('guest:@' .. HOST .. ':' .. PORT)
 while counter < 1 do fiber.sleep(0.001) end
 test:is(counter, 1, "on_auth has been fired once")
 test:is(msg, "user guest is there", "on_auth username param")
 test:ok(succeeded, "on_auth success param")
 conn:close()
-conn = nil
 
 counter = 0
 succeeded = false
@@ -128,17 +123,15 @@ test:is(counter, 1, "on_auth has been fired once")
 test:is(msg, "user guest is there", "on_auth username param")
 test:ok(succeeded, "on_auth success param")
 conn:close()
-conn = nil
 
 counter = 0
 succeeded = false
-local conn = netbox.connect(HOST, PORT, {user='guest'})
+conn = netbox.connect(HOST, PORT, {user='guest'})
 while counter < 1 do fiber.sleep(0.001) end
 test:is(counter, 1, "on_auth has been fired once")
 test:is(msg, "user guest is there", "on_auth username param")
 test:ok(succeeded, "on_auth success param")
 conn:close()
-conn = nil
 
 -- check guest connection without authentication(no increment)
 counter = 0
@@ -148,7 +141,6 @@ conn:ping()
 test:is(counter, 0, "on_auth hasn't been fired")
 test:ok(not succeeded, "on_auth not successed param")
 conn:close()
-conn = nil
 
 test:isnil(session.on_auth(nil, auth_trigger), "removal returns nil")
 test:isnil(session.on_auth(nil, auth_trigger2), "removal returns nil")
diff --git a/test/box-tap/cfg.test.lua b/test/box-tap/cfg.test.lua
index 569b5f463..85b18a37a 100755
--- a/test/box-tap/cfg.test.lua
+++ b/test/box-tap/cfg.test.lua
@@ -76,14 +76,14 @@ test:ok(not status and result:match('Please call box.cfg{}'),
     'exception on unconfigured box')
 
 status, result = pcall(box.error, box.error.ILLEGAL_PARAMS, 'xx')
-test:ok(result.code == box.error.ILLEGAL_PARAMS, "box.error without box.cfg")
+test:ok(not status and result.code == box.error.ILLEGAL_PARAMS, "box.error without box.cfg")
 status, result = pcall(function() return box.runtime.info() end)
 test:ok(status and type(result) == 'table', "box.runtime without box.cfg")
 status, result = pcall(function() return box.index.EQ end)
 test:ok(status and type(result) == 'number', "box.index without box.cfg")
 status, result = pcall(function() return box.NULL end)
 test:ok(status and result == msgpack.NULL, "box.NULL without box.cfg")
-status, result = pcall(box.session.id)
+status = pcall(box.session.id)
 test:ok(status, "box.session without box.cfg")
 status, result = pcall(box.tuple.new, {1, 2, 3})
 test:ok(status and result[1] == 1, "box.tuple without box.cfg")
@@ -145,13 +145,13 @@ test:is(box.cfg.too_long_threshold , 0.1, "too_long_threshold new value")
 test:is(box.cfg.read_only, false, "read_only default value")
 box.cfg{read_only = true}
 test:is(box.cfg.read_only, true, "read_only new value")
-local status, reason = pcall(function()
+status = pcall(function()
     box.space._schema:insert({'read_only', 'test'})
 end)
 test:ok(not status and box.error.last().code == box.error.READONLY,
     "read_only = true")
 box.cfg{read_only = false}
-local status, reason = pcall(function()
+status = pcall(function()
     box.space._schema:insert({'read_only', 'test'})
 end)
 test:ok(status, "read_only = false")
@@ -163,7 +163,7 @@ test:is(box.cfg.worker_pool_threads, 1, 'worker_pool_threads')
 
 local tarantool_bin = arg[-1]
 local PANIC = 256
-function run_script(code)
+local function run_script(code)
     local dir = fio.tempdir()
     local script_path = fio.pathjoin(dir, 'script.lua')
     local script = fio.open(script_path, {'O_CREAT', 'O_WRONLY', 'O_APPEND'},
@@ -178,7 +178,7 @@ function run_script(code)
 end
 
 -- gh-3468: should allow box.cfg with vinyl_memory=0
-code =[[
+local code =[[
 box.cfg{vinyl_memory=0}
 os.exit(box.cfg.vinyl_memory == 0 and 0 or 1)
 ]]
@@ -198,7 +198,6 @@ code = [[ box.cfg{ wal_mode = 'write' }; box.cfg { wal_mode = 'fsync'} ]]
 test:is(run_script(code), PANIC, 'wal_mode write -> fsync is not supported')
 
 -- gh-684: Inconsistency with box.cfg and directories
-local code;
 code = [[ box.cfg{ work_dir='invalid' } ]]
 test:is(run_script(code), PANIC, 'work_dir is invalid')
 
@@ -238,7 +237,7 @@ os.remove(path)
 
 path = './tarantool.sock'
 local path2 = './tarantool2.sock'
-local s = socket.tcp_server('unix/', path, function () end)
+s = socket.tcp_server('unix/', path, function () end)
 os.execute('ln ' .. path .. ' ' .. path2)
 s:close()
 box.cfg{ listen = 'unix/:'.. path2}
@@ -270,6 +269,7 @@ test:is(run_script(code), 0, "wal_mode none and ER_LOADING")
 --
 -- gh-1962: incorrect replication source
 --
+local reason
 status, reason = pcall(box.cfg, {replication="3303,3304"})
 test:ok(not status and reason:match("Incorrect"), "invalid replication")
 
@@ -298,7 +298,7 @@ test:is(run_script(code), 0, "page size equal with range")
 code = [[
 box.cfg{slab_alloc_arena = 0.2, slab_alloc_minimal = 16,
     slab_alloc_maximal = 64 * 1024}
-os.exit(box.cfg.memtx_memory == 214748364 
+os.exit(box.cfg.memtx_memory == 214748364
     and box.cfg.memtx_min_tuple_size == 16
     and box.cfg.memtx_max_tuple_size == 64 * 1024
 and 0 or 1)
@@ -384,7 +384,7 @@ test:is(run_script(code), 0, "wal_max_size xlog rotation")
 -- gh-2872 bootstrap is aborted if vinyl_dir contains vylog files
 -- left from previous runs
 --
-vinyl_dir = fio.tempdir()
+local vinyl_dir = fio.tempdir()
 run_script(string.format([[
 box.cfg{vinyl_dir = '%s'}
 s = box.schema.space.create('test', {engine = 'vinyl'})
@@ -401,8 +401,8 @@ fio.rmtree(vinyl_dir)
 --
 -- gh-2278 vinyl does not support DDL/DML if wal_mode = 'none'
 --
-dir = fio.tempdir()
-cfg = string.format("wal_dir = '%s', memtx_dir = '%s', vinyl_dir = '%s'", dir, dir, dir)
+local dir = fio.tempdir()
+local cfg = string.format("wal_dir = '%s', memtx_dir = '%s', vinyl_dir = '%s'", dir, dir, dir)
 run_script(string.format([[
 box.cfg{%s}
 s = box.schema.space.create('test', {engine = 'vinyl'})
@@ -453,9 +453,9 @@ test:is(run_script(code), 0, "check replicaset_uuid")
 -- Configuration fails on instance or replica set UUID mismatch.
 --
 dir = fio.tempdir()
-instance_uuid = uuid.new()
-replicaset_uuid = uuid.new()
-code_fmt = [[
+local instance_uuid = uuid.new()
+local replicaset_uuid = uuid.new()
+local code_fmt = [[
 box.cfg{memtx_dir = '%s', instance_uuid = '%s', replicaset_uuid = '%s'}
 os.exit(0)
 ]]
@@ -569,14 +569,14 @@ test:is(run_script(code), 0, "log_nonblock")
 -- Crash (instead of panic) when trying to recover a huge tuple.
 --
 dir = fio.tempdir()
-code1 = string.format([[
+local code1 = string.format([[
 box.cfg{wal_dir = '%s', memtx_dir = '%s', memtx_max_tuple_size = 10 * 1024 * 1024}
 box.schema.space.create('test')
 box.space.test:create_index('primary')
 box.space.test:insert{1, string.rep('x', 1024 * 1024)}
 os.exit(0)
 ]], dir, dir)
-code2 = string.format([[
+local code2 = string.format([[
 box.cfg{wal_dir = '%s', memtx_dir = '%s', memtx_max_tuple_size = 10 * 1024}
 os.exit(0)
 ]], dir, dir)
diff --git a/test/box-tap/cfgup.test.lua b/test/box-tap/cfgup.test.lua
index 45fc12316..493a37ae0 100755
--- a/test/box-tap/cfgup.test.lua
+++ b/test/box-tap/cfgup.test.lua
@@ -6,7 +6,7 @@ local tap = require('tap')
 local test = tap.test('cfg')
 test:plan(3)
 
-config = {
+local config = {
 	pid_file = '1.pid',
     log="tarantool.log"
 }
diff --git a/test/box-tap/extended_error.test.lua b/test/box-tap/extended_error.test.lua
index 884387be8..7a6152d22 100755
--- a/test/box-tap/extended_error.test.lua
+++ b/test/box-tap/extended_error.test.lua
@@ -24,7 +24,8 @@ box.schema.func.create('forbidden_function')
 box.session.su('guest')
 local tmp = box.func.forbidden_function
 local access_denied_error
-tmp, access_denied_error = pcall(tmp.call, tmp)
+local _
+_, access_denied_error = pcall(tmp.call, tmp)
 box.session.su('admin')
 box.schema.func.drop('forbidden_function')
 box.session.su(user)
@@ -85,7 +86,7 @@ local checks = {
     type = 'ClientError',
 }
 test:ok(check_error(err, checks), "ClientError marshaling")
-tmp, err = pcall(c.call, c, 'error_throw', args)
+_, err = pcall(c.call, c, 'error_throw', args)
 test:ok(check_error(err, checks), "ClientError marshaling in iproto fields")
 
 args = {{code = 1001, reason = 'Reason2', type = 'MyError'}}
@@ -97,7 +98,7 @@ checks = {
     type = 'MyError',
 }
 test:ok(check_error(err, checks), "CustomError marshaling")
-tmp, err = pcall(c.call, c, 'error_throw', args)
+_, err = pcall(c.call, c, 'error_throw', args)
 test:ok(check_error(err, checks), "CustomError marshaling in iproto fields")
 
 err = c:call('error_access_denied')
@@ -111,7 +112,7 @@ checks = {
     access_type = 'Execute',
 }
 test:ok(check_error(err, checks), "AccessDeniedError marshaling")
-tmp, err = pcall(c.call, c, 'error_throw_access_denied')
+_, err = pcall(c.call, c, 'error_throw_access_denied')
 test:ok(check_error(err, checks), "AccessDeniedError marshaling in iproto fields")
 
 args = {
@@ -137,7 +138,7 @@ local checks2 = {
 }
 test:ok(check_error(err2, checks2), "Second error in the stack")
 
-tmp, err = pcall(c.call, c, 'error_throw_stacked', args)
+_, err = pcall(c.call, c, 'error_throw_stacked', args)
 err1 = err
 err2 = err.prev
 test:isnt(err2, nil, 'Stack is received via iproto fields')
diff --git a/test/box-tap/feedback_daemon.test.lua b/test/box-tap/feedback_daemon.test.lua
index d4adb71f1..06d967588 100755
--- a/test/box-tap/feedback_daemon.test.lua
+++ b/test/box-tap/feedback_daemon.test.lua
@@ -36,7 +36,7 @@ local function http_handle(s)
         buf = s:read('\n')
     end
     buf = s:read(length)
-    local ok, data = pcall(json.decode, buf)
+    local ok, _ = pcall(json.decode, buf)
     if ok then
         feedback = buf
         feedback_count = feedback_count + 1
@@ -126,7 +126,7 @@ fio.unlink("feedback.json")
 
 server:close()
 -- check it does not fail without server
-local daemon = box.internal.feedback_daemon
+daemon = box.internal.feedback_daemon
 daemon.start()
 daemon.send_test()
 daemon.stop()
diff --git a/test/box-tap/gc.test.lua b/test/box-tap/gc.test.lua
index f88752e71..c3437507d 100755
--- a/test/box-tap/gc.test.lua
+++ b/test/box-tap/gc.test.lua
@@ -4,7 +4,7 @@ local fiber = require('fiber')
 
 box.cfg{}
 
-local debug = type(box.error.injection) == "table" 
+local debug = type(box.error.injection) == "table"
 
 -- check box.info.gc() is false if snapshot is not in progress
 local test = tap.test('box.info.gc')
@@ -19,10 +19,10 @@ test:is(gc.checkpoint_is_in_progress, false, "checkpoint is not in progress")
 if debug then
     box.error.injection.set("ERRINJ_SNAP_COMMIT_DELAY", true)
     local snapshot_f  = function()
-       box.snapshot() 
+       box.snapshot()
     end
     fiber.create(snapshot_f)
-    local gc = box.info.gc()
+    gc = box.info.gc()
     test:is(gc.checkpoint_is_in_progress, true, "checkpoint is in progress")
     box.error.injection.set("ERRINJ_SNAP_COMMIT_DELAY", false)
 end
diff --git a/test/box-tap/gh-4785-syslog.test.lua b/test/box-tap/gh-4785-syslog.test.lua
index 9bdc97175..c0520da21 100755
--- a/test/box-tap/gh-4785-syslog.test.lua
+++ b/test/box-tap/gh-4785-syslog.test.lua
@@ -52,12 +52,12 @@ test:like(entry, pattern, 'log.info() log entry is in syslog format',
           {logs = {entry}})
 
 -- log.log_format('plain') is silently ignored.
-local ok = pcall(log.log_format, 'plain')
+ok = pcall(log.log_format, 'plain')
 test:ok(ok, "log.log_format('plain') is ignored with syslog")
 
 -- Verify log format again after log.log_format().
 log.info('world')
-local entry = unix_socket:recv(100)
+entry = unix_socket:recv(100)
 test:like(entry, pattern, 'log.info() log entry after log_format',
           {logs = {entry}})
 
diff --git a/test/box-tap/key_def.test.lua b/test/box-tap/key_def.test.lua
index d7dbf5b88..3959b9406 100755
--- a/test/box-tap/key_def.test.lua
+++ b/test/box-tap/key_def.test.lua
@@ -206,8 +206,8 @@ end
 -- Prepare source data for test cases.
 
 -- Case: extract_key().
-test:test('extract_key()', function(test)
-    test:plan(13)
+test:test('extract_key()', function(testcase)
+    testcase:plan(13)
 
     local key_def_a = key_def_lib.new({
         {type = 'unsigned', fieldno = 1},
@@ -223,19 +223,19 @@ test:test('extract_key()', function(test)
     })
     local tuple_a = box.tuple.new({1, 1, 22})
 
-    test:is_deeply(key_def_a:extract_key(tuple_a):totable(), {1}, 'case 1')
-    test:is_deeply(key_def_b:extract_key(tuple_a):totable(), {1, 22}, 'case 2')
+    testcase:is_deeply(key_def_a:extract_key(tuple_a):totable(), {1}, 'case 1')
+    testcase:is_deeply(key_def_b:extract_key(tuple_a):totable(), {1, 22}, 'case 2')
 
     -- JSON path.
     local res = key_def_lib.new({
         {type = 'string', fieldno = 1, path = 'a.b'},
     }):extract_key(box.tuple.new({{a = {b = 'foo'}}})):totable()
-    test:is_deeply(res, {'foo'}, 'JSON path (tuple argument)')
+    testcase:is_deeply(res, {'foo'}, 'JSON path (tuple argument)')
 
-    local res = key_def_lib.new({
+    res = key_def_lib.new({
         {type = 'string', fieldno = 1, path = 'a.b'},
     }):extract_key({{a = {b = 'foo'}}}):totable()
-    test:is_deeply(res, {'foo'}, 'JSON path (table argument)')
+    testcase:is_deeply(res, {'foo'}, 'JSON path (table argument)')
 
     -- A key def has a **nullable** part with a field that is over
     -- a tuple size.
@@ -244,7 +244,7 @@ test:test('extract_key()', function(test)
     --
     -- * is_nullable = true;
     -- * has_optional_parts = true.
-    test:is_deeply(key_def_c:extract_key(tuple_a):totable(), {1, 1, box.NULL},
+    testcase:is_deeply(key_def_c:extract_key(tuple_a):totable(), {1, 1, box.NULL},
         'short tuple with a nullable part')
 
     -- A key def has a **non-nullable** part with a field that is
@@ -261,73 +261,73 @@ test:test('extract_key()', function(test)
     })
     local ok, err = pcall(key_def.extract_key, key_def,
         box.tuple.new({'foo'}))
-    test:is_deeply({ok, tostring(err)}, {false, exp_err},
+    testcase:is_deeply({ok, tostring(err)}, {false, exp_err},
         'short tuple with a non-nullable part (case 1)')
 
     -- Same as before, but a max fieldno is over tuple:len() + 1.
-    local exp_err = 'Tuple field [2] required by space format is missing'
-    local key_def = key_def_lib.new({
+    exp_err = 'Tuple field [2] required by space format is missing'
+    key_def = key_def_lib.new({
         {type = 'string', fieldno = 1},
         {type = 'string', fieldno = 2},
         {type = 'string', fieldno = 3},
     })
-    local ok, err = pcall(key_def.extract_key, key_def,
+    ok, err = pcall(key_def.extract_key, key_def,
         box.tuple.new({'foo'}))
-    test:is_deeply({ok, tostring(err)}, {false, exp_err},
+    testcase:is_deeply({ok, tostring(err)}, {false, exp_err},
         'short tuple with a non-nullable part (case 2)')
 
     -- Same as before, but with another key def options:
     --
     -- * is_nullable = true;
     -- * has_optional_parts = false.
-    local exp_err = 'Tuple field [2] required by space format is missing'
-    local key_def = key_def_lib.new({
+    exp_err = 'Tuple field [2] required by space format is missing'
+    key_def = key_def_lib.new({
         {type = 'string', fieldno = 1, is_nullable = true},
         {type = 'string', fieldno = 2},
     })
-    local ok, err = pcall(key_def.extract_key, key_def,
+    ok, err = pcall(key_def.extract_key, key_def,
         box.tuple.new({'foo'}))
-    test:is_deeply({ok, tostring(err)}, {false, exp_err},
+    testcase:is_deeply({ok, tostring(err)}, {false, exp_err},
         'short tuple with a non-nullable part (case 3)')
 
     -- A tuple has a field that does not match corresponding key
     -- part type.
-    local exp_err = 'Supplied key type of part 2 does not match index ' ..
+    exp_err = 'Supplied key type of part 2 does not match index ' ..
                     'part type: expected string'
-    local key_def = key_def_lib.new({
+    key_def = key_def_lib.new({
         {type = 'string', fieldno = 1},
         {type = 'string', fieldno = 2},
         {type = 'string', fieldno = 3},
     })
-    local ok, err = pcall(key_def.extract_key, key_def, {'one', 'two', 3})
-    test:is_deeply({ok, tostring(err)}, {false, exp_err},
+    ok, err = pcall(key_def.extract_key, key_def, {'one', 'two', 3})
+    testcase:is_deeply({ok, tostring(err)}, {false, exp_err},
         'wrong field type')
 
-    local key_def = key_def_lib.new({
+    key_def = key_def_lib.new({
         {type = 'number', fieldno = 1, path='a'},
         {type = 'number', fieldno = 1, path='b'},
         {type = 'number', fieldno = 1, path='c', is_nullable=true},
         {type = 'number', fieldno = 3, is_nullable=true},
     })
-    local ok, err = pcall(key_def.extract_key, key_def,
+    ok, err = pcall(key_def.extract_key, key_def,
                           box.tuple.new({1, 1, 22}))
-    test:is_deeply({ok, tostring(err)},
+    testcase:is_deeply({ok, tostring(err)},
                 {false, 'Tuple field [1]a required by space format is missing'},
                 'invalid JSON structure')
-    test:is_deeply(key_def:extract_key({{a=1, b=2}, 1}):totable(),
+    testcase:is_deeply(key_def:extract_key({{a=1, b=2}, 1}):totable(),
                    {1, 2, box.NULL, box.NULL},
                    'tuple with optional parts - case 1')
-    test:is_deeply(key_def:extract_key({{a=1, b=2, c=3}, 1}):totable(),
+    testcase:is_deeply(key_def:extract_key({{a=1, b=2, c=3}, 1}):totable(),
                    {1, 2, 3, box.NULL},
                    'tuple with optional parts - case 2')
-    test:is_deeply(key_def:extract_key({{a=1, b=2}, 1, 3}):totable(),
+    testcase:is_deeply(key_def:extract_key({{a=1, b=2}, 1, 3}):totable(),
                    {1, 2, box.NULL, 3},
                    'tuple with optional parts - case 3')
 end)
 
 -- Case: compare().
-test:test('compare()', function(test)
-    test:plan(8)
+test:test('compare()', function(testcase)
+    testcase:plan(8)
 
     local key_def_a = key_def_lib.new({
         {type = 'unsigned', fieldno = 1},
@@ -340,28 +340,28 @@ test:test('compare()', function(test)
     local tuple_b = box.tuple.new({2, 1, 11})
     local tuple_c = box.tuple.new({3, 1, 22})
 
-    test:is(key_def_a:compare(tuple_b, tuple_a), 1,
+    testcase:is(key_def_a:compare(tuple_b, tuple_a), 1,
             'case 1: great (tuple argument)')
-    test:is(key_def_a:compare(tuple_b, tuple_c), -1,
+    testcase:is(key_def_a:compare(tuple_b, tuple_c), -1,
             'case 2: less (tuple argument)')
-    test:is(key_def_b:compare(tuple_b, tuple_a), -1,
+    testcase:is(key_def_b:compare(tuple_b, tuple_a), -1,
             'case 3: less (tuple argument)')
-    test:is(key_def_b:compare(tuple_a, tuple_c), 0,
+    testcase:is(key_def_b:compare(tuple_a, tuple_c), 0,
             'case 4: equal (tuple argument)')
 
-    test:is(key_def_a:compare(tuple_b:totable(), tuple_a:totable()), 1,
+    testcase:is(key_def_a:compare(tuple_b:totable(), tuple_a:totable()), 1,
             'case 1: great (table argument)')
-    test:is(key_def_a:compare(tuple_b:totable(), tuple_c:totable()), -1,
+    testcase:is(key_def_a:compare(tuple_b:totable(), tuple_c:totable()), -1,
             'case 2: less (table argument)')
-    test:is(key_def_b:compare(tuple_b:totable(), tuple_a:totable()), -1,
+    testcase:is(key_def_b:compare(tuple_b:totable(), tuple_a:totable()), -1,
             'case 3: less (table argument)')
-    test:is(key_def_b:compare(tuple_a:totable(), tuple_c:totable()), 0,
+    testcase:is(key_def_b:compare(tuple_a:totable(), tuple_c:totable()), 0,
             'case 4: equal (table argument)')
 end)
 
 -- Case: compare_with_key().
-test:test('compare_with_key()', function(test)
-    test:plan(2)
+test:test('compare_with_key()', function(testcase)
+    testcase:plan(2)
 
     local key_def_b = key_def_lib.new({
         {type = 'number', fieldno = 2},
@@ -370,15 +370,15 @@ test:test('compare_with_key()', function(test)
     local tuple_a = box.tuple.new({1, 1, 22})
 
     local key = {1, 22}
-    test:is(key_def_b:compare_with_key(tuple_a:totable(), key), 0, 'table')
+    testcase:is(key_def_b:compare_with_key(tuple_a:totable(), key), 0, 'table')
 
-    local key = box.tuple.new({1, 22})
-    test:is(key_def_b:compare_with_key(tuple_a, key), 0, 'tuple')
+    key = box.tuple.new({1, 22})
+    testcase:is(key_def_b:compare_with_key(tuple_a, key), 0, 'tuple')
 end)
 
 -- Case: totable().
-test:test('totable()', function(test)
-    test:plan(2)
+test:test('totable()', function(testcase)
+    testcase:plan(2)
 
     local parts_a = {
         {type = 'unsigned', fieldno = 1}
@@ -391,15 +391,15 @@ test:test('totable()', function(test)
     local key_def_b = key_def_lib.new(parts_b)
 
     local exp = set_key_part_defaults(parts_a)
-    test:is_deeply(key_def_a:totable(), exp, 'case 1')
+    testcase:is_deeply(key_def_a:totable(), exp, 'case 1')
 
-    local exp = set_key_part_defaults(parts_b)
-    test:is_deeply(key_def_b:totable(), exp, 'case 2')
+    exp = set_key_part_defaults(parts_b)
+    testcase:is_deeply(key_def_b:totable(), exp, 'case 2')
 end)
 
 -- Case: __serialize().
-test:test('__serialize()', function(test)
-    test:plan(2)
+test:test('__serialize()', function(testcase)
+    testcase:plan(2)
 
     local parts_a = {
         {type = 'unsigned', fieldno = 1}
@@ -412,15 +412,15 @@ test:test('__serialize()', function(test)
     local key_def_b = key_def_lib.new(parts_b)
 
     local exp = set_key_part_defaults(parts_a)
-    test:is(json.encode(key_def_a), json.encode(exp), 'case 1')
+    testcase:is(json.encode(key_def_a), json.encode(exp), 'case 1')
 
-    local exp = set_key_part_defaults(parts_b)
-    test:is(json.encode(key_def_b), json.encode(exp), 'case 2')
+    exp = set_key_part_defaults(parts_b)
+    testcase:is(json.encode(key_def_b), json.encode(exp), 'case 2')
 end)
 
 -- Case: tostring().
-test:test('tostring()', function(test)
-    test:plan(2)
+test:test('tostring()', function(testcase)
+    testcase:plan(2)
 
     local parts_a = {
         {type = 'unsigned', fieldno = 1}
@@ -433,13 +433,13 @@ test:test('tostring()', function(test)
     local key_def_b = key_def_lib.new(parts_b)
 
     local exp = '<struct key_def &>'
-    test:is(tostring(key_def_a), exp, 'case 1')
-    test:is(tostring(key_def_b), exp, 'case 2')
+    testcase:is(tostring(key_def_a), exp, 'case 1')
+    testcase:is(tostring(key_def_b), exp, 'case 2')
 end)
 
 -- Case: merge().
-test:test('merge()', function(test)
-    test:plan(6)
+test:test('merge()', function(testcase)
+    testcase:plan(6)
 
     local key_def_a = key_def_lib.new({
         {type = 'unsigned', fieldno = 1},
@@ -458,27 +458,27 @@ test:test('merge()', function(test)
     local key_def_ab = key_def_a:merge(key_def_b)
     local exp_parts = fun.iter(key_def_a:totable())
         :chain(fun.iter(key_def_b:totable())):totable()
-    test:is_deeply(key_def_ab:totable(), exp_parts,
+    testcase:is_deeply(key_def_ab:totable(), exp_parts,
         'case 1: verify with :totable()')
-    test:is_deeply(key_def_ab:extract_key(tuple_a):totable(), {1, 1, 22},
+    testcase:is_deeply(key_def_ab:extract_key(tuple_a):totable(), {1, 1, 22},
         'case 1: verify with :extract_key()')
 
     local key_def_ba = key_def_b:merge(key_def_a)
-    local exp_parts = fun.iter(key_def_b:totable())
+    exp_parts = fun.iter(key_def_b:totable())
         :chain(fun.iter(key_def_a:totable())):totable()
-    test:is_deeply(key_def_ba:totable(), exp_parts,
+    testcase:is_deeply(key_def_ba:totable(), exp_parts,
         'case 2: verify with :totable()')
-    test:is_deeply(key_def_ba:extract_key(tuple_a):totable(), {1, 22, 1},
+    testcase:is_deeply(key_def_ba:extract_key(tuple_a):totable(), {1, 22, 1},
         'case 2: verify with :extract_key()')
 
     -- Intersecting parts + NULL parts.
     local key_def_cb = key_def_c:merge(key_def_b)
-    local exp_parts = key_def_c:totable()
+    exp_parts = key_def_c:totable()
     exp_parts[#exp_parts + 1] = {type = 'number', fieldno = 3,
         is_nullable = false}
-    test:is_deeply(key_def_cb:totable(), exp_parts,
+    testcase:is_deeply(key_def_cb:totable(), exp_parts,
         'case 3: verify with :totable()')
-    test:is_deeply(key_def_cb:extract_key(tuple_a):totable(),
+    testcase:is_deeply(key_def_cb:extract_key(tuple_a):totable(),
         {1, 1, box.NULL, 22}, 'case 3: verify with :extract_key()')
 end)
 
diff --git a/test/box-tap/merger.test.lua b/test/box-tap/merger.test.lua
index ee9eaeaed..768b42a41 100755
--- a/test/box-tap/merger.test.lua
+++ b/test/box-tap/merger.test.lua
@@ -39,7 +39,7 @@ end
 
 -- Get buffer with data encoded without last 'trunc' bytes.
 local function truncated_msgpack_buffer(data, trunc)
-    local data = msgpackffi.encode(data)
+    data = msgpackffi.encode(data)
     data = data:sub(1, data:len() - trunc)
     local len = data:len()
     local buf = buffer.ibuf()
@@ -370,7 +370,7 @@ local function fetch_source_iterator(input_type, tuples)
 end
 
 local function prepare_data(schema, tuple_count, source_count, opts)
-    local opts = opts or {}
+    opts = opts or {}
     local input_type = opts.input_type
     local use_table_as_tuple = opts.use_table_as_tuple
     local use_fetch_source = opts.use_fetch_source
@@ -471,7 +471,7 @@ end
 local function run_merger(test, schema, tuple_count, source_count, opts)
     fiber.yield()
 
-    local opts = opts or {}
+    opts = opts or {}
 
     -- Prepare data.
     local sources, exp_result = prepare_data(schema, tuple_count, source_count,
@@ -516,8 +516,8 @@ local function run_merger(test, schema, tuple_count, source_count, opts)
         :format(tuple_count, source_count, test_case_opts_str(opts)))
 end
 
-local function run_case(test, schema, opts)
-    local opts = opts or {}
+local function run_case(testcase, schema, opts)
+    opts = opts or {}
 
     local case_name = ('testing on schema %s%s'):format(
         schema.name, test_case_opts_str(opts))
@@ -535,7 +535,7 @@ local function run_case(test, schema, opts)
         return
     end
 
-    test:test(case_name, function(test)
+    testcase:test(case_name, function(test)
         test:plan(4)
 
         -- Check with small buffer count.
@@ -556,12 +556,12 @@ test:plan(#bad_source_new_calls + #bad_chunks + #bad_merger_new_calls +
 box.cfg{}
 
 for _, case in ipairs(bad_source_new_calls) do
-    test:test(case[1], function(test)
+    test:test(case[1], function(testcase)
         local funcs = case.funcs
-        test:plan(#funcs)
+        testcase:plan(#funcs)
         for _, func in ipairs(funcs) do
             local ok, err = pcall(merger[func], unpack(case.params))
-            test:ok(ok == false and err:match(case.exp_err), func)
+            testcase:ok(ok == false and err:match(case.exp_err), func)
         end
     end)
 end
@@ -602,8 +602,8 @@ for _, schema in ipairs(schemas) do
     schema.key_def = key_def_lib.new(schema.parts)
 end
 
-test:test('use a source in two mergers', function(test)
-    test:plan(5)
+test:test('use a source in two mergers', function(testcase)
+    testcase:plan(5)
 
     local data = {{'a'}, {'b'}, {'c'}}
     local source = merger.new_source_fromtable(data)
@@ -611,16 +611,16 @@ test:test('use a source in two mergers', function(test)
     local i2 = merger.new(key_def, {source}):pairs()
 
     local t1 = i1:head():totable()
-    test:is_deeply(t1, data[1], 'tuple 1 from merger 1')
+    testcase:is_deeply(t1, data[1], 'tuple 1 from merger 1')
 
     local t3 = i2:head():totable()
-    test:is_deeply(t3, data[3], 'tuple 3 from merger 2')
+    testcase:is_deeply(t3, data[3], 'tuple 3 from merger 2')
 
     local t2 = i1:head():totable()
-    test:is_deeply(t2, data[2], 'tuple 2 from merger 1')
+    testcase:is_deeply(t2, data[2], 'tuple 2 from merger 1')
 
-    test:ok(i1:is_null(), 'merger 1 ends')
-    test:ok(i2:is_null(), 'merger 2 ends')
+    testcase:ok(i1:is_null(), 'merger 1 ends')
+    testcase:ok(i2:is_null(), 'merger 2 ends')
 end)
 
 local function reusable_source_gen(param)
@@ -640,37 +640,37 @@ local function reusable_source_gen(param)
     return box.NULL, chunk
 end
 
-local function verify_reusable_source(test, source)
-    test:plan(3)
+local function verify_reusable_source(testcase, source)
+    testcase:plan(3)
 
     local exp = {{1}, {2}}
     local res = source:pairs():map(box.tuple.totable):totable()
-    test:is_deeply(res, exp, '1st use')
+    testcase:is_deeply(res, exp, '1st use')
 
-    local exp = {{3}, {4}, {5}}
-    local res = source:pairs():map(box.tuple.totable):totable()
-    test:is_deeply(res, exp, '2nd use')
+    exp = {{3}, {4}, {5}}
+    res = source:pairs():map(box.tuple.totable):totable()
+    testcase:is_deeply(res, exp, '2nd use')
 
-    local exp = {}
-    local res = source:pairs():map(box.tuple.totable):totable()
-    test:is_deeply(res, exp, 'end')
+    exp = {}
+    res = source:pairs():map(box.tuple.totable):totable()
+    testcase:is_deeply(res, exp, 'end')
 end
 
-test:test('reuse a tuple source', function(test)
+test:test('reuse a tuple source', function(testcase)
     local tuples = {{1}, {2}, nil, {3}, {4}, {5}}
     local source = merger.new_tuple_source(reusable_source_gen,
         {chunks = tuples})
-    verify_reusable_source(test, source)
+    verify_reusable_source(testcase, source)
 end)
 
-test:test('reuse a table source', function(test)
+test:test('reuse a table source', function(testcase)
     local chunks = {{{1}}, {{2}}, {}, nil, {{3}}, {{4}}, {}, {{5}}}
     local source = merger.new_table_source(reusable_source_gen,
         {chunks = chunks})
-    verify_reusable_source(test, source)
+    verify_reusable_source(testcase, source)
 end)
 
-test:test('reuse a buffer source', function(test)
+test:test('reuse a buffer source', function(testcase)
     local chunks_tbl = {{{1}}, {{2}}, {}, nil, {{3}}, {{4}}, {}, {{5}}}
     local chunks = {}
     for i = 1, table.maxn(chunks_tbl) do
@@ -683,43 +683,43 @@ test:test('reuse a buffer source', function(test)
     end
     local source = merger.new_buffer_source(reusable_source_gen,
         {chunks = chunks})
-    verify_reusable_source(test, source)
+    verify_reusable_source(testcase, source)
 end)
 
-test:test('use limit', function(test)
-    test:plan(6)
+test:test('use limit', function(testcase)
+    testcase:plan(6)
 
     local data = {{'a'}, {'b'}}
 
     local source = merger.new_source_fromtable(data)
     local m = merger.new(key_def, {source})
     local res = m:select({limit = 0})
-    test:is(#res, 0, 'table output with limit 0')
+    testcase:is(#res, 0, 'table output with limit 0')
 
-    local source = merger.new_source_fromtable(data)
-    local m = merger.new(key_def, {source})
-    local res = m:select({limit = 1})
-    test:is(#res, 1, 'table output with limit 1')
-    test:is_deeply(res[1]:totable(), data[1], 'tuple content')
+    source = merger.new_source_fromtable(data)
+    m = merger.new(key_def, {source})
+    res = m:select({limit = 1})
+    testcase:is(#res, 1, 'table output with limit 1')
+    testcase:is_deeply(res[1]:totable(), data[1], 'tuple content')
 
-    local source = merger.new_source_fromtable(data)
-    local m = merger.new(key_def, {source})
+    source = merger.new_source_fromtable(data)
+    m = merger.new(key_def, {source})
     local output_buffer = buffer.ibuf()
     m:select({buffer = output_buffer, limit = 0})
-    local res = msgpackffi.decode(output_buffer.rpos)
-    test:is(#res, 0, 'buffer output with limit 0')
+    res = msgpackffi.decode(output_buffer.rpos)
+    testcase:is(#res, 0, 'buffer output with limit 0')
 
-    local source = merger.new_source_fromtable(data)
-    local m = merger.new(key_def, {source})
+    source = merger.new_source_fromtable(data)
+    m = merger.new(key_def, {source})
     output_buffer:recycle()
     m:select({buffer = output_buffer, limit = 1})
-    local res = msgpackffi.decode(output_buffer.rpos)
-    test:is(#res, 1, 'buffer output with limit 1')
-    test:is_deeply(res[1], data[1], 'tuple content')
+    res = msgpackffi.decode(output_buffer.rpos)
+    testcase:is(#res, 1, 'buffer output with limit 1')
+    testcase:is_deeply(res[1], data[1], 'tuple content')
 end)
 
-test:test('cascade mergers', function(test)
-    test:plan(2)
+test:test('cascade mergers', function(testcase)
+    testcase:plan(2)
 
     local data = {{'a'}, {'b'}}
 
@@ -728,7 +728,7 @@ test:test('cascade mergers', function(test)
     local m2 = merger.new(key_def, {m1})
 
     local res = m2:pairs():map(box.tuple.totable):totable()
-    test:is_deeply(res, data, 'same key_def')
+    testcase:is_deeply(res, data, 'same key_def')
 
     local key_def_unicode = key_def_lib.new({{
         fieldno = 1,
@@ -736,12 +736,12 @@ test:test('cascade mergers', function(test)
         collation = 'unicode',
     }})
 
-    local source = merger.new_source_fromtable(data)
-    local m1 = merger.new(key_def, {source})
-    local m2 = merger.new(key_def_unicode, {m1})
+    source = merger.new_source_fromtable(data)
+    m1 = merger.new(key_def, {source})
+    m2 = merger.new(key_def_unicode, {m1})
 
-    local res = m2:pairs():map(box.tuple.totable):totable()
-    test:is_deeply(res, data, 'different key_defs')
+    res = m2:pairs():map(box.tuple.totable):totable()
+    testcase:is_deeply(res, data, 'different key_defs')
 end)
 
 -- Merging cases.
diff --git a/test/box-tap/on_schema_init.test.lua b/test/box-tap/on_schema_init.test.lua
index 51b28ea08..db9ae6f27 100755
--- a/test/box-tap/on_schema_init.test.lua
+++ b/test/box-tap/on_schema_init.test.lua
@@ -8,7 +8,7 @@ local test = tap.test('on_schema_init')
 local str = ''
 test:plan(7)
 
-function testing_trig()
+local function testing_trig()
     test:istable(box.space._space, 'system spaces are accessible')
     test:is(type(box.space._space.before_replace), 'function', 'before_replace triggers')
     test:is(type(box.space._space.on_replace), 'function', 'on_replace triggers')
@@ -17,7 +17,7 @@ function testing_trig()
     str = str..'on_schema_init'
 end
 
-trig = box.ctl.on_schema_init(testing_trig)
+local trig = box.ctl.on_schema_init(testing_trig)
 test:is(type(trig), 'function', 'on_schema_init trigger set')
 
 box.cfg{log = 'tarantool.log'}
diff --git a/test/box-tap/schema_mt.test.lua b/test/box-tap/schema_mt.test.lua
index 5a635262f..c098fcc3e 100755
--- a/test/box-tap/schema_mt.test.lua
+++ b/test/box-tap/schema_mt.test.lua
@@ -21,6 +21,7 @@ local sp2 = box.schema.create_space('test2', {engine = 'vinyl'})
 test:is(getmetatable(sp1).__index, getmetatable(sp2).__index, 'spaces share metatables __index')
 
 function box.schema.space_mt.myfunc(space, args)
+  print(space)
   return args
 end
 test:is(sp1:myfunc(123), 123, 'space_mt can be extended')
@@ -42,12 +43,15 @@ test:isnt(getmetatable(sp1_pk).__index, getmetatable(sp2_pk).__index, 'engines d
 -- extend base index metatable, or extend engine specific.
 --
 function box.schema.index_mt.common_func(index, args)
+  print(index)
   return args
 end
 function box.schema.vinyl_index_mt.vinyl_func(index, args)
+  print(index)
   return args
 end
 function box.schema.memtx_index_mt.memtx_func(index, args)
+  print(index)
   return args
 end
 test:is(box.schema.index_mt.common_func, box.schema.vinyl_index_mt.common_func,
@@ -77,14 +81,14 @@ test:is(sp2_sk:common_func(400), 400, 'vinyl common methods work')
 -- A space local metatable can extended so it does not affect
 -- other spaces. Same about index.
 --
-sp3 = box.schema.create_space('test3', {engine = 'memtx'})
-sp3_pk = sp3:create_index('pk')
-sp3_sk = sp3:create_index('sk')
-mt1 = getmetatable(sp1)
-mt2 = getmetatable(sp2)
+local sp3 = box.schema.create_space('test3', {engine = 'memtx'})
+local sp3_pk = sp3:create_index('pk')
+local sp3_sk = sp3:create_index('sk')
+local mt1 = getmetatable(sp1)
+local mt2 = getmetatable(sp2)
 test:isnt(mt1, mt2, 'spaces do not share metatables')
-index_mt1 = getmetatable(sp3_pk)
-index_mt2 = getmetatable(sp3_sk)
+local index_mt1 = getmetatable(sp3_pk)
+local index_mt2 = getmetatable(sp3_sk)
 test:isnt(index_mt1, index_mt2, 'indexes do not share metatables')
 
 mt1.my_func = function(a) return a end
diff --git a/test/box-tap/session.storage.test.lua b/test/box-tap/session.storage.test.lua
index 40ca9c230..d17d3efce 100755
--- a/test/box-tap/session.storage.test.lua
+++ b/test/box-tap/session.storage.test.lua
@@ -19,7 +19,7 @@ test:is(
 )
 
 local uri = inspector:eval('session_storage', 'box.cfg.listen')[1]
-conn1 = net_box.connect(uri)
+local conn1 = net_box.connect(uri)
 
 conn1:eval("session = box.session")
 test:is(conn1:eval("return type(session.id())"), "number", "session.id()")
@@ -34,7 +34,7 @@ conn1:eval("all = getmetatable(session).aggregate_storage")
 test:ok(conn1:eval("return all[session.id()].abc == 'cde'"), "check meta table")
 
 
-conn2 = net_box.connect(uri)
+local conn2 = net_box.connect(uri)
 
 test:is(conn2:eval("return type(session.storage)"), "table", "storage")
 test:isnil(conn2:eval("return type(session.storage.abc)"), "empty storage")
@@ -45,12 +45,12 @@ test:ok(conn1:eval("return session.storage.abc == 'cde'"), "first conn storage")
 test:ok(conn1:eval("return all[session.id()].abc == 'cde'"), "check first conn metatable")
 test:ok(conn2:eval("return all[session.id()].abc == 'def'"), "check second conn metatable")
 
-tres1 = conn1:eval("t1 = {} for k, v in pairs(all) do table.insert(t1, v.abc) end return t1")
+local tres1 = conn1:eval("t1 = {} for k, v in pairs(all) do table.insert(t1, v.abc) end return t1")
 
 conn1:close()
 conn2:close()
-conn3 = net_box.connect(uri)
-tres2 = conn3:eval("t2 = {} for k, v in pairs(all) do table.insert(t2, v.abc) end return t2")
+local conn3 = net_box.connect(uri)
+local tres2 = conn3:eval("t2 = {} for k, v in pairs(all) do table.insert(t2, v.abc) end return t2")
 table.sort(tres1)
 table.sort(tres2)
 test:is(tres1[1], "cde", "check after closing")
diff --git a/test/box-tap/session.test.lua b/test/box-tap/session.test.lua
index 5d4965533..09095f99f 100755
--- a/test/box-tap/session.test.lua
+++ b/test/box-tap/session.test.lua
@@ -13,7 +13,7 @@ local uri = require('uri').parse(box.cfg.listen)
 local HOST, PORT = uri.host or 'localhost', uri.service
 session = box.session
 space = box.schema.space.create('tweedledum')
-index = space:create_index('primary', { type = 'hash' })
+space:create_index('primary', { type = 'hash' })
 
 test:plan(56)
 
@@ -23,25 +23,26 @@ test:plan(56)
 test:ok(session.exists(session.id()), "session is created")
 test:isnil(session.peer(session.id()), "session.peer")
 test:ok(session.exists(), "session.exists")
-ok, err = pcall(session.exists, 1, 2, 3)
+local err, _
+_, err = pcall(session.exists, 1, 2, 3)
 test:is(err, "session.exists(sid): bad arguments", "exists bad args #2")
 test:ok(not session.exists(1234567890), "session doesn't exist")
 
 -- check session.id()
 test:ok(session.id() > 0, "id > 0")
-failed = false
+local failed = false
 local f = fiber.create(function() failed = session.id() == 0 end)
 while f:status() ~= 'dead' do fiber.sleep(0) end
 test:ok(not failed, "session not broken")
 test:is(session.peer(), session.peer(session.id()), "peer() == peer(id())")
 
 -- check on_connect/on_disconnect triggers
-function noop() end
+local function noop() end
 test:is(type(session.on_connect(noop)), "function", "type of trigger noop on_connect")
 test:is(type(session.on_disconnect(noop)), "function", "type of trigger noop on_disconnect")
 
 -- check it's possible to reset these triggers
-function fail() error('hear') end
+local function fail() error('hear') end
 test:is(type(session.on_connect(fail, noop)), "function", "type of trigger fail, noop on_connect")
 test:is(type(session.on_disconnect(fail, noop)), "function", "type of trigger fail, noop on_disconnect")
 
@@ -49,19 +50,19 @@ test:is(type(session.on_disconnect(fail, noop)), "function", "type of trigger fa
 test:is(type(session.on_connect()), "table", "type of trigger on_connect, no args")
 test:is(type(session.on_disconnect()), "table", "type of trigger on_disconnect, no args")
 
-ok, err = pcall(session.on_connect, function() end, function() end)
+_, err = pcall(session.on_connect, function() end, function() end)
 test:is(err,"trigger reset: Trigger is not found", "on_connect trigger not found")
-ok, err = pcall(session.on_disconnect, function() end, function() end)
+_, err = pcall(session.on_disconnect, function() end, function() end)
 test:is(err,"trigger reset: Trigger is not found", "on_disconnect trigger not found")
 
-ok, err = pcall(session.on_connect, 1, 2)
+_, err = pcall(session.on_connect, 1, 2)
 test:is(err, "trigger reset: incorrect arguments", "on_connect bad args #1")
-ok, err = pcall(session.on_disconnect, 1, 2)
+_, err = pcall(session.on_disconnect, 1, 2)
 test:is(err, "trigger reset: incorrect arguments", "on_disconnect bad args #1")
 
-ok, err = pcall(session.on_connect, 1)
+_, err = pcall(session.on_connect, 1)
 test:is(err, "trigger reset: incorrect arguments", "on_connect bad args #2")
-ok, err = pcall(session.on_disconnect, 1)
+_, err = pcall(session.on_disconnect, 1)
 test:is(err, "trigger reset: incorrect arguments", "on_disconnect bad args #2")
 
 -- use of nil to clear the trigger
@@ -70,18 +71,18 @@ session.on_disconnect(nil, fail)
 
 -- check how connect/disconnect triggers work
 local peer_name = "peer_name"
-function inc() active_connections = active_connections + 1 end
-function dec() active_connections = active_connections - 1 end
-function peer() peer_name = box.session.peer() end
-net = { box = require('net.box') }
+local function inc() active_connections = active_connections + 1 end
+local function dec() active_connections = active_connections - 1 end
+local function peer() peer_name = box.session.peer() end
+local net = { box = require('net.box') }
 test:is(type(session.on_connect(inc)), "function", "type of trigger inc on_connect")
 test:is(type(session.on_disconnect(dec)), "function", "type of trigger dec on_disconnect")
 test:is(type(session.on_disconnect(peer)), "function", "type of trigger peer on_disconnect")
 active_connections = 0
-c = net.box.connect(HOST, PORT)
+local c = net.box.connect(HOST, PORT)
 while active_connections < 1 do fiber.sleep(0.001) end
 test:is(active_connections, 1, "active_connections after 1 connection")
-c1 = net.box.connect(HOST, PORT)
+local c1 = net.box.connect(HOST, PORT)
 while active_connections < 2 do fiber.sleep(0.001) end
 test:is(active_connections, 2, "active_connections after 2 connection")
 c:close()
@@ -95,14 +96,14 @@ session.on_disconnect(nil, dec)
 session.on_disconnect(nil, peer)
 
 -- write audit trail of connect/disconnect into a space
-function audit_connect() box.space['tweedledum']:insert{session.id()} end
-function audit_disconnect() box.space['tweedledum']:delete{session.id()} end
+local function audit_connect() box.space['tweedledum']:insert{session.id()} end
+local function audit_disconnect() box.space['tweedledum']:delete{session.id()} end
 test:is(type(session.on_connect(audit_connect)), "function", "type of trigger audit_connect on_connect")
 test:is(type(session.on_disconnect(audit_disconnect)), "function", "type of trigger audit_connect on_disconnect")
 
 box.schema.user.grant('guest', 'read,write', 'space', 'tweedledum')
 box.schema.user.grant('guest', 'execute', 'universe')
-a = net.box.connect(HOST, PORT)
+local a = net.box.connect(HOST, PORT)
 test:ok(a:eval('return space:get{box.session.id()}[1] == session.id()'), "eval get_id")
 test:ok(a:eval('return session.sync() ~= 0'), "eval sync")
 a:close()
@@ -122,15 +123,15 @@ box.schema.user.revoke('guest', 'execute', 'universe')
 -- audit permission in on_connect/on_disconnect triggers
 box.schema.user.create('tester', { password = 'tester' })
 
-on_connect_user = nil
-on_disconnect_user = nil
-function on_connect() on_connect_user = box.session.effective_user() end
-function on_disconnect() on_disconnect_user = box.session.effective_user() end
+local on_connect_user = nil
+local on_disconnect_user = nil
+local function on_connect() on_connect_user = box.session.effective_user() end
+local function on_disconnect() on_disconnect_user = box.session.effective_user() end
 _ = box.session.on_connect(on_connect)
 _ = box.session.on_disconnect(on_disconnect)
 local conn = require('net.box').connect("tester:tester@" ..HOST..':'..PORT)
 -- Triggers must not lead to privilege escalation
-ok, err = pcall(function () conn:eval('box.space._user:select()') end)
+local ok, _ = pcall(function () conn:eval('box.space._user:select()') end)
 test:ok(not ok, "check access")
 conn:close()
 conn = nil
@@ -143,13 +144,13 @@ box.session.on_connect(nil, on_connect)
 box.session.on_disconnect(nil, on_disconnect)
 
 -- check Session privilege
-ok, err = pcall(function() net.box.connect("tester:tester@" ..HOST..':'..PORT) end)
+ok, _ = pcall(function() net.box.connect("tester:tester@" ..HOST..':'..PORT) end)
 test:ok(ok, "session privilege")
 box.schema.user.revoke('tester', 'session', 'universe')
 conn = net.box.connect("tester:tester@" ..HOST..':'..PORT)
 test:is(conn.state, "error", "session privilege state")
 test:ok(conn.error:match("Session"), "sesssion privilege errmsg")
-ok, err = pcall(box.session.su, "user1")
+ok, _ = pcall(box.session.su, "user1")
 test:ok(not ok, "session.su on revoked")
 box.schema.user.drop('tester')
 
@@ -163,7 +164,7 @@ test:is(
     inspector:cmd('start server session'),
     true, 'instance started'
 )
-local uri = inspector:eval('session', 'box.cfg.listen')[1]
+uri = inspector:eval('session', 'box.cfg.listen')[1]
 conn = net.box.connect(uri)
 test:ok(conn:eval("return box.session.exists(box.session.id())"), "remote session exist check")
 test:isnt(conn:eval("return box.session.peer(box.session.id())"), nil, "remote session peer check")
@@ -187,7 +188,7 @@ conn:close()
 --
 -- gh-3450: box.session.sync() becomes request local.
 --
-cond = fiber.cond()
+local cond = fiber.cond()
 local sync1, sync2
 local started = 0
 function f1()
diff --git a/test/box-tap/trigger_atexit.test.lua b/test/box-tap/trigger_atexit.test.lua
index 59b47aa6a..8baa868c4 100755
--- a/test/box-tap/trigger_atexit.test.lua
+++ b/test/box-tap/trigger_atexit.test.lua
@@ -3,11 +3,9 @@
 
 -- see https://github.com/tarantool/tarantool/issues/583
 
-tap = require 'tap'
-fio = require 'fio'
-log = require 'log'
+local fio = require 'fio'
 
-tempdir = fio.tempdir()
+local tempdir = fio.tempdir()
 
 box.cfg {
     wal_dir = tempdir,
@@ -17,7 +15,7 @@ box.cfg {
     memtx_memory = 104857600 -- for small systems
 }
 
-local function test_replace(old_tuple, new_tuple)
+local function test_replace()
 
 end
 
@@ -27,7 +25,7 @@ box.space.abc:create_index('pk', { type = 'tree' })
 box.space.abc:on_replace(test_replace)
 
 
-cleanup_list = fio.glob(fio.pathjoin(tempdir, '*'))
+local cleanup_list = fio.glob(fio.pathjoin(tempdir, '*'))
 for _, file in pairs(cleanup_list) do
     fio.unlink(file)
 end
diff --git a/test/box-tap/trigger_yield.test.lua b/test/box-tap/trigger_yield.test.lua
index 5d02fea3a..10fca632c 100755
--- a/test/box-tap/trigger_yield.test.lua
+++ b/test/box-tap/trigger_yield.test.lua
@@ -5,21 +5,21 @@ box.cfg{
     log = "tarantool.log"
 }
 
-fiber = require('fiber')
+local fiber = require('fiber')
 
 box.schema.space.create('test')
 box.space.test:create_index('pk')
 
 box.space.test:truncate()
 
-function fail() fiber.sleep(0.0001) error("fail") end
+local function fail() fiber.sleep(0.0001) error("fail") end
 
 box.space.test:on_replace(fail)
 
-function insert() box.space.test:auto_increment{fiber.id()} end
+local function insert() box.space.test:auto_increment{fiber.id()} end
 
-fibers = {}
-for i = 1, 100 do
+local fibers = {}
+for _ = 1, 100 do
     table.insert(fibers, fiber.create(insert))
 end
 
diff --git a/test/box/box.lua b/test/box/box.lua
index 6fad07015..2cf399f96 100644
--- a/test/box/box.lua
+++ b/test/box/box.lua
@@ -1,5 +1,5 @@
 #!/usr/bin/env tarantool
-os = require('os')
+local os = require('os')
 
 local msgpack = require('msgpack')
 
diff --git a/test/box/hash_multipart.result b/test/box/hash_multipart.result
index e94313b62..e6915652f 100644
--- a/test/box/hash_multipart.result
+++ b/test/box/hash_multipart.result
@@ -62,7 +62,7 @@ test_run:cmd("setopt delimiter ';'")
 function select_all()
     local result = {}
     local tuple, v
-    for tuple, v in hash:pairs() do
+    for _, v in hash:pairs() do
         table.insert(result, v)
     end
     return result
diff --git a/test/box/hash_multipart.test.lua b/test/box/hash_multipart.test.lua
index c0a871bee..c572d13b6 100644
--- a/test/box/hash_multipart.test.lua
+++ b/test/box/hash_multipart.test.lua
@@ -24,7 +24,7 @@ test_run:cmd("setopt delimiter ';'")
 function select_all()
     local result = {}
     local tuple, v
-    for tuple, v in hash:pairs() do
+    for _, v in hash:pairs() do
         table.insert(result, v)
     end
     return result
diff --git a/test/box/lua/bitset.lua b/test/box/lua/bitset.lua
index 41d2c3681..948bf3710 100644
--- a/test/box/lua/bitset.lua
+++ b/test/box/lua/bitset.lua
@@ -1,8 +1,5 @@
 local utils = require('utils')
 
-local SPACE_NO = 0 
-local INDEX_NO = 1
-
 function create_space()
     local space = box.schema.create_space('tweedledum')
     space:create_index('primary', { type = 'hash', parts = {1, 'unsigned'}, unique = true })
@@ -13,7 +10,7 @@ function fill(...)
     local space = box.space['tweedledum']
     local nums = utils.table_generate(utils.arithmetic(...))
     utils.table_shuffle(nums)
-    for _k, v in ipairs(nums) do
+    for _, v in ipairs(nums) do
         space:insert{v, v}
     end
 end
@@ -22,7 +19,7 @@ function delete(...)
     local space = box.space['tweedledum']
     local nums = utils.table_generate(utils.arithmetic(...))
     utils.table_shuffle(nums)
-    for _k, v in ipairs(nums) do
+    for _, v in ipairs(nums) do
         space:delete{v}
     end
 end
diff --git a/test/box/lua/cfg_bad_vinyl_dir.lua b/test/box/lua/cfg_bad_vinyl_dir.lua
index 8e1a98dc8..82746b99a 100644
--- a/test/box/lua/cfg_bad_vinyl_dir.lua
+++ b/test/box/lua/cfg_bad_vinyl_dir.lua
@@ -1,5 +1,5 @@
 #!/usr/bin/env tarantool
-os = require('os')
+local os = require('os')
 
 box.cfg{
     listen              = os.getenv("LISTEN"),
diff --git a/test/box/lua/cfg_rtree.lua b/test/box/lua/cfg_rtree.lua
index f2d32ef7d..860cb14a8 100644
--- a/test/box/lua/cfg_rtree.lua
+++ b/test/box/lua/cfg_rtree.lua
@@ -1,5 +1,5 @@
 #!/usr/bin/env tarantool
-os = require('os')
+local os = require('os')
 box.error.injection.set("ERRINJ_INDEX_RESERVE", true)
 box.cfg{
     listen              = os.getenv("LISTEN"),
diff --git a/test/box/lua/cfg_test1.lua b/test/box/lua/cfg_test1.lua
index 60b7aff9a..aa026ed42 100644
--- a/test/box/lua/cfg_test1.lua
+++ b/test/box/lua/cfg_test1.lua
@@ -1,5 +1,5 @@
 #!/usr/bin/env tarantool
-os = require('os')
+local os = require('os')
 
 box.cfg{
     listen              = os.getenv("LISTEN"),
diff --git a/test/box/lua/cfg_test2.lua b/test/box/lua/cfg_test2.lua
index 2397f9c19..536661698 100644
--- a/test/box/lua/cfg_test2.lua
+++ b/test/box/lua/cfg_test2.lua
@@ -1,5 +1,5 @@
 #!/usr/bin/env tarantool
-os = require('os')
+local os = require('os')
 
 box.cfg{
     listen              = os.getenv("LISTEN"),
diff --git a/test/box/lua/cfg_test3.lua b/test/box/lua/cfg_test3.lua
index 6a6e544b6..4978900fb 100644
--- a/test/box/lua/cfg_test3.lua
+++ b/test/box/lua/cfg_test3.lua
@@ -1,5 +1,5 @@
 #!/usr/bin/env tarantool
-os = require('os')
+local os = require('os')
 
 box.cfg{
     listen              = os.getenv("LISTEN"),
diff --git a/test/box/lua/cfg_test4.lua b/test/box/lua/cfg_test4.lua
index 82dab8757..21a38f95c 100644
--- a/test/box/lua/cfg_test4.lua
+++ b/test/box/lua/cfg_test4.lua
@@ -1,5 +1,5 @@
 #!/usr/bin/env tarantool
-os = require('os')
+local os = require('os')
 
 box.cfg{
     listen              = os.getenv("LISTEN"),
diff --git a/test/box/lua/cfg_test5.lua b/test/box/lua/cfg_test5.lua
index e3eb87392..8b6f9b31c 100644
--- a/test/box/lua/cfg_test5.lua
+++ b/test/box/lua/cfg_test5.lua
@@ -1,5 +1,5 @@
 #!/usr/bin/env tarantool
-os = require('os')
+local os = require('os')
 
 box.cfg{
     listen              = os.getenv("LISTEN"),
@@ -7,4 +7,4 @@ box.cfg{
 }
 
 require('console').listen(os.getenv('ADMIN'))
-box.schema.user.grant('guest', 'read,write,execute', 'universe')
\ No newline at end of file
+box.schema.user.grant('guest', 'read,write,execute', 'universe')
diff --git a/test/box/lua/cfg_test6.lua b/test/box/lua/cfg_test6.lua
index efcfc6f3e..0a5859bc5 100644
--- a/test/box/lua/cfg_test6.lua
+++ b/test/box/lua/cfg_test6.lua
@@ -1,5 +1,5 @@
 #!/usr/bin/env tarantool
-os = require('os')
+local os = require('os')
 
 box.cfg{
     listen = os.getenv("LISTEN"),
diff --git a/test/box/lua/fifo.lua b/test/box/lua/fifo.lua
index bb3446179..c9216cfde 100644
--- a/test/box/lua/fifo.lua
+++ b/test/box/lua/fifo.lua
@@ -4,7 +4,7 @@ function find_or_create_fifo(space, name)
     local fifo = space:get{name}
     if fifo == nil then
         fifo = {}
-        for i = 1, fifomax do table.insert(fifo, 0) end
+        for _ = 1, fifomax do table.insert(fifo, 0) end
         fifo = space:insert{name, 4, 4, unpack(fifo)}
     end
     return fifo
diff --git a/test/box/lua/identifier.lua b/test/box/lua/identifier.lua
index 0cfb9e722..c42840aaf 100644
--- a/test/box/lua/identifier.lua
+++ b/test/box/lua/identifier.lua
@@ -1,6 +1,6 @@
-max_len_string = string.rep('a', box.schema.NAME_MAX)
+local max_len_string = string.rep('a', box.schema.NAME_MAX)
 
-valid_testcases = {
+local valid_testcases = {
     --[[ Symbols from various unicode groups ,, --]]
     "1", "_", "sd", "я", "Ё",
     ".", "@", "#" , "⁋", "☢",
@@ -13,7 +13,7 @@ valid_testcases = {
     "⧭", "⭓", max_len_string
 }
 
-invalid_testcases = {
+local invalid_testcases = {
     --[[ Invalid and non printable unicode sequences --]]
     --[[ 1-3 ASCII control, C0 --]]
     "\x01", "\x09", "\x1f",
@@ -35,7 +35,6 @@ invalid_testcases = {
 }
 
 function run_test(create_func, cleanup_func)
-    local json = require("json")
     local bad_tests = {}
     for i, identifier in ipairs(valid_testcases) do
         local ok, res = pcall(create_func,identifier)
@@ -48,7 +47,7 @@ function run_test(create_func, cleanup_func)
         end
     end
     for i, identifier in ipairs(invalid_testcases) do
-        local ok, res = pcall(create_func,identifier)
+        local ok, _ = pcall(create_func,identifier)
         if ok then
             table.insert(bad_tests, "invalid_testcases: "..i)
         end
diff --git a/test/box/lua/index_random_test.lua b/test/box/lua/index_random_test.lua
index 7b5256a7c..83e230216 100644
--- a/test/box/lua/index_random_test.lua
+++ b/test/box/lua/index_random_test.lua
@@ -7,7 +7,7 @@ function index_random_test(space, index_no)
 	-- insert values into the index
 	for k=1,COUNT,1 do space:insert{k}  end
 	-- delete some values from the index
-	for i=1,COUNT/2,1 do
+	for _=1,COUNT/2,1 do
 		local k = math.random(COUNT)
 		local tuple = space:delete{k}
 		if tuple ~= nil then COUNT = COUNT - 1 end
diff --git a/test/box/lua/require_init.lua b/test/box/lua/require_init.lua
index c9ab07dce..8a2b477cc 100644
--- a/test/box/lua/require_init.lua
+++ b/test/box/lua/require_init.lua
@@ -1,5 +1,2 @@
 #!/usr/bin/env tarantool
 box.load_cfg()
-mod = require("require_mod")
-package_path = package.path
-package_cpath = package.cpath
diff --git a/test/box/lua/test_init.lua b/test/box/lua/test_init.lua
index 88cc3acdc..3823a0d13 100644
--- a/test/box/lua/test_init.lua
+++ b/test/box/lua/test_init.lua
@@ -1,15 +1,15 @@
 #!/usr/bin/env tarantool
 box.load_cfg()
 -- testing start-up script
-floor = require("math").floor
+require("math").floor
 
 --
 -- Access to box.cfg from start-up script
 --
 
-box_cfg = box.cfg()
+local box_cfg = box.cfg()
 
-function print_config()
+local function print_config()
 	return box_cfg
 end
 
@@ -24,10 +24,10 @@ local function do_insert()
     box.space[0]:insert{1, 2, 4, 8}
 end
 
-space = box.schema.create_space('tweedledum', { id = 0 })
+local space = box.schema.create_space('tweedledum', { id = 0 })
 space:create_index('primary', { type = 'hash' })
 
-fiber = box.fiber.create(do_insert)
+local fiber = box.fiber.create(do_insert)
 box.fiber.resume(fiber)
 
 --
diff --git a/test/box/lua/utils.lua b/test/box/lua/utils.lua
index 5f859fd19..fd562b767 100644
--- a/test/box/lua/utils.lua
+++ b/test/box/lua/utils.lua
@@ -22,8 +22,7 @@ function iterate(space_no, index_no, f1, f2, iterator, ...)
 			return f
 		end
 	end
-	local state, v
-	for state, v in box.space[space_no].index[index_no]:pairs({...}, { iterator = iterator }) do
+	for _, v in box.space[space_no].index[index_no]:pairs({...}, { iterator = iterator }) do
 		local pk = get_field(v, 1);
 		local tk = '$';
 		for f = f1 + 1, f2, 1 do tk = (tk..(get_field(v, f))..'$'); end;
@@ -90,7 +89,7 @@ end;
 
 -- return string tuple
 function tuple_to_string(tuple, yaml)
-    ans = '['
+    local ans = '['
     for i = 0, #tuple - 1 do
         if #i == 4 then
             ans = ans..i
@@ -205,17 +204,17 @@ function space_bsize(s)
 end
 
 function create_iterator(obj, key, opts)
-    local iter, key, state = obj:pairs(key, opts)
+    local iter, state
+    iter, key, state = obj:pairs(key, opts)
     local res = {iter = iter, key = key, state = state}
     res.next = function()
-        local st, tp = iter.gen(key, state)
+        local _, tp = iter.gen(key, state)
         return tp
     end
     res.iterate_over = function()
-        local tp = nil
         local ret = {}
         local i = 0
-        tp = res.next()
+        local tp = res.next()
         while tp do
             ret[i] = tp
             i = i + 1
diff --git a/test/box/on_schema_init.lua b/test/box/on_schema_init.lua
index 17cf89166..f74d6d7fe 100644
--- a/test/box/on_schema_init.lua
+++ b/test/box/on_schema_init.lua
@@ -1,5 +1,5 @@
 #!/usr/bin/env tarantool
-os = require('os')
+local os = require('os')
 
 function test_before_replace_trig(old, new)
     -- return multiple values so that the stack fills earlier.
diff --git a/test/box/proxy.lua b/test/box/proxy.lua
index 8bbd505f8..c763e9634 100644
--- a/test/box/proxy.lua
+++ b/test/box/proxy.lua
@@ -1,5 +1,5 @@
 #!/usr/bin/env tarantool
-os = require('os')
+local os = require('os')
 
 box.cfg{
     listen              = os.getenv("LISTEN"),
diff --git a/test/box/tiny.lua b/test/box/tiny.lua
index 04b523fb2..608d48366 100644
--- a/test/box/tiny.lua
+++ b/test/box/tiny.lua
@@ -1,5 +1,5 @@
 #!/usr/bin/env tarantool
-os = require('os')
+local os = require('os')
 
 box.cfg{
     listen              = os.getenv("LISTEN"),
diff --git a/test/box/tree_pk.result b/test/box/tree_pk.result
index df3c78bed..f2a4f5352 100644
--- a/test/box/tree_pk.result
+++ b/test/box/tree_pk.result
@@ -153,8 +153,8 @@ test_run:cmd("setopt delimiter ';'")
 ...
 function crossjoin(space0, space1, limit)
     local result = {}
-    for state, v0 in space0:pairs() do
-        for state, v1 in space1:pairs() do
+    for _, v0 in space0:pairs() do
+        for _, v1 in space1:pairs() do
             if limit <= 0 then
                 return result
             end
diff --git a/test/box/tree_pk.test.lua b/test/box/tree_pk.test.lua
index 1190ab424..86041a642 100644
--- a/test/box/tree_pk.test.lua
+++ b/test/box/tree_pk.test.lua
@@ -58,8 +58,8 @@ test_run = env.new()
 test_run:cmd("setopt delimiter ';'")
 function crossjoin(space0, space1, limit)
     local result = {}
-    for state, v0 in space0:pairs() do
-        for state, v1 in space1:pairs() do
+    for _, v0 in space0:pairs() do
+        for _, v1 in space1:pairs() do
             if limit <= 0 then
                 return result
             end
diff --git a/test/engine/box.lua b/test/engine/box.lua
index e2f04cba2..8558c9ac0 100644
--- a/test/engine/box.lua
+++ b/test/engine/box.lua
@@ -1,11 +1,5 @@
 #!/usr/bin/env tarantool
-os = require('os')
-
-local vinyl = {
-    threads = 3,
-    range_size=1024*64,
-    page_size=1024,
-}
+local os = require('os')
 
 box.cfg{
     listen              = os.getenv("LISTEN"),
diff --git a/test/engine/conflict.lua b/test/engine/conflict.lua
index b757b81d2..56c70f6ff 100644
--- a/test/engine/conflict.lua
+++ b/test/engine/conflict.lua
@@ -5,7 +5,7 @@ function test_conflict()
     local engine = inspector:get_cfg('engine')
 
     local s = box.schema.space.create('tester', {engine=engine});
-    local i = s:create_index('test_index', {type = 'tree', parts = {1, 'string'}});
+    s:create_index('test_index', {type = 'tree', parts = {1, 'string'}});
 
     local commits = 0
     local function conflict()
@@ -16,8 +16,8 @@ function test_conflict()
     end;
 
     local fiber = require('fiber');
-    local f0 = fiber.create(conflict);
-    local f1 = fiber.create(conflict); -- conflict
+    fiber.create(conflict);
+    fiber.create(conflict); -- conflict
     fiber.sleep(0);
 
     s:drop();
diff --git a/test/engine/tree_min_max_count.result b/test/engine/tree_min_max_count.result
index f55732aa6..9f1595a20 100644
--- a/test/engine/tree_min_max_count.result
+++ b/test/engine/tree_min_max_count.result
@@ -1189,7 +1189,7 @@ space6:drop()
 ---
 ...
 -- min max count after many inserts
-string = require('string')
+local string = require('string')
 ---
 ...
 space7 = box.schema.space.create('space7', { engine = engine })
diff --git a/test/engine/tree_min_max_count.test.lua b/test/engine/tree_min_max_count.test.lua
index 0633c56b3..19b5fe92d 100644
--- a/test/engine/tree_min_max_count.test.lua
+++ b/test/engine/tree_min_max_count.test.lua
@@ -337,7 +337,7 @@ space6:drop()
 
 -- min max count after many inserts
 
-string = require('string')
+local string = require('string')
 
 space7 = box.schema.space.create('space7', { engine = engine })
 index7 = space7:create_index('primary', { type = 'tree', parts = {1, 'scalar'} })
diff --git a/test/engine_long/suite.lua b/test/engine_long/suite.lua
index 9ac2bff9f..6fe25472c 100644
--- a/test/engine_long/suite.lua
+++ b/test/engine_long/suite.lua
@@ -2,7 +2,7 @@ local function string_function()
     local random_number
     local random_string
     random_string = ""
-    for x = 1,20,1 do
+    for _ = 1,20,1 do
         random_number = math.random(65, 90)
         random_string = random_string .. string.char(random_number)
     end
@@ -10,7 +10,6 @@ local function string_function()
 end
 
 function delete_replace_update(engine_name, iterations)
-    local string_value
     if (box.space._space.index.name:select{'tester'}[1] ~= nil) then
         box.space.tester:drop()
     end
@@ -69,7 +68,6 @@ function delete_replace_update(engine_name, iterations)
 end
 
 function delete_insert(engine_name, iterations)
-    local string_value
     if (box.space._space.index.name:select{'tester'}[1] ~= nil) then
         box.space.tester:drop()
     end
diff --git a/test/long_run-py/lua/finalizers.lua b/test/long_run-py/lua/finalizers.lua
index 69146a323..cb6400363 100644
--- a/test/long_run-py/lua/finalizers.lua
+++ b/test/long_run-py/lua/finalizers.lua
@@ -1,19 +1,17 @@
 #!/usr/bin/env tarantool
 
-function on_gc(t)
+local function on_gc()
 end;
 
-function test_finalizers()
+local function test_finalizers()
     local result = {}
     local i = 1
     local ffi = require('ffi')
     while true do
-        result[i] = ffi.gc(ffi.cast('void *', 0), on_gc)
+        local result[i] = ffi.gc(ffi.cast('void *', 0), on_gc)
         i = i + 1
     end
-    return "done"
 end;
 
 test_finalizers()
 test_finalizers()
-
diff --git a/test/long_run-py/suite.lua b/test/long_run-py/suite.lua
index 0b33dec7d..c2ea97279 100644
--- a/test/long_run-py/suite.lua
+++ b/test/long_run-py/suite.lua
@@ -1,9 +1,9 @@
 
-function string_function()
+local function string_function()
     local random_number
     local random_string
     random_string = ""
-    for x = 1,20,1 do
+    for _ = 1,20,1 do
         random_number = math.random(65, 90)
         random_string = random_string .. string.char(random_number)
     end
@@ -11,7 +11,6 @@ function string_function()
 end
 
 function delete_replace_update(engine_name)
-    local string_value
     if (box.space._space.index.name:select{'tester'}[1] ~= nil) then
         box.space.tester:drop()
     end
@@ -72,7 +71,6 @@ function delete_replace_update(engine_name)
 end
 
 function delete_insert(engine_name)
-    local string_value
     if (box.space._space.index.name:select{'tester'}[1] ~= nil) then
         box.space.tester:drop()
     end
diff --git a/test/replication-py/master.lua b/test/replication-py/master.lua
index e924b5495..b43bafd54 100644
--- a/test/replication-py/master.lua
+++ b/test/replication-py/master.lua
@@ -1,5 +1,5 @@
 #!/usr/bin/env tarantool
-os = require('os')
+local os = require('os')
 box.cfg({
     listen              = os.getenv("LISTEN"),
     memtx_memory        = 107374182,
diff --git a/test/replication-py/panic.lua b/test/replication-py/panic.lua
index 75a738cbb..e72d11419 100644
--- a/test/replication-py/panic.lua
+++ b/test/replication-py/panic.lua
@@ -1,5 +1,5 @@
 #!/usr/bin/env tarantool
-os = require('os')
+local os = require('os')
 box.cfg({
     listen              = os.getenv("LISTEN"),
     memtx_memory        = 107374182,
diff --git a/test/replication-py/replica.lua b/test/replication-py/replica.lua
index 32d888eff..a5fa292d2 100644
--- a/test/replication-py/replica.lua
+++ b/test/replication-py/replica.lua
@@ -1,6 +1,4 @@
 #!/usr/bin/env tarantool
-box_cfg_done = false
-
 require('console').listen(os.getenv('ADMIN'))
 
 box.cfg({
@@ -9,5 +7,3 @@ box.cfg({
     memtx_memory        = 107374182,
     replication_timeout = 0.1
 })
-
-box_cfg_done = true
diff --git a/test/replication/lua/fast_replica.lua b/test/replication/lua/fast_replica.lua
index 8c772c41f..68148d6a0 100644
--- a/test/replication/lua/fast_replica.lua
+++ b/test/replication/lua/fast_replica.lua
@@ -7,7 +7,8 @@ function join(inspector, n)
         os.execute('cp '..path..'/test/replication/replica.lua ./tmp/replica'..rid..'.lua')
         os.execute('chmod +x ./tmp/replica'..rid..'.lua')
         local out_dir = box.cfg.wal_dir
-        inspector:cmd("create server replica"..rid.." with rpl_master=default, script='"..out_dir.."/../tmp/replica"..rid..".lua'")
+        inspector:cmd("create server replica"..rid.." with rpl_master=default, script='"
+			..out_dir.."/../tmp/replica"..rid..".lua'")
         inspector:cmd("start server replica"..rid)
     end
 end
diff --git a/test/replication/lua/rlimit.lua b/test/replication/lua/rlimit.lua
index de9f86a35..1bd9e333f 100644
--- a/test/replication/lua/rlimit.lua
+++ b/test/replication/lua/rlimit.lua
@@ -1,5 +1,5 @@
 
-ffi = require('ffi')
+local ffi = require('ffi')
 pcall(ffi.cdef, [[
 typedef long rlim_t;
 struct rlimit {
diff --git a/test/replication/master.lua b/test/replication/master.lua
index e924b5495..b43bafd54 100644
--- a/test/replication/master.lua
+++ b/test/replication/master.lua
@@ -1,5 +1,5 @@
 #!/usr/bin/env tarantool
-os = require('os')
+local os = require('os')
 box.cfg({
     listen              = os.getenv("LISTEN"),
     memtx_memory        = 107374182,
diff --git a/test/replication/master_quorum.lua b/test/replication/master_quorum.lua
index 20f161cc0..8b7ddc5eb 100644
--- a/test/replication/master_quorum.lua
+++ b/test/replication/master_quorum.lua
@@ -26,8 +26,8 @@ box.cfg({
     replication_timeout = TIMEOUT;
 })
 
-test_run = require('test_run').new()
-engine = test_run:get_cfg('engine')
+local test_run = require('test_run').new()
+local engine = test_run:get_cfg('engine')
 
 box.once("bootstrap", function()
     box.schema.user.grant("guest", 'replication')
diff --git a/test/replication/on_replace.lua b/test/replication/on_replace.lua
index 71e63d3f9..df65832c4 100644
--- a/test/replication/on_replace.lua
+++ b/test/replication/on_replace.lua
@@ -15,9 +15,9 @@ end
 
 -- start console first
 require('console').listen(os.getenv('ADMIN'))
-env = require('test_run')
-test_run = env.new()
-engine = test_run:get_cfg('engine')
+local env = require('test_run')
+local test_run = env.new()
+local engine = test_run:get_cfg('engine')
 
 box.cfg({
     listen = instance_uri(INSTANCE_ID);
diff --git a/test/replication/replica.lua b/test/replication/replica.lua
index f3a6dfe58..6bf8060e2 100644
--- a/test/replication/replica.lua
+++ b/test/replication/replica.lua
@@ -1,7 +1,7 @@
 #!/usr/bin/env tarantool
 
-repl_include_self = arg[1] and arg[1] == 'true' or false
-repl_list = nil
+local repl_include_self = arg[1] and arg[1] == 'true' or false
+local repl_list
 
 if repl_include_self then
     repl_list = {os.getenv("MASTER"), os.getenv("LISTEN")}
diff --git a/test/replication/replica_on_schema_init.lua b/test/replication/replica_on_schema_init.lua
index 8a221681b..8138c9715 100644
--- a/test/replication/replica_on_schema_init.lua
+++ b/test/replication/replica_on_schema_init.lua
@@ -1,12 +1,12 @@
 #!/usr/bin/env tarantool
 
-function trig_local(old, new)
+function trig_local(old, new) -- luacheck: ignore
     if new and new[3] == 'test_local' and new[6]['group_id'] ~= 1 then
         return new:update{{'=', 6, {group_id = 1}}}
     end
 end
 
-function trig_engine(old, new)
+function trig_engine(old, new) -- luacheck: ignore
     if new and new[3] == 'test_engine' and new[4] ~= 'vinyl' then
         return new:update{{'=', 4, 'vinyl'}}
     end
diff --git a/test/replication/replicaset_ro_mostly.result b/test/replication/replicaset_ro_mostly.result
index a471779d3..e509e0da0 100644
--- a/test/replication/replicaset_ro_mostly.result
+++ b/test/replication/replicaset_ro_mostly.result
@@ -35,7 +35,7 @@ test_run:cmd("setopt delimiter ';'")
 - true
 ...
 function create_cluster_uuid(servers, uuids)
-    for i, name in ipairs(servers) do
+    for _, name in ipairs(servers) do
         test_run:cmd(create_cluster_cmd1:format(name, name))
     end
     for i, name in ipairs(servers) do
diff --git a/test/replication/replicaset_ro_mostly.test.lua b/test/replication/replicaset_ro_mostly.test.lua
index 19cd1fe4a..e06e29c8e 100644
--- a/test/replication/replicaset_ro_mostly.test.lua
+++ b/test/replication/replicaset_ro_mostly.test.lua
@@ -16,7 +16,7 @@ create_cluster_cmd2 = 'start server %s with args="%s", wait_load=False, wait=Fal
 
 test_run:cmd("setopt delimiter ';'")
 function create_cluster_uuid(servers, uuids)
-    for i, name in ipairs(servers) do
+    for _, name in ipairs(servers) do
         test_run:cmd(create_cluster_cmd1:format(name, name))
     end
     for i, name in ipairs(servers) do
diff --git a/test/sql-tap/alter.test.lua b/test/sql-tap/alter.test.lua
index 615b9d8a6..4983b711c 100755
--- a/test/sql-tap/alter.test.lua
+++ b/test/sql-tap/alter.test.lua
@@ -90,7 +90,7 @@ test:do_catchsql_test(
 test:do_test(
     "alter-2.3.prepare",
     function()
-        format = {}
+        local format = {}
         format[1] = { name = 'id', type = 'integer'}
         format[2] = { name = 'f2', type = 'number'}
         s = box.schema.create_space('t', {format = format})
@@ -520,7 +520,7 @@ test:do_catchsql_test(
 test:do_test(
     "alter-8.1.0",
     function()
-        format = {}
+        local format = {}
         format[1] = { name = 'id', type = 'scalar'}
         format[2] = { name = 'f2', type = 'scalar'}
         s = box.schema.create_space('T', {format = format})
diff --git a/test/sql-tap/analyze3.test.lua b/test/sql-tap/analyze3.test.lua
index dcbea1da5..5c9c28601 100755
--- a/test/sql-tap/analyze3.test.lua
+++ b/test/sql-tap/analyze3.test.lua
@@ -23,15 +23,15 @@ testprefix = "analyze3"
 ------------------------------------------------------------------------
 -- Test Organization:
 --
--- analyze3-1.*: Test that the values of bound parameters are considered 
+-- analyze3-1.*: Test that the values of bound parameters are considered
 --               in the same way as constants when planning queries that
 --               use range constraints.
 --
--- analyze3-2.*: Test that the values of bound parameters are considered 
+-- analyze3-2.*: Test that the values of bound parameters are considered
 --               in the same way as constants when planning queries that
 --               use LIKE expressions in the WHERE clause.
 --
--- analyze3-3.*: Test that binding to a variable does not invalidate the 
+-- analyze3-3.*: Test that binding to a variable does not invalidate the
 --               query plan when there is no way in which replanning the
 --               query may produce a superior outcome.
 --
diff --git a/test/sql-tap/analyze5.test.lua b/test/sql-tap/analyze5.test.lua
index 45e76492a..0ea0ac07e 100755
--- a/test/sql-tap/analyze5.test.lua
+++ b/test/sql-tap/analyze5.test.lua
@@ -26,7 +26,7 @@ local function eqp(sql)
     return test:execsql("EXPLAIN QUERY PLAN"..sql)
 end
 
-local function alpha(blob)
+local function alpha()
     ret = ""
     for _, c in ipairs(X(37, "X!cmd", [=[["split",["blob"],""]]=])) do
         if X(39, "X!cmd", [=[["string","is","alpha",["c"]]]=])
diff --git a/test/sql-tap/analyze9.test.lua b/test/sql-tap/analyze9.test.lua
index 02eb49f69..7e8a88380 100755
--- a/test/sql-tap/analyze9.test.lua
+++ b/test/sql-tap/analyze9.test.lua
@@ -160,7 +160,7 @@ end
 box.internal.sql_create_function("lrange", "TEXT", lrange)
 
 generate_tens = function(n)
-    tens = {}
+    local tens = {}
     for i = 1, n do
         tens[i] = 10
     end
@@ -168,7 +168,7 @@ generate_tens = function(n)
 end
 
 generate_tens_str = function(n)
-    tens = {}
+    local tens = {}
     for i = 1, n do
         tens[i] = "10"
     end
@@ -239,7 +239,7 @@ test:do_execsql_test(
 insert_filler_rows_n = function(iStart, nCopy, nVal)
     for i = 0, nVal-1 do
         local iVal = iStart+i
-        for j = 0, nCopy-1 do
+        for _ = 0, nCopy-1 do
             box.execute(string.format("INSERT INTO t1 VALUES (null, %s, %s, '%s')", iVal, iVal, iVal))
         end
     end
@@ -416,7 +416,7 @@ local get_pk = function (space, record)
     return pkey
 end
 
-local inject_stat_error_func = function (space_name)
+local inject_stat_error_func1 = function (space_name)
     local space = box.space[space_name]
     local record = space:select({"T1", "I1", nil}, {limit = 1})[1]
     space:delete(get_pk(space, record))
@@ -427,7 +427,7 @@ local inject_stat_error_func = function (space_name)
     return 0
 end
 
-box.internal.sql_create_function("inject_stat_error", "INT", inject_stat_error_func)
+box.internal.sql_create_function("inject_stat_error", "INT", inject_stat_error_func1)
 
 test:do_execsql_test(
     7.1,
@@ -609,7 +609,7 @@ test:do_execsql_test(
 test:do_test(
     "10.1.2",
     function()
-        local a = 0
+        local a
         for i = 1, 100 do
             if i > 90 then
                 a = i
@@ -657,7 +657,7 @@ test:do_execsql_test(
 test:do_test(
     "10.2.2",
     function()
-        local a = 0
+        local a
         for i = 1, 100 do
             if i > 90 then
                 a = i
@@ -711,7 +711,7 @@ test:do_execsql_test(
 test:do_test(
     11.1,
     function()
-        local a = 0
+        local a
         for i = 0, 100 do
             if i % 10 == 0 then 
                 a = "\"ABC\""
@@ -762,7 +762,7 @@ test:do_execsql_test(
 test:do_test(
     11.5,
     function()
-        local a = 0
+        local a
         for i = 0, 100 do
             if i % 10 == 0 then 
                 a = "\"ABC\""
@@ -823,7 +823,7 @@ test:do_execsql_test(
 test:do_test(
     12.1,
     function()
-        local a = 0
+        local a
         for i = 0, 100 do
             if i % 10 == 0 then 
                 a = "\"ABC\""
@@ -874,7 +874,7 @@ test:do_execsql_test(
 test:do_test(
     12.5,
     function()
-        local a = 0
+        local a
         for i = 0, 100 do
             if i % 10 == 0 then 
                 a = "\"ABC\""
@@ -931,7 +931,7 @@ test:do_test(
         test:execsql("CREATE TABLE t1(id INTEGER PRIMARY KEY AUTOINCREMENT, a TEXT, b INT, c INT, d INT);")
         test:execsql("CREATE INDEX i1 ON t1(a);")
         test:execsql("CREATE INDEX i2 ON t1(b, c);")
-        local a = 0
+        local a
         for i = 0, 100 do
             if i % 2 == 1 then
                 a = "\"abc\""
@@ -1073,7 +1073,7 @@ test:do_execsql_test(
         -- </15.4>
     })
 
-local inject_stat_error_func = function (space_name)
+local inject_stat_error_func2 = function (space_name)
     local space = box.space[space_name]
     local stats = space:select()
     for _, stat in pairs(stats) do
@@ -1087,7 +1087,7 @@ local inject_stat_error_func = function (space_name)
     return 0
 end
 
-box.internal.sql_create_function("inject_stat_error", "INT", inject_stat_error_func)
+box.internal.sql_create_function("inject_stat_error", "INT", inject_stat_error_func2)
 
 
 test:do_execsql_test(
@@ -1161,7 +1161,7 @@ test:do_test(
             INSERT INTO t1 SELECT null, 2*a,2*b,2*c,d FROM t1;
             INSERT INTO t1 SELECT null, 2*a,2*b,2*c,d FROM t1;
         ]])
-        local b = 0
+        local b
         for i = 0, 31 do
             if (i < 8) then
                 b = 0
diff --git a/test/sql-tap/between.test.lua b/test/sql-tap/between.test.lua
index 60d9ae1d6..436106f83 100755
--- a/test/sql-tap/between.test.lua
+++ b/test/sql-tap/between.test.lua
@@ -60,11 +60,11 @@ local function queryplan(sql)
     table.insert(data,x)
     local eqp = box.execute("EXPLAIN QUERY PLAN "..sql.."").rows
     -- puts eqp=$eqp
-    for i, val in ipairs(eqp) do
+    for _, val in ipairs(eqp) do
         --local a = val[1]
         --local b = val[2]
         --local c = val[3]
-        local x = val[4]
+        x = val[4]
         local tab, idx = string.match(x, "TABLE (%w+) USING.* INDEX (%w+)")
 
         if tab then
diff --git a/test/sql-tap/date.test.lua b/test/sql-tap/date.test.lua
index 87fc80db0..794e5a3b6 100755
--- a/test/sql-tap/date.test.lua
+++ b/test/sql-tap/date.test.lua
@@ -2,6 +2,7 @@
 test = require("sqltester")
 -- test:plan(1279)
 test:plan(0)
+local enable_broken_tests = false
 
 --!./tcltestrunner.lua
 -- 2003 October 31
@@ -29,7 +30,7 @@ test:plan(0)
 
 -- Disabled until #3694 is resolved.
 --
-if false then
+if enable_broken_tests then
 local function datetest(tnum, expr, result)
     test:do_test(
         "date-"..tnum,
diff --git a/test/sql-tap/delete1.test.lua b/test/sql-tap/delete1.test.lua
index bfed3ba9d..7d7146715 100755
--- a/test/sql-tap/delete1.test.lua
+++ b/test/sql-tap/delete1.test.lua
@@ -132,7 +132,7 @@ test:do_test(
     })
 
 -- Tests for data dictionary integration.
-format = {}
+local format = {}
 format[1] = {name = 'id', type = 'scalar'}
 format[2] = {name = 'f', type = 'scalar'}
 s = box.schema.create_space('t', {format = format})
diff --git a/test/sql-tap/e_delete.test.lua b/test/sql-tap/e_delete.test.lua
index a0c944327..d1cf2a79f 100755
--- a/test/sql-tap/e_delete.test.lua
+++ b/test/sql-tap/e_delete.test.lua
@@ -1,5 +1,5 @@
 #!/usr/bin/env tarantool
-test = require("sqltester")
+local test = require("sqltester")
 test:plan(18)
 
 --!./tcltestrunner.lua
diff --git a/test/sql-tap/e_expr.test.lua b/test/sql-tap/e_expr.test.lua
index 7ee7a2d98..6df27401e 100755
--- a/test/sql-tap/e_expr.test.lua
+++ b/test/sql-tap/e_expr.test.lua
@@ -36,14 +36,14 @@ local function do_qexpr_test(tn, expr, value)
         {value })
 end
 
-local function matchfunc(a, b)
+local function matchfunc1(a, b)
     return (a == b)
 end
 
 local function regexfunc(a, b)
     return (a == b)
 end
-box.internal.sql_create_function("MATCH", "INT", matchfunc)
+box.internal.sql_create_function("MATCH", "INT", matchfunc1)
 box.internal.sql_create_function("REGEXP", "INT", regexfunc)
 
 -- Set up three global variables:
@@ -1077,7 +1077,7 @@ test:do_execsql_test(
 --
 -- MUST_WORK_TEST prepared statements
 if (0>0) then
-    local function parameter_test(tn, sql, params, result)
+    local function parameter_test(sql)
         stmt = sql_prepare_v2("db", sql, -1)
         for _ in X(0, "X!foreach", [=[["number name",["params"]]]=]) do
             nm = sql_bind_parameter_name(stmt, number)
@@ -1264,7 +1264,7 @@ test:do_execsql_test(
 test:execsql [[
     CREATE TABLE tblname(cname INT PRIMARY KEY);
 ]]
-local function glob(args)
+local function glob()
     return 1
 end
 
@@ -2121,7 +2121,7 @@ test:do_execsql_test(
 local likeargs = {}
 function likefunc(...)
     local args = {...}
-    for i, v in ipairs(args) do
+    for _, v in ipairs(args) do
         table.insert(likeargs, v)
     end
     return 1
@@ -2356,7 +2356,7 @@ end
 local regexpargs = {}
 local function regexpfunc(...)
     local args = {...}
-    for i, v in ipairs(args) do
+    for _, v in ipairs(args) do
         table.insert(regexpargs, v)
     end
     return 1
@@ -2413,14 +2413,14 @@ test:do_test(
 --
 
 local matchargs = {  }
-local function matchfunc(...)
+local function matchfunc2(...)
     local args = {...}
-    for i, v in ipairs(args) do
+    for _, v in ipairs(args) do
         table.insert(matchargs, v)
     end
     return 1
 end
-box.internal.sql_create_function("MATCH", "INT", matchfunc, 2)
+box.internal.sql_create_function("MATCH", "INT", matchfunc2, 2)
 
 test:do_execsql_test(
     "e_expr-19.2.1",
@@ -2905,9 +2905,9 @@ test:do_test(
 -- x=w1 THEN r1 WHEN x=w2 THEN r2 ELSE r3 END
 --
 local evalcount = 0
-local function ceval(x)
+local function ceval(t)
     evalcount = evalcount + 1
-    return x
+    return t
 end
 box.internal.sql_create_function("CEVAL", "BLOB", ceval)
 evalcount = 0
diff --git a/test/sql-tap/func.test.lua b/test/sql-tap/func.test.lua
index 3c088920f..eac930857 100755
--- a/test/sql-tap/func.test.lua
+++ b/test/sql-tap/func.test.lua
@@ -1472,7 +1472,7 @@ test:do_test(
 test:do_test(
     "func-17.1",
     function()
-        local function testfunc1(args)
+        local function testfunc1()
             X(768, "X!cmd", [=[["error","Error %d with %s percents %p"]]=])
         end
 
diff --git a/test/sql-tap/func3.test.lua b/test/sql-tap/func3.test.lua
index 95d96965e..a1d04ed94 100755
--- a/test/sql-tap/func3.test.lua
+++ b/test/sql-tap/func3.test.lua
@@ -288,19 +288,19 @@ test:do_test(
 --
 -- gh-3929: sql: ANSI aliases for LENGTH().
 --
-suits = {}
-suits[1] = {str = '123456789', len = 9}
-suits[2] = {str = '\x80', len = 1}
-suits[3] = {str = '\x61\x62\x63', len = 3}
-suits[4] = {str = '\x7f\x80\x81', len = 3}
-suits[5] = {str = '\x61\xc0', len = 2}
-suits[6] = {str = '\x61\xc0\x80\x80\x80\x80\x80\x80\x80\x80\x80\x80', len = 12}
-suits[7] = {str = '\xc0\x80\x80\x80\x80\x80\x80\x80\x80\x80\x80', len = 11}
-suits[8] = {str = '\x80\x80\x80\x80\x80\x80\x80\x80\x80\x80', len = 10}
-suits[9] = {str = '\x80\x80\x80\x80\x80\xf0\x80\x80\x80\x80', len = 7}
-suits[10] = {str = '\x80\x80\x80\x80\x80\xf0\x80\x80\x80\xff', len = 7}
+local suites = {}
+suites[1] = {str = '123456789', len = 9}
+suites[2] = {str = '\x80', len = 1}
+suites[3] = {str = '\x61\x62\x63', len = 3}
+suites[4] = {str = '\x7f\x80\x81', len = 3}
+suites[5] = {str = '\x61\xc0', len = 2}
+suites[6] = {str = '\x61\xc0\x80\x80\x80\x80\x80\x80\x80\x80\x80\x80', len = 12}
+suites[7] = {str = '\xc0\x80\x80\x80\x80\x80\x80\x80\x80\x80\x80', len = 11}
+suites[8] = {str = '\x80\x80\x80\x80\x80\x80\x80\x80\x80\x80', len = 10}
+suites[9] = {str = '\x80\x80\x80\x80\x80\xf0\x80\x80\x80\x80', len = 7}
+suites[10] = {str = '\x80\x80\x80\x80\x80\xf0\x80\x80\x80\xff', len = 7}
 
-for k,v in pairs(suits) do
+for k,v in pairs(suites) do
     test:do_execsql_test(
         "func3-6."..k,
         "SELECT CHAR_LENGTH('"..v.str.."'), CHARACTER_LENGTH('"..v.str.."');",
diff --git a/test/sql-tap/gh-2723-concurrency.test.lua b/test/sql-tap/gh-2723-concurrency.test.lua
index 842142d2d..4b8788ce2 100755
--- a/test/sql-tap/gh-2723-concurrency.test.lua
+++ b/test/sql-tap/gh-2723-concurrency.test.lua
@@ -20,7 +20,7 @@ for id = 1, N do
         end
     )
 end
-for id = 1, N do
+for _ = 1, N do
     ch:get()
 end
 
@@ -46,7 +46,7 @@ for id = 1, N do
         end
     )
 end
-for id = 1, N do
+for _ = 1, N do
     ch:get()
 end
 test:do_test(
@@ -64,7 +64,7 @@ box.execute("create index i1 on t1(b);")
 for id = 1, N*N do
     box.execute(string.format("insert into t1 values(%s, %s, 3)", id, id))
 end
-for id = 1, N do
+for _ = 1, N do
     fiber.create(
         function ()
             box.execute("delete from t1")
@@ -72,7 +72,7 @@ for id = 1, N do
         end
     )
 end
-for id = 1, N do
+for _ = 1, N do
     ch:get()
 end
 test:do_test(
diff --git a/test/sql-tap/gh-3083-ephemeral-unref-tuples.test.lua b/test/sql-tap/gh-3083-ephemeral-unref-tuples.test.lua
index 3807ba665..0e73a940f 100755
--- a/test/sql-tap/gh-3083-ephemeral-unref-tuples.test.lua
+++ b/test/sql-tap/gh-3083-ephemeral-unref-tuples.test.lua
@@ -12,7 +12,7 @@ test:do_test(
 			box.execute("insert into test(id, k) values(" .. i .. "," .. i .. ")")
 		end
 
-		for i = 1, 10000 do
+		for _ = 1, 10000 do
 			box.execute("SELECT id, k FROM test WHERE k IN (5849, 4986, 4997, 5020, 5044, 4990, 5013, 4983)")
 		end
 	end, {
diff --git a/test/sql-tap/gh-3307-xfer-optimization-issue.test.lua b/test/sql-tap/gh-3307-xfer-optimization-issue.test.lua
index bb8a4989e..c3dba4381 100755
--- a/test/sql-tap/gh-3307-xfer-optimization-issue.test.lua
+++ b/test/sql-tap/gh-3307-xfer-optimization-issue.test.lua
@@ -1,23 +1,23 @@
 #!/usr/bin/env tarantool
-test = require("sqltester")
+local test = require("sqltester")
 test:plan(39)
 
-local function do_xfer_test(test, test_func, test_name, func, exp, opts)
-    local opts = opts or {}
+local function do_xfer_test(test_query, test_func, test_name, func, exp, opts)
+    opts = opts or {}
     local exp_xfer_count = opts.exp_xfer_count
     local before = box.stat.sql().sql_xfer_count
-    test_func(test, test_name, func, exp)
+    test_func(test_query, test_name, func, exp)
     local after = box.stat.sql().sql_xfer_count
     test:is(after - before, exp_xfer_count,
                    test_name .. '-xfer-count')
 end
 
-test.do_execsql_xfer_test = function(test, test_name, func, exp, opts)
-    do_xfer_test(test, test.do_execsql_test, test_name, func, exp, opts)
+test.do_execsql_xfer_test = function(test_query, test_name, func, exp, opts)
+    do_xfer_test(test_query, test.do_execsql_test, test_name, func, exp, opts)
 end
 
-test.do_catchsql_xfer_test = function(test, test_name, func, exp, opts)
-    do_xfer_test(test, test.do_catchsql_test, test_name, func, exp, opts)
+test.do_catchsql_xfer_test = function(test_query, test_name, func, exp, opts)
+    do_xfer_test(test_query, test.do_catchsql_test, test_name, func, exp, opts)
 end
 
 test:do_catchsql_xfer_test(
diff --git a/test/sql-tap/gh-3332-tuple-format-leak.test.lua b/test/sql-tap/gh-3332-tuple-format-leak.test.lua
index 84e67b7ef..05c440e47 100755
--- a/test/sql-tap/gh-3332-tuple-format-leak.test.lua
+++ b/test/sql-tap/gh-3332-tuple-format-leak.test.lua
@@ -21,7 +21,7 @@ test:do_test(
 test:do_test(
     "format-leak",
     function()
-        for i = 1, 100000 do
+        for _ = 1, 100000 do
             box.execute("SELECT id FROM t1 WHERE flags=3 ORDER BY id LIMIT 2");
         end
     end, {
diff --git a/test/sql-tap/gh-4077-iproto-execute-no-bind.test.lua b/test/sql-tap/gh-4077-iproto-execute-no-bind.test.lua
index d4b597e35..2f71a68ea 100755
--- a/test/sql-tap/gh-4077-iproto-execute-no-bind.test.lua
+++ b/test/sql-tap/gh-4077-iproto-execute-no-bind.test.lua
@@ -41,10 +41,11 @@ local size = msgpack.encode(header:len() + body:len())
 sock:write(size .. header .. body)
 
 -- Read response.
-local size = msgpack.decode(sock:read(5))
+size = msgpack.decode(sock:read(5))
 local header_body = sock:read(size)
-local header, header_len = msgpack.decode(header_body)
-local body = msgpack.decode(header_body:sub(header_len))
+local header_len
+header, header_len = msgpack.decode(header_body)
+body = msgpack.decode(header_body:sub(header_len))
 sock:close()
 
 -- Verify response.
diff --git a/test/sql-tap/gh2127-indentifier-max-length.test.lua b/test/sql-tap/gh2127-indentifier-max-length.test.lua
index 46efffeed..e37281913 100755
--- a/test/sql-tap/gh2127-indentifier-max-length.test.lua
+++ b/test/sql-tap/gh2127-indentifier-max-length.test.lua
@@ -7,7 +7,7 @@ local tt = {}
 local table_word = "АААААААААА"
 
 -- Create 30kb table name
-for i=1,300 do
+for _=1,300 do
 	table.insert(tt, table_word)
 end
 
@@ -27,7 +27,7 @@ local vt = {}
 local view_word = "BBBBBBBBBB"
 
 -- Create 30kb view name
-for i=1, 300 do
+for _=1, 300 do
 	table.insert(vt, view_word)
 end
 
@@ -45,7 +45,7 @@ local it = {}
 local index_word = "ЕЕЕЕЕЕЕЕЕЕ"
 
 -- Create 30kb index name
-for i=1, 300 do
+for _=1, 300 do
 	table.insert(it, index_word)
 end
 
@@ -55,7 +55,7 @@ local field_table = {}
 local field_word = 'ДДДДДДДДД'
 
 -- Create 30kb field name
-for i=1, 300 do
+for _=1, 300 do
 	table.insert(field_table, field_word)
 end
 
@@ -75,7 +75,7 @@ test:do_execsql_test(
 local trig_table = {}
 local trigger_word = "ССССССССС"
 
-for i=1, 300 do
+for _=1, 300 do
 	table.insert(trig_table, trigger_word)
 end
 
diff --git a/test/sql-tap/identifier-characters.test.lua b/test/sql-tap/identifier-characters.test.lua
index 27ed2f889..65a738f5d 100755
--- a/test/sql-tap/identifier-characters.test.lua
+++ b/test/sql-tap/identifier-characters.test.lua
@@ -65,7 +65,7 @@ local testcases = {
 		test:execsql("commit")
 		if ok == false then error(res) end
 	end,
-	function (id) end},
+	function () end},
 	{"trigger name",
 		function (id)
 			test:execsql(string.format([[
diff --git a/test/sql-tap/index1.test.lua b/test/sql-tap/index1.test.lua
index e173e685c..f1394199e 100755
--- a/test/sql-tap/index1.test.lua
+++ b/test/sql-tap/index1.test.lua
@@ -106,7 +106,6 @@ test:do_test(
 test:do_test(
     "index-2.2",
     function()
-        local msg
         local v , msg= pcall(function()
             test:execsql("CREATE INDEX index1 ON test1(f1, f2, f4, f3)")
             end)
@@ -1019,7 +1018,7 @@ end
 test:do_test(
     "index-22.1.0",
     function()
-        format = {}
+        local format = {}
         format[1] = { name = 'id', type = 'scalar'}
         format[2] = { name = 'f2', type = 'scalar'}
         s = box.schema.create_space('T', {format = format})
diff --git a/test/sql-tap/index7.test.lua b/test/sql-tap/index7.test.lua
index c98f17218..4506fd97e 100755
--- a/test/sql-tap/index7.test.lua
+++ b/test/sql-tap/index7.test.lua
@@ -22,7 +22,7 @@ test:plan(12)
 
 -- Capture the output of a pragma in a TEMP table.
 --
-local function capture_pragma(db, tabname, sql)
+local function capture_pragma()
     once = 1
 end
 
diff --git a/test/sql-tap/join3.test.lua b/test/sql-tap/join3.test.lua
index 876b3121a..030fbaba3 100755
--- a/test/sql-tap/join3.test.lua
+++ b/test/sql-tap/join3.test.lua
@@ -49,7 +49,7 @@ for N=1, bitmask_size do
 end
 -- Joins with a comparison
 --
-local result = {}
+result = {}
 --for _ in X(0, "X!for", [=[["set N 1","$N<=$bitmask_size","incr N"]]=]) do
 for N=1, bitmask_size do
     table.insert(result,N)
diff --git a/test/sql-tap/lua-tables.test.lua b/test/sql-tap/lua-tables.test.lua
index 07e0f6a1e..16c89a8e8 100755
--- a/test/sql-tap/lua-tables.test.lua
+++ b/test/sql-tap/lua-tables.test.lua
@@ -5,7 +5,7 @@ test:plan(14)
 test:do_test(
     "lua-tables-prepare-1",
     function()
-        format = {}
+        local format = {}
         format[1] = { name = 'id', type = 'scalar'}
         format[2] = { name = 'f2', type = 'scalar'}
         s = box.schema.create_space('t', {format = format})
diff --git a/test/sql-tap/lua/sqltester.lua b/test/sql-tap/lua/sqltester.lua
index 9b0218e63..957da9746 100644
--- a/test/sql-tap/lua/sqltester.lua
+++ b/test/sql-tap/lua/sqltester.lua
@@ -9,7 +9,7 @@ local sql_tokenizer = require('sql_tokenizer')
 local ok, test_run = pcall(require, 'test_run')
 test_run = ok and test_run.new() or nil
 
-local function flatten(arr)
+local function flatten_func(array)
     local result = { }
 
     local function flatten(arr)
@@ -23,7 +23,7 @@ local function flatten(arr)
             end
         end
     end
-    flatten(arr)
+    flatten(array)
     return result
 end
 
@@ -118,7 +118,8 @@ end
 test.is_deeply_regex = is_deeply_regex
 
 local function do_test(self, label, func, expect)
-    local ok, result = pcall(func)
+    local result
+    ok, result = pcall(func)
     if ok then
         if result == nil then result = { } end
 
@@ -166,7 +167,7 @@ local function execsql(self, sql)
     local result = execsql_one_by_one(sql)
     if type(result) ~= 'table' then return end
 
-    result = flatten(result)
+    result = flatten_func(result)
     for i, c in ipairs(result) do
         if c == nil then
             result[i] = ""
@@ -176,8 +177,8 @@ local function execsql(self, sql)
 end
 test.execsql = execsql
 
-local function catchsql(self, sql, expect)
-    r = {pcall(execsql, self, sql) }
+local function catchsql(self, sql)
+    local r = {pcall(execsql, self, sql) }
     if r[1] == true then
         r[1] = 0
     else
@@ -256,7 +257,7 @@ end
 test.sortsql = sortsql
 
 local function catchsql2(self, sql)
-    r = {pcall(execsql2, self, sql) }
+    local r = {pcall(execsql2, self, sql) }
     -- 0 means ok
     -- 1 means not ok
     r[1] = r[1] == true and 0 or 1
@@ -271,8 +272,8 @@ test.catchsql2 = catchsql2
 -- opcode at the beginning.  This procedure can be used to prove
 -- that different SQL statements generate exactly the same VDBE code.
 local function explain_no_trace(self, sql)
-    tr = execsql(self, "EXPLAIN "..sql)
-    for i=1,8 do
+    local tr = execsql(self, "EXPLAIN "..sql)
+    for _=1,8 do
         table.remove(tr,1)
     end
     return tr
@@ -378,7 +379,6 @@ function test.randstr(Length)
     for Loop = 0, 255 do
         Chars[Loop+1] = string.char(Loop)
     end
-    local String = table.concat(Chars)
     local Result = {}
     local Lookup = Chars
     local Range = #Lookup
@@ -394,11 +394,11 @@ test.do_eqp_test = function (self, label, sql, result)
     test:do_test(
         label,
         function()
-            local result = execsql_one_by_one("EXPLAIN QUERY PLAN "..sql)
-            for k,v in pairs(result) do
-                result[k] = v:totable()
+            local res = execsql_one_by_one("EXPLAIN QUERY PLAN "..sql)
+            for k,v in pairs(res) do
+                res[k] = v:totable()
             end
-            return result
+            return res
         end,
         result)
 end
diff --git a/test/sql-tap/misc1.test.lua b/test/sql-tap/misc1.test.lua
index 32f38cc97..40b53b3d6 100755
--- a/test/sql-tap/misc1.test.lua
+++ b/test/sql-tap/misc1.test.lua
@@ -1,5 +1,5 @@
 #!/usr/bin/env tarantool
-test = require("sqltester")
+local test = require("sqltester")
 test:plan(59)
 
 --!./tcltestrunner.lua
@@ -583,7 +583,7 @@ if (0 > 0) then
             test:execsql("START TRANSACTION")
             test:execsql("UPDATE t1 SET a=0 WHERE 0")
             sql("db2", "test.db")
-            rc = X(371, "X!cmd", [=[["catch","db2 eval {SELECT count(*) FROM t1}","msg"]]=])
+            local rc = X(371, "X!cmd", [=[["catch","db2 eval {SELECT count(*) FROM t1}","msg"]]=])
             return table.insert(rc,msg) or rc
             -- v2 result: {1 {database is locked}}
         end, {
@@ -596,7 +596,7 @@ if (0 > 0) then
         "misc1-11.2",
         function()
             test:execsql("COMMIT")
-            rc = X(377, "X!cmd", [=[["catch","db2 eval {SELECT count(*) FROM t1}","msg"]]=])
+            local rc = X(377, "X!cmd", [=[["catch","db2 eval {SELECT count(*) FROM t1}","msg"]]=])
             db2("close")
             return table.insert(rc,msg) or rc
         end, {
@@ -726,7 +726,7 @@ test:do_execsql_test(
 -- MUST_WORK_TEST collate
 if 0>0 then
     db("collate", "numeric", "numeric_collate")
-    local function numeric_collate(lhs, rhs)
+    local function numeric_collate1(lhs, rhs)
         if (lhs == rhs)
         then
             return 0
@@ -736,7 +736,7 @@ if 0>0 then
 
     -- Mimic the sql 2 collation type TEXT.
     db("collate", "text", "text_collate")
-    local function numeric_collate(lhs, rhs)
+    local function numeric_collate2()
         return X(34, "X!cmd", [=[["string","compare",["lhs"],["rhs"]]]=])
     end
 
diff --git a/test/sql-tap/misc5.test.lua b/test/sql-tap/misc5.test.lua
index 2725e6782..7a8da91b4 100755
--- a/test/sql-tap/misc5.test.lua
+++ b/test/sql-tap/misc5.test.lua
@@ -291,7 +291,7 @@ test:do_test(
         test:execsql "CREATE TABLE t1(x  INT primary key)"
         sql = "INSERT INTO t1 VALUES("
         tail = ""
-        for i = 0, 199, 1 do
+        for _ = 0, 199, 1 do
             sql = sql .. "(1+"
             tail = tail .. ")"
         end
diff --git a/test/sql-tap/select1.test.lua b/test/sql-tap/select1.test.lua
index fbebfab37..4eb30e59e 100755
--- a/test/sql-tap/select1.test.lua
+++ b/test/sql-tap/select1.test.lua
@@ -1,6 +1,7 @@
 #!/usr/bin/env tarantool
 test = require("sqltester")
 test:plan(173)
+local enable_broken_tests = false
 
 function set_full_column_names(value)
     box.space._session_settings:update('sql_full_column_names', {
@@ -1178,7 +1179,7 @@ test:do_execsql2_test(
 test:do_test(
     "select1-6.9.7",
     function()
-        x = test:execsql2 [[
+        local x = test:execsql2 [[
             SELECT * FROM test1 a, (select 5, 6) LIMIT 1
         ]]
         for i, tmp in ipairs(x) do
@@ -1196,7 +1197,7 @@ test:do_test(
 test:do_test(
     "select1-6.9.8",
     function()
-        x = test:execsql2 [[
+        local x = test:execsql2 [[
             SELECT * FROM test1 a, (select 5 AS x, 6 AS y) AS b LIMIT 1
         ]]
         for i, tmp in ipairs(x) do
@@ -1512,8 +1513,7 @@ test:do_execsql_test(
 -- TODO: This test is failing because f1 is now being loaded off the
 -- disk as a vdbe integer, not a string. Hence the value of f1/(f1-11)
 -- changes because of rounding. Disable the test for now.
-if false
- then
+if enable_broken_tests then
     test:do_execsql_test(
         "select1-8.4",
         [[
@@ -1969,7 +1969,7 @@ test:do_test(
             START TRANSACTION;
             INSERT INTO abc VALUES(1, 1, 1);
         ]]
-        for i = 0,9,1 do
+        for _ = 0,9,1 do
             test:execsql [[
                 INSERT INTO abc SELECT a+(select max(a) FROM abc), b+(select max(a) FROM abc), c+(select max(a) FROM abc) FROM abc;
             ]]
diff --git a/test/sql-tap/select2.test.lua b/test/sql-tap/select2.test.lua
index 24fad2149..5c9e4cad5 100755
--- a/test/sql-tap/select2.test.lua
+++ b/test/sql-tap/select2.test.lua
@@ -37,8 +37,8 @@ test:do_test(
         local data = test:execsql "SELECT DISTINCT f1 FROM tbl1 ORDER BY f1"
         for _, f1 in ipairs(data) do
             table.insert(r, f1..":")
-            local data = test:execsql( string.format("SELECT f2 FROM tbl1 WHERE f1=%s ORDER BY f2", f1))
-            for _, f2 in ipairs(data) do
+            local d = test:execsql( string.format("SELECT f2 FROM tbl1 WHERE f1=%s ORDER BY f2", f1))
+            for _, f2 in ipairs(d) do
                 table.insert(r, f2)
             end
         end
@@ -56,8 +56,8 @@ test:do_test(
         local data = test:execsql "SELECT DISTINCT f1 FROM tbl1 WHERE f1>3 AND f1<5"
         for _, f1 in ipairs(data) do
             table.insert(r, f1..":")
-            local data = test:execsql( string.format("SELECT f2 FROM tbl1 WHERE f1=%s ORDER BY f2", f1))
-            for _, f2 in ipairs(data) do
+            local d = test:execsql( string.format("SELECT f2 FROM tbl1 WHERE f1=%s ORDER BY f2", f1))
+            for _, f2 in ipairs(d) do
                 table.insert(r, f2)
             end
         end
diff --git a/test/sql-tap/select4.test.lua b/test/sql-tap/select4.test.lua
index 23cf1bf1b..26f80d57e 100755
--- a/test/sql-tap/select4.test.lua
+++ b/test/sql-tap/select4.test.lua
@@ -30,7 +30,6 @@ test:execsql [[
     CREATE TABLE t1(n int primary key, log int);
     START TRANSACTION;
 ]]
-local i, j
 for i = 1, 31, 1 do
     j = 0
     while math.pow(2, j) < i do
diff --git a/test/sql-tap/select5.test.lua b/test/sql-tap/select5.test.lua
index d34de3139..309043448 100755
--- a/test/sql-tap/select5.test.lua
+++ b/test/sql-tap/select5.test.lua
@@ -27,7 +27,6 @@ test:execsql [[
     CREATE TABLE t1(x int primary key, y int);
     START TRANSACTION;
 ]]
-local i, j
 for i = 1, 31, 1 do
     j = 0
     while math.pow(2, j) < i do
diff --git a/test/sql-tap/select9.test.lua b/test/sql-tap/select9.test.lua
index 1ae16a658..3a432a7a7 100755
--- a/test/sql-tap/select9.test.lua
+++ b/test/sql-tap/select9.test.lua
@@ -1,5 +1,5 @@
 #!/usr/bin/env tarantool
-test = require("sqltester")
+local test = require("sqltester")
 test:plan(21157)
 -- it is bad idea to store 20k positive test results in git
 test.silent = true
@@ -60,10 +60,8 @@ function subrange(t, first, last)
 end
 
 local function test_compound_select(testname, sql, result)
-    local nCol = 1
     local A = box.execute(sql) --test.box(sql)
-    nCol = #A.metadata
-    A = A.rows
+    local nCol = #A.metadata
     local nRow = #result / nCol
     local compound_sql = sql
     test:do_execsql_test(
@@ -274,10 +272,8 @@ test:do_execsql_test(
         -- </select9-2.0>
     })
 
-local t1_space_id = ""
-local t2_space_id = ""
-t1_space_id = test:execsql([[SELECT * from "_space" where "name"='T1']])["id"]
-t2_space_id = test:execsql([[SELECT * from "_space" where "name"='T2']])["id"]
+local t1_space_id = test:execsql([[SELECT * from "_space" where "name"='T1']])["id"]
+local t2_space_id = test:execsql([[SELECT * from "_space" where "name"='T2']])["id"]
 --X(276, "X!cmd", [=[["db","eval","SELECT * from _space where name='t2'","data","\n  set t2_space_id $data(id)\n"]]=])
 --local function reverse(lhs, rhs)
 --    return X(283, "X!cmd", [=[["string","compare",["rhs"],["lhs"]]]=])
diff --git a/test/sql-tap/selectA.test.lua b/test/sql-tap/selectA.test.lua
index 5cc69ef61..d986f233e 100755
--- a/test/sql-tap/selectA.test.lua
+++ b/test/sql-tap/selectA.test.lua
@@ -78,9 +78,6 @@ test:do_execsql_test(
     })
 
 -- MUST_WORK_TEST
-if (0 > 0)
- then
-end
 test:do_execsql_test(
     "selectA-2.1",
     [[
@@ -2356,10 +2353,7 @@ test:do_execsql_test(
 --
 -- MUST_WORK_TEST
 -- TODO stored procedures are not supported by now
-if (0 > 0)
- then
-end
-local function f(args)
+local function f()
     return 1
 end
 
diff --git a/test/sql-tap/selectB.test.lua b/test/sql-tap/selectB.test.lua
index 56d4b9d1b..934aa2db9 100755
--- a/test/sql-tap/selectB.test.lua
+++ b/test/sql-tap/selectB.test.lua
@@ -26,11 +26,11 @@ local function test_transform(testname, sql1, sql2, results)
     local vdbe1 = {  }
     local vdbe2 = {  }
     local data = box.execute("explain "..sql1)
-    for i, line in ipairs(data) do
+    for _, line in ipairs(data) do
         table.insert(vdbe1, line[2])
     end
     data = box.execute("explain "..sql2)
-    for i, line in ipairs(data) do
+    for _, line in ipairs(data) do
         table.insert(vdbe2, line[2])
     end
     test:do_test(
@@ -211,10 +211,7 @@ test:do_execsql_test(
     })
 
 for ii = 3, 6, 1 do
-    if ii == 4 then
-        -- TODO
-        --X(2, "X!cmd", [=[["optimization_control","db","query-flattener","off"]]=])
-    elseif ii == 5 then
+    if ii == 5 then
         --X(2, "X!cmd", [=[["optimization_control","db","query-flattener","on"]]=])
         test:do_execsql_test(
             "selectB-5.0",
@@ -231,7 +228,10 @@ for ii = 3, 6, 1 do
                 -- </selectB-5.0>
             })
 
-    elseif ii == 6 then
+    --elseif ii == 4 then
+        -- TODO
+        --X(2, "X!cmd", [=[["optimization_control","db","query-flattener","off"]]=])
+    --elseif ii == 6 then
         --X(2, "X!cmd", [=[["optimization_control","db","query-flattener","off"]]=])
     end
     test:do_execsql_test(
diff --git a/test/sql-tap/selectG.test.lua b/test/sql-tap/selectG.test.lua
index 0ca066d1c..b1644190c 100755
--- a/test/sql-tap/selectG.test.lua
+++ b/test/sql-tap/selectG.test.lua
@@ -36,7 +36,6 @@ test:do_test(
     function()
         local sql_arr = {[[CREATE TABLE t1(x INT primary key);
             INSERT INTO t1(x) VALUES]]}
-        local i
         for i = 1, 100000-1, 1 do
             table.insert(sql_arr, "("..i.."),")
         end
diff --git a/test/sql-tap/sort.test.lua b/test/sql-tap/sort.test.lua
index 36074d6ef..0ad2f4ef4 100755
--- a/test/sql-tap/sort.test.lua
+++ b/test/sql-tap/sort.test.lua
@@ -761,7 +761,7 @@ test:do_execsql_test(
 --
 -- MUST_WORK_TEST? special sql functions (sql_soft_heap_limit, sql_test_control...)
 if (0 > 0) then
-local function cksum(x)
+local function cksum()
     local i1 = 1
     local i2 = 2
     X(503, "X!cmd", [=[["binary","scan",["x"],"c*","L"]]=])
diff --git a/test/sql-tap/sql-errors.test.lua b/test/sql-tap/sql-errors.test.lua
index 5ec94bfe3..14294f706 100755
--- a/test/sql-tap/sql-errors.test.lua
+++ b/test/sql-tap/sql-errors.test.lua
@@ -6,7 +6,7 @@ test:execsql([[
 	CREATE TABLE t0 (i INT PRIMARY KEY, a INT);
 	CREATE VIEW v0 AS SELECT * FROM t0;
 ]])
-format = {}
+local format = {}
 for i = 1, 2001 do format[i] = {name = 'A' .. i, type = 'unsigned'} end
 s0 = box.schema.space.create('S0', {format = format})
 i0 = s0:create_index('I0')
diff --git a/test/sql-tap/table.test.lua b/test/sql-tap/table.test.lua
index 1b4ec1173..86d20e09f 100755
--- a/test/sql-tap/table.test.lua
+++ b/test/sql-tap/table.test.lua
@@ -1,6 +1,7 @@
 #!/usr/bin/env tarantool
 test = require("sqltester")
 test:plan(79)
+enable_broken_tests = false
 
 --!./tcltestrunner.lua
 -- 2001 September 15
@@ -947,7 +948,7 @@ test:do_execsql_test(
 --
 --  Disabled until #3694 is resolved.
 --
-if false then
+if enable_broken_tests then
 test:do_execsql_test(
     "table-13.1",
     [[
diff --git a/test/sql-tap/tkt-38cb5df375.test.lua b/test/sql-tap/tkt-38cb5df375.test.lua
index a7587ef3a..32ac6fdcd 100755
--- a/test/sql-tap/tkt-38cb5df375.test.lua
+++ b/test/sql-tap/tkt-38cb5df375.test.lua
@@ -31,7 +31,6 @@ local function lrange(arr, start_num, end_num)
     return tmp
 end
 
-local ii
 test:do_execsql_test(
     "tkt-38cb5df375.0",
     [[
diff --git a/test/sql-tap/tkt-91e2e8ba6f.test.lua b/test/sql-tap/tkt-91e2e8ba6f.test.lua
index b12b6e0f3..d1ed6a653 100755
--- a/test/sql-tap/tkt-91e2e8ba6f.test.lua
+++ b/test/sql-tap/tkt-91e2e8ba6f.test.lua
@@ -82,9 +82,6 @@ test:do_execsql_test(
     })
 
 -- MUST_WORK_TEST
-if (0 > 0)
- then
-end
 test:do_execsql_test(
     1.7,
     [[
diff --git a/test/sql-tap/tkt-9a8b09f8e6.test.lua b/test/sql-tap/tkt-9a8b09f8e6.test.lua
index cb5348ab4..f90782cbd 100755
--- a/test/sql-tap/tkt-9a8b09f8e6.test.lua
+++ b/test/sql-tap/tkt-9a8b09f8e6.test.lua
@@ -22,9 +22,6 @@ test:plan(49)
 -- ["source",[["testdir"],"\/tester.tcl"]]
 testprefix = "tkt-9a8b09f8e6"
 -- MUST_WORK_TEST
-if (0 > 0)
- then
-end
 test:do_execsql_test(
     1.1,
     [[
diff --git a/test/sql-tap/tkt-bd484a090c.test.lua b/test/sql-tap/tkt-bd484a090c.test.lua
index 0347fd426..9eab5fe73 100755
--- a/test/sql-tap/tkt-bd484a090c.test.lua
+++ b/test/sql-tap/tkt-bd484a090c.test.lua
@@ -2,6 +2,7 @@
 test = require("sqltester")
 --test:plan(2)
 test:plan(0)
+enable_broken_tests = false
 
 --!./tcltestrunner.lua
 -- 2011 June 21
@@ -22,7 +23,7 @@ testprefix = "tkt-bd484a090c"
 
 -- Disabled until #3694 is resolved.
 --
-if false then
+if enable_broken_tests then
 test:do_test(
     1.1,
     function()
diff --git a/test/sql-tap/tkt-fa7bf5ec.test.lua b/test/sql-tap/tkt-fa7bf5ec.test.lua
index 7152e028c..25d44c9d3 100755
--- a/test/sql-tap/tkt-fa7bf5ec.test.lua
+++ b/test/sql-tap/tkt-fa7bf5ec.test.lua
@@ -20,9 +20,9 @@ test:plan(1)
 -- The problem described by this ticket was that the sqlExprCompare()
 -- function was saying that expressions (x='a') and (x='A') were identical
 -- because it was using sqlStrICmp() instead of strcmp() to compare string
--- literals.  That was causing the query optimizer for aggregate queries to 
--- believe that both count() operations were identical, and thus only 
--- computing the first count() and making a copy of the result for the 
+-- literals.  That was causing the query optimizer for aggregate queries to
+-- believe that both count() operations were identical, and thus only
+-- computing the first count() and making a copy of the result for the
 -- second count().
 --
 -- ["set","testdir",[["file","dirname",["argv0"]]]]
diff --git a/test/sql-tap/tkt2192.test.lua b/test/sql-tap/tkt2192.test.lua
index 52309ff2b..763cae782 100755
--- a/test/sql-tap/tkt2192.test.lua
+++ b/test/sql-tap/tkt2192.test.lua
@@ -2,6 +2,7 @@
 test = require("sqltester")
 -- test:plan(6)
 test:plan(4)
+local enable_broken_tests = false
 
 --!./tcltestrunner.lua
 -- 2007 January 26
@@ -26,7 +27,7 @@ test:plan(4)
 
 --  Disabled until #3694 is resolved.
 --
-if false then
+if enable_broken_tests then
 test:do_execsql_test(
     "tkt2192-1.1",
     [[
diff --git a/test/sql-tap/tkt3493.test.lua b/test/sql-tap/tkt3493.test.lua
index 7ceec4702..6ec4214db 100755
--- a/test/sql-tap/tkt3493.test.lua
+++ b/test/sql-tap/tkt3493.test.lua
@@ -255,9 +255,6 @@ test:do_execsql_test(
     })
 
 -- MUST_WORK_TEST
-if (0 > 0)
- then
-end
 test:do_execsql_test(
     "tkt3493-3.2.1",
     [[
diff --git a/test/sql-tap/trigger2.test.lua b/test/sql-tap/trigger2.test.lua
index 192b707d3..b412e581c 100755
--- a/test/sql-tap/trigger2.test.lua
+++ b/test/sql-tap/trigger2.test.lua
@@ -126,12 +126,12 @@ for _, tbl_defn in ipairs(tbl_definitions) do
             raw_result = test:execsql [[
                 SELECT * FROM rlog ORDER BY idx;
             ]]
-            for k,v in pairs(raw_result) do table.insert(r, v) end
+            for _,v in pairs(raw_result) do table.insert(r, v) end
 
             raw_result = test:execsql [[
                 SELECT * FROM clog ORDER BY idx;
             ]]
-            for k,v in pairs(raw_result) do table.insert(r, v) end
+            for _,v in pairs(raw_result) do table.insert(r, v) end
             
             return r
         end, {
diff --git a/test/sql-tap/triggerA.test.lua b/test/sql-tap/triggerA.test.lua
index fac51ca14..8dfd4dfab 100755
--- a/test/sql-tap/triggerA.test.lua
+++ b/test/sql-tap/triggerA.test.lua
@@ -46,7 +46,6 @@ test:do_test(
                 INSERT INTO t1 VALUES(%d,'%s');
                 INSERT INTO t2 VALUES(20-%d,%d,'%s');
             ]], i, word, i, j, word))
-            i = i + 1
         end
         return test:execsql [[
             SELECT count(*) FROM t1 UNION ALL SELECT count(*) FROM t2;
diff --git a/test/sql-tap/where2.test.lua b/test/sql-tap/where2.test.lua
index f267be8e6..838e58be6 100755
--- a/test/sql-tap/where2.test.lua
+++ b/test/sql-tap/where2.test.lua
@@ -1,9 +1,6 @@
 #!/usr/bin/env tarantool
-test = require("sqltester")
-yaml = require("yaml")
-fio = require("fio")
-
-ffi = require("ffi")
+local test = require("sqltester")
+local ffi = require("ffi")
 test:plan(74)
 
 ffi.cdef[[
@@ -115,7 +112,7 @@ local function queryplan(sql)
                 table.insert(data, tab)
                 table.insert(data, idx)
             else
-                as, tab = string.match(v, "TABLE (%w+ AS) (%w+)")
+                _, tab = string.match(v, "TABLE (%w+ AS) (%w+)")
                 if tab == nil  then
                     tab = string.match(v, "TABLE (%w+)")
                 end
diff --git a/test/sql-tap/where3.test.lua b/test/sql-tap/where3.test.lua
index ae9e37f61..4a8798eeb 100755
--- a/test/sql-tap/where3.test.lua
+++ b/test/sql-tap/where3.test.lua
@@ -1,5 +1,5 @@
 #!/usr/bin/env tarantool
-test = require("sqltester")
+local test = require("sqltester")
 test:plan(83)
 
 --!./tcltestrunner.lua
diff --git a/test/sql-tap/where4.test.lua b/test/sql-tap/where4.test.lua
index e38972666..65e7f9337 100755
--- a/test/sql-tap/where4.test.lua
+++ b/test/sql-tap/where4.test.lua
@@ -1,5 +1,5 @@
 #!/usr/bin/env tarantool
-test = require("sqltester")
+local test = require("sqltester")
 test:plan(8)
 
 --!./tcltestrunner.lua
@@ -23,7 +23,7 @@ test:plan(8)
 -- $Id: where4.test,v 1.6 2007/12/10 05:03:48 danielk1977 Exp $
 -- ["set","testdir",[["file","dirname",["argv0"]]]]
 -- ["source",[["testdir"],"\/tester.tcl"]]
-testprefix = "where4"
+local testprefix = "where4"
 
 
 -- Build some test data
diff --git a/test/sql-tap/where5.test.lua b/test/sql-tap/where5.test.lua
index 749201564..655c1b72b 100755
--- a/test/sql-tap/where5.test.lua
+++ b/test/sql-tap/where5.test.lua
@@ -1,5 +1,5 @@
 #!/usr/bin/env tarantool
-test = require("sqltester")
+local test = require("sqltester")
 test:plan(50)
 
 --!./tcltestrunner.lua
diff --git a/test/sql-tap/where6.test.lua b/test/sql-tap/where6.test.lua
index 5fb79fa2a..f9de30dbc 100755
--- a/test/sql-tap/where6.test.lua
+++ b/test/sql-tap/where6.test.lua
@@ -1,5 +1,5 @@
 #!/usr/bin/env tarantool
-test = require("sqltester")
+local test = require("sqltester")
 test:plan(20)
 
 --!./tcltestrunner.lua
diff --git a/test/sql-tap/where7.test.lua b/test/sql-tap/where7.test.lua
index 70209545d..d3e7d91fe 100755
--- a/test/sql-tap/where7.test.lua
+++ b/test/sql-tap/where7.test.lua
@@ -1,5 +1,5 @@
 #!/usr/bin/env tarantool
-test = require("sqltester")
+local test = require("sqltester")
 test:plan(2023)
 
 --!./tcltestrunner.lua
@@ -229,7 +229,7 @@ test:do_test(
 test:do_test(
     "where7-1.20",
     function()
-        sql = "SELECT a FROM t1 WHERE a=11 OR b=11"
+        local sql = "SELECT a FROM t1 WHERE a=11 OR b=11"
         for i = 12, 100 do
             sql = sql .. string.format(" OR a=%s OR b=%s", i, i)
         end
@@ -244,7 +244,7 @@ test:do_test(
 test:do_test(
     "where7-1.21",
     function()
-        sql = "SELECT a FROM t1 WHERE b=11 OR c=11"
+        local sql = "SELECT a FROM t1 WHERE b=11 OR c=11"
         for i = 12, 100 do
             sql = sql .. string.format(" OR b=%s OR c=%s", i, i)
         end
@@ -259,7 +259,7 @@ test:do_test(
 test:do_test(
     "where7-1.22",
     function()
-        sql = "SELECT a FROM t1 WHERE (b=11 OR c=11"
+        local sql = "SELECT a FROM t1 WHERE (b=11 OR c=11"
         for i = 12, 100 do
             sql = sql .. string.format(" OR b=%s OR c=%s", i, i)
         end
@@ -274,7 +274,7 @@ test:do_test(
 test:do_test(
     "where7-1.23",
     function()
-        sql = "SELECT a FROM t1 WHERE (b=11 OR c=11"
+        local sql = "SELECT a FROM t1 WHERE (b=11 OR c=11"
         for i = 12, 100 do
             sql = sql .. string.format(" OR (b=%s AND d!=0) OR (c=%s AND d IS NOT NULL)", i, i)
         end
@@ -289,7 +289,7 @@ test:do_test(
 test:do_test(
     "where7-1.31",
     function()
-        sql = "SELECT a FROM t1 WHERE (a=11 AND b=11)"
+        local sql = "SELECT a FROM t1 WHERE (a=11 AND b=11)"
         for i = 12, 100 do
             sql = sql .. string.format(" OR (a=%s AND b=%s)", i, i)
         end
@@ -304,7 +304,7 @@ test:do_test(
 test:do_test(
     "where7-1.32",
     function()
-        sql = "SELECT a FROM t1 WHERE (b=11 AND c=11)"
+        local sql = "SELECT a FROM t1 WHERE (b=11 AND c=11)"
         for i = 12, 100 do
             sql = sql .. string.format(" OR (b=%s AND c=%s)", i, i)
         end
@@ -319,7 +319,7 @@ test:do_test(
 test:do_test(
     "where7-AST-depth-limit",
     function()
-        sql = "SELECT a FROM t1 WHERE a = 0"
+        local sql = "SELECT a FROM t1 WHERE a = 0"
         for i = 1, 199 do
             sql = sql .. string.format(" OR a = %s", i)
         end
diff --git a/test/sql-tap/whereA.test.lua b/test/sql-tap/whereA.test.lua
index a49d1c05c..968ceb2e9 100755
--- a/test/sql-tap/whereA.test.lua
+++ b/test/sql-tap/whereA.test.lua
@@ -1,5 +1,5 @@
 #!/usr/bin/env tarantool
-test = require("sqltester")
+local test = require("sqltester")
 test:plan(17)
 
 --!./tcltestrunner.lua
diff --git a/test/sql-tap/whereB.test.lua b/test/sql-tap/whereB.test.lua
index d98645fdc..c7ef910d1 100755
--- a/test/sql-tap/whereB.test.lua
+++ b/test/sql-tap/whereB.test.lua
@@ -1,5 +1,5 @@
 #!/usr/bin/env tarantool
-test = require("sqltester")
+local test = require("sqltester")
 test:plan(63)
 
 --!./tcltestrunner.lua
diff --git a/test/sql-tap/whereC.test.lua b/test/sql-tap/whereC.test.lua
index 89459dee3..231404cea 100755
--- a/test/sql-tap/whereC.test.lua
+++ b/test/sql-tap/whereC.test.lua
@@ -1,6 +1,5 @@
 #!/usr/bin/env tarantool
-test = require("sqltester")
-local yaml = require('yaml')
+local test = require("sqltester")
 test:plan(41)
 
 --!./tcltestrunner.lua
@@ -17,7 +16,7 @@ test:plan(41)
 --
 -- ["set","testdir",[["file","dirname",["argv0"]]]]
 -- ["source",[["testdir"],"\/tester.tcl"]]
-testprefix = "whereC"
+local testprefix = "whereC"
 test:do_execsql_test(
     1.0,
     [[
diff --git a/test/sql-tap/whereD.test.lua b/test/sql-tap/whereD.test.lua
index 14dc8d3bd..26221ec12 100755
--- a/test/sql-tap/whereD.test.lua
+++ b/test/sql-tap/whereD.test.lua
@@ -1,5 +1,5 @@
 #!/usr/bin/env tarantool
-test = require("sqltester")
+local test = require("sqltester")
 test:plan(36)
 
 --!./tcltestrunner.lua
@@ -19,7 +19,7 @@ test:plan(36)
 --
 -- ["set","testdir",[["file","dirname",["argv0"]]]]
 -- ["source",[["testdir"],"\/tester.tcl"]]
-testprefix = "whereD"
+local testprefix = "whereD"
 test:do_execsql_test(
     1.1,
     [[
diff --git a/test/sql-tap/whereF.test.lua b/test/sql-tap/whereF.test.lua
index 5a894b748..64e51fbf0 100755
--- a/test/sql-tap/whereF.test.lua
+++ b/test/sql-tap/whereF.test.lua
@@ -1,5 +1,5 @@
 #!/usr/bin/env tarantool
-test = require("sqltester")
+local test = require("sqltester")
 test:plan(13)
 
 --!./tcltestrunner.lua
@@ -48,7 +48,7 @@ test:plan(13)
 --
 -- ["set","testdir",[["file","dirname",["argv0"]]]]
 -- ["source",[["testdir"],"\/tester.tcl"]]
-testprefix = "whereF"
+local testprefix = "whereF"
 test:do_execsql_test(
     1.0,
     [[
diff --git a/test/sql-tap/whereG.test.lua b/test/sql-tap/whereG.test.lua
index 590027023..2fbc6c5b3 100755
--- a/test/sql-tap/whereG.test.lua
+++ b/test/sql-tap/whereG.test.lua
@@ -1,5 +1,5 @@
 #!/usr/bin/env tarantool
-test = require("sqltester")
+local test = require("sqltester")
 test:plan(23)
 
 --!./tcltestrunner.lua
@@ -18,7 +18,7 @@ test:plan(23)
 -- likelihood() functions.
 -- ["set","testdir",[["file","dirname",["argv0"]]]]
 -- ["source",[["testdir"],"\/tester.tcl"]]
-testprefix = "whereG"
+local testprefix = "whereG"
 test:do_execsql_test(
     "whereG-1.0",
     [[
diff --git a/test/sql-tap/whereI.test.lua b/test/sql-tap/whereI.test.lua
index 3ae5b82f2..79c6bcfe5 100755
--- a/test/sql-tap/whereI.test.lua
+++ b/test/sql-tap/whereI.test.lua
@@ -1,5 +1,5 @@
 #!/usr/bin/env tarantool
-test = require("sqltester")
+local test = require("sqltester")
 test:plan(7)
 
 --!./tcltestrunner.lua
@@ -20,7 +20,7 @@ test:plan(7)
 --
 -- ["set","testdir",[["file","dirname",["argv0"]]]]
 -- ["source",[["testdir"],"\/tester.tcl"]]
-testprefix = "whereI"
+local testprefix = "whereI"
 test:do_execsql_test(1.0, [[
     CREATE TABLE t1(a INT, b TEXT, c TEXT, PRIMARY KEY(a));
     INSERT INTO t1 VALUES(1, 'a', 'z');
diff --git a/test/sql-tap/whereK.test.lua b/test/sql-tap/whereK.test.lua
index 58e3146a7..0ca7fff0d 100755
--- a/test/sql-tap/whereK.test.lua
+++ b/test/sql-tap/whereK.test.lua
@@ -1,5 +1,5 @@
 #!/usr/bin/env tarantool
-test = require("sqltester")
+local test = require("sqltester")
 test:plan(10)
 
 --!./tcltestrunner.lua
@@ -23,7 +23,7 @@ test:plan(10)
 --
 -- ["set","testdir",[["file","dirname",["argv0"]]]]
 -- ["source",[["testdir"],"\/tester.tcl"]]
-testprefix = "whereK"
+local testprefix = "whereK"
 test:do_execsql_test(1.1, [[
   CREATE TABLE t1(a INT ,b INT ,c INT , primary key (a,b,c));
   WITH RECURSIVE c(x) AS (VALUES(0) UNION ALL SELECT x+1 FROM c WHERE x<99)
diff --git a/test/sql-tap/with1.test.lua b/test/sql-tap/with1.test.lua
index 75935108c..2a91085a2 100755
--- a/test/sql-tap/with1.test.lua
+++ b/test/sql-tap/with1.test.lua
@@ -1,5 +1,5 @@
 #!/usr/bin/env tarantool
-test = require("sqltester")
+local test = require("sqltester")
 test:plan(64)
 
 --!./tcltestrunner.lua
@@ -18,7 +18,7 @@ test:plan(64)
 --
 -- ["set","testdir",[["file","dirname",["argv0"]]]]
 -- ["source",[["testdir"],"\/tester.tcl"]]
-testprefix = "with1"
+local testprefix = "with1"
 -- if X(0, "X!capable", [["!cte"]]) then
 --   test:finish_test()
 --  return 
@@ -623,7 +623,7 @@ test:do_execsql_test("8.2-soduko", [[
 -- Some tests that use LIMIT and OFFSET in the definition of recursive CTEs.
 --
 -- I = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20 }
-function limit_test(tn, iLimit, iOffset)
+local function limit_test(tn, iLimit, iOffset)
     local last = 20 - 1
     local result = {}
     -- if X(0, "X!expr01", [["$iOffset < 0"]]) then
@@ -631,13 +631,13 @@ function limit_test(tn, iLimit, iOffset)
         iOffset = 0
     end
     -- if X(0, "X!expr01", [["$iLimit < 0 "]]) then
-    if iLimit < 0 then
-        -- result = X(467, "X!cmd", [=[["lrange",["::I"],["iOffset"],"end"]]=])
-        -- last is 20
-    else
+    if iLimit >= 0 then
         -- result = X(467, "X!cmd", [=[["lrange",["::I"],["iOffset"],[["expr",[["iLimit"],"+",["iOffset"],"-1"]]]]]=])
         last = iLimit + iOffset - 1
         if last > 20 then last = 20 - 1 end
+    --else
+        -- result = X(467, "X!cmd", [=[["lrange",["::I"],["iOffset"],"end"]]=])
+        -- last is 20
     end
 
     for i = iOffset, last do
diff --git a/test/sql-tap/with2.test.lua b/test/sql-tap/with2.test.lua
index 1aa39b32e..cdf1d75a2 100755
--- a/test/sql-tap/with2.test.lua
+++ b/test/sql-tap/with2.test.lua
@@ -1,5 +1,5 @@
 #!/usr/bin/env tarantool
-test = require("sqltester")
+local test = require("sqltester")
 test:plan(59)
 
 --!./tcltestrunner.lua
@@ -18,7 +18,7 @@ test:plan(59)
 --
 -- ["set","testdir",[["file","dirname",["argv0"]]]]
 -- ["source",[["testdir"],"\/tester.tcl"]]
-testprefix = "with2"
+local testprefix = "with2"
 
 test:do_execsql_test(
     1.0,
@@ -386,22 +386,22 @@ genstmt(255), {
 -- Check that adding a WITH clause to an INSERT disables the xfer
 -- optimization.
 
-local function do_xfer_test(test, test_func, test_name, func, exp, opts)
-    local opts = opts or {}
+local function do_xfer_test(test_arg, test_func, test_name, func, exp, opts)
+    opts = opts or {}
     local exp_xfer_count = opts.exp_xfer_count
     local before = box.stat.sql().sql_xfer_count
-    test_func(test, test_name, func, exp)
+    test_func(test_arg, test_name, func, exp)
     local after = box.stat.sql().sql_xfer_count
     test:is(after - before, exp_xfer_count,
                    test_name .. '-xfer-count')
 end
 
-test.do_execsql_xfer_test = function(test, test_name, func, exp, opts)
-    do_xfer_test(test, test.do_execsql_test, test_name, func, exp, opts)
+test.do_execsql_xfer_test = function(test_arg, test_name, func, exp, opts)
+    do_xfer_test(test_arg, test_arg.do_execsql_test, test_name, func, exp, opts)
 end
 
-test.do_catchsql_xfer_test = function(test, test_name, func, exp, opts)
-    do_xfer_test(test, test.do_catchsql_test, test_name, func, exp, opts)
+test.do_catchsql_xfer_test = function(test_arg, test_name, func, exp, opts)
+    do_xfer_test(test_arg, test_arg.do_catchsql_test, test_name, func, exp, opts)
 end
 
 test:do_execsql_test(
diff --git a/test/sql/lua/sql_tokenizer.lua b/test/sql/lua/sql_tokenizer.lua
index 9922d792d..ffe4fb4e8 100644
--- a/test/sql/lua/sql_tokenizer.lua
+++ b/test/sql/lua/sql_tokenizer.lua
@@ -134,7 +134,7 @@ end
 -- @retval Token type. If the rest of the SQL request consists of
 --         spaces and comments, then return TK_EMPTY.
 local function get_next_token(context)
-    local c = ''
+    local c
     repeat
         local i = context.offset
         c = context.sql:sub(i, i)
diff --git a/test/sql/savepoints.result b/test/sql/savepoints.result
index 509c33e59..b0915f398 100644
--- a/test/sql/savepoints.result
+++ b/test/sql/savepoints.result
@@ -102,12 +102,12 @@ collision_sv_2 = function()
     box.begin()
     box.execute('SAVEPOINT t1;')
     box.execute('SAVEPOINT t2;')
-    local _,err = box.execute('SAVEPOINT t1;')
+    local _, err = box.execute('SAVEPOINT t1;')
     assert(err == nil)
     box.execute('RELEASE SAVEPOINT t1;')
-    local _,err = box.execute('RELEASE SAVEPOINT t1;')
+    _, err = box.execute('RELEASE SAVEPOINT t1;')
     assert(err ~= nil)
-    local _, err = box.execute('ROLLBACK TO t2;')
+    _, err = box.execute('ROLLBACK TO t2;')
     assert(err == nil)
 end;
 ---
diff --git a/test/sql/savepoints.test.lua b/test/sql/savepoints.test.lua
index f1b15c748..eb7bea37d 100644
--- a/test/sql/savepoints.test.lua
+++ b/test/sql/savepoints.test.lua
@@ -65,12 +65,12 @@ collision_sv_2 = function()
     box.begin()
     box.execute('SAVEPOINT t1;')
     box.execute('SAVEPOINT t2;')
-    local _,err = box.execute('SAVEPOINT t1;')
+    local _, err = box.execute('SAVEPOINT t1;')
     assert(err == nil)
     box.execute('RELEASE SAVEPOINT t1;')
-    local _,err = box.execute('RELEASE SAVEPOINT t1;')
+    _, err = box.execute('RELEASE SAVEPOINT t1;')
     assert(err ~= nil)
-    local _, err = box.execute('ROLLBACK TO t2;')
+    _, err = box.execute('ROLLBACK TO t2;')
     assert(err == nil)
 end;
 collision_sv_2();
diff --git a/test/sql/triggers.result b/test/sql/triggers.result
index ceecb8ef2..e70d72947 100644
--- a/test/sql/triggers.result
+++ b/test/sql/triggers.result
@@ -11,7 +11,7 @@ _ = box.space._session_settings:update('sql_default_engine', {{'=', 2, engine}})
 ---
 ...
 -- Get invariant part of the tuple; name and opts don't change.
- function immutable_part(data) local r = {} for i, l in pairs(data) do table.insert(r, {l.name, l.opts}) end return r end
+ function immutable_part(data) local r = {} for _, l in pairs(data) do table.insert(r, {l.name, l.opts}) end return r end
 ---
 ...
 --
diff --git a/test/sql/triggers.test.lua b/test/sql/triggers.test.lua
index f5c8a3961..bc694ebc4 100644
--- a/test/sql/triggers.test.lua
+++ b/test/sql/triggers.test.lua
@@ -4,7 +4,7 @@ engine = test_run:get_cfg('engine')
 _ = box.space._session_settings:update('sql_default_engine', {{'=', 2, engine}})
 
 -- Get invariant part of the tuple; name and opts don't change.
- function immutable_part(data) local r = {} for i, l in pairs(data) do table.insert(r, {l.name, l.opts}) end return r end
+ function immutable_part(data) local r = {} for _, l in pairs(data) do table.insert(r, {l.name, l.opts}) end return r end
 
 --
 -- gh-3273: Move Triggers to server
diff --git a/test/swim/box.lua b/test/swim/box.lua
index a603777e0..41791013b 100644
--- a/test/swim/box.lua
+++ b/test/swim/box.lua
@@ -12,8 +12,8 @@ box.cfg{}
 -- with encryption. Otherwise they can accidentally discover
 -- SWIM instances from other tests.
 --
-enc_key = box.info.uuid
-enc_algo = 'aes128'
+local enc_key = box.info.uuid
+local enc_algo = 'aes128'
 
 --
 -- Wrap swim.new with a codec to prevent test workers affecting
diff --git a/test/vinyl/large.lua b/test/vinyl/large.lua
index e10e94c1a..a997aec7e 100644
--- a/test/vinyl/large.lua
+++ b/test/vinyl/large.lua
@@ -1,5 +1,4 @@
-fiber = require('fiber')
-digest = require('digest')
+local digest = require('digest')
 
 local PAGE_SIZE = 1024
 local RANGE_SIZE = 64 * PAGE_SIZE
diff --git a/test/vinyl/stress.lua b/test/vinyl/stress.lua
index 5e8d89795..15a999393 100644
--- a/test/vinyl/stress.lua
+++ b/test/vinyl/stress.lua
@@ -33,8 +33,8 @@ local spaces = {box.space.s1, box.space.s2, box.space.s3, box.space.s4,
 local max_data_size = box.cfg.vinyl_page_size * 1.5
 
 local function t1(ch, time_limit)
-    local t1 = fiber.time()
-    while fiber.time() - t1 < time_limit do
+    local time = fiber.time()
+    while fiber.time() - time < time_limit do
         local k = math.random(10000)
         local t = math.random(80)
         local data = string.char(math.random(string.byte('Z') - string.byte('A')) + string.byte('A') - 1)
@@ -56,13 +56,13 @@ local function t1(ch, time_limit)
 end;
 
 local function t2(ch, time_limit)
-    local t1 = fiber.time()
-    while fiber.time() - t1 < time_limit do
+    local time = fiber.time()
+    while fiber.time() - time < time_limit do
         local k = math.random(10000)
         local t = math.random(16)
         local space = spaces[math.fmod(t, #spaces) + 1]
         if t < 12 then
-            local l = space:get({k})
+            space:get({k})
         else
             space:delete({k})
         end
@@ -71,9 +71,9 @@ local function t2(ch, time_limit)
 end;
 
 local function t3(ch, time_limit)
-    local t1 = fiber.time()
+    local time = fiber.time()
     local i = 0
-    while fiber.time() - t1 < time_limit do
+    while fiber.time() - time < time_limit do
         i = i + 1
         local k = math.random(10000)
         local t = math.random(20)
@@ -99,19 +99,19 @@ local function stress(time_limit)
 
     math.randomseed(os.time());
 
-    for i = 1, 6 do
+    for _ = 1, 6 do
         fiber.create(t1, ch, time_limit)
     end;
 
-    for i = 1, 6 do
+    for _ = 1, 6 do
         fiber.create(t2, ch, time_limit)
     end;
 
-    for i = 1, 4 do
+    for _ = 1, 4 do
         fiber.create(t3, ch, time_limit)
     end;
 
-    for i = 1, 16 do
+    for _ = 1, 16 do
         ch:get()
     end;
 end
diff --git a/test/vinyl/txn_proxy.lua b/test/vinyl/txn_proxy.lua
index 7a4d0b865..15b0e4add 100644
--- a/test/vinyl/txn_proxy.lua
+++ b/test/vinyl/txn_proxy.lua
@@ -1,11 +1,11 @@
--- A fiber can't use multiple transactions simultaneously;  
+-- A fiber can't use multiple transactions simultaneously;
 -- i.e. [fiber] --? [transaction] in UML parlor.
 --
 -- This module provides a simple transaction proxy facility
--- to control multiple transactions at once. A proxy executes 
+-- to control multiple transactions at once. A proxy executes
 -- statements in a worker fiber in order to overcome
 -- "one transaction per fiber" limitation.
--- 
+--
 -- Ex:
 -- proxy = require('txn_proxy').new()
 -- proxy:begin()
diff --git a/test/vinyl/upgrade/fill.lua b/test/vinyl/upgrade/fill.lua
index 547777330..0164b9316 100644
--- a/test/vinyl/upgrade/fill.lua
+++ b/test/vinyl/upgrade/fill.lua
@@ -2,11 +2,11 @@
 -- This script generates a vinyl metadata log
 -- containing all possible record types.
 --
-fiber = require 'fiber'
+local fiber = require 'fiber'
 
 box.cfg{vinyl_memory = 1024 * 1024, vinyl_timeout = 1e-9, checkpoint_count = 1}
 
-dump_trigger = box.schema.space.create('dump_trigger', {engine = 'vinyl'})
+local dump_trigger = box.schema.space.create('dump_trigger', {engine = 'vinyl'})
 dump_trigger:create_index('pk', {run_count_per_level = 1})
 
 -- Trigger dump of all indexes and wait for it to finish.
@@ -15,7 +15,7 @@ dump_trigger:create_index('pk', {run_count_per_level = 1})
 -- to trigger system-wide memory dump, it is enough to insert a
 -- huge tuple into one space.
 --
-function dump()
+local function dump()
     local pad = string.rep('x', box.cfg.vinyl_memory / 2)
     dump_trigger:replace{1, pad}
     -- Must fail due to quota timeout, but still trigger dump.
@@ -38,7 +38,7 @@ end
 --   VY_LOG_CREATE_INDEX
 --   VY_LOG_INSERT_RANGE
 --
-s = box.schema.space.create('test', {engine = 'vinyl'})
+local s = box.schema.space.create('test', {engine = 'vinyl'})
 s:create_index('i1', {parts = {1, 'unsigned'}, run_count_per_level = 1})
 s:create_index('i2', {parts = {2, 'string'},   run_count_per_level = 2})
 
diff --git a/test/vinyl/vinyl.lua b/test/vinyl/vinyl.lua
index 31307f4bc..1d313b4e4 100644
--- a/test/vinyl/vinyl.lua
+++ b/test/vinyl/vinyl.lua
@@ -15,21 +15,4 @@ box.cfg {
     vinyl_max_tuple_size = 1024 * 1024 * 6,
 }
 
-function box_info_sort(data)
-    if type(data)~='table' then
-        return data
-    end
-    local keys = {}
-    for k in pairs(data) do
-        table.insert(keys, k)
-    end
-    table.sort(keys)
-    local result = {}
-    for _,k in pairs(keys) do
-        local v = data[k]
-        table.insert(result, {[k] = box_info_sort(v) })
-    end
-    return result
-end
-
 require('console').listen(os.getenv('ADMIN'))
diff --git a/test/wal_off/rtree_benchmark.result b/test/wal_off/rtree_benchmark.result
index 8e01c9f2a..8deefca82 100644
--- a/test/wal_off/rtree_benchmark.result
+++ b/test/wal_off/rtree_benchmark.result
@@ -163,7 +163,7 @@ for i = 1, 0 do
    for j = 1, dimension do
       table.insert(rect, 180*math.random())
    end
-   for k,v in pairs(s.index.spatial:select(rect, {limit = n_neighbors, iterator = 'NEIGHBOR'})) do
+   for _,_ in pairs(s.index.spatial:select(rect, {limit = n_neighbors, iterator = 'NEIGHBOR'})) do
       n = n + 1
    end
 end;
diff --git a/test/wal_off/rtree_benchmark.test.lua b/test/wal_off/rtree_benchmark.test.lua
index 6fae977c9..6bdc0a758 100644
--- a/test/wal_off/rtree_benchmark.test.lua
+++ b/test/wal_off/rtree_benchmark.test.lua
@@ -96,7 +96,7 @@ for i = 1, 0 do
    for j = 1, dimension do
       table.insert(rect, 180*math.random())
    end
-   for k,v in pairs(s.index.spatial:select(rect, {limit = n_neighbors, iterator = 'NEIGHBOR'})) do
+   for _,_ in pairs(s.index.spatial:select(rect, {limit = n_neighbors, iterator = 'NEIGHBOR'})) do
       n = n + 1
    end
 end;
diff --git a/test/xlog-py/box.lua b/test/xlog-py/box.lua
index c87f7b94b..8b9e9434f 100644
--- a/test/xlog-py/box.lua
+++ b/test/xlog-py/box.lua
@@ -1,5 +1,5 @@
 #!/usr/bin/env tarantool
-os = require('os')
+local os = require('os')
 
 box.cfg{
     listen              = os.getenv("LISTEN"),
diff --git a/test/xlog/panic.lua b/test/xlog/panic.lua
index 2d4eb8d2e..0fa855421 100644
--- a/test/xlog/panic.lua
+++ b/test/xlog/panic.lua
@@ -1,5 +1,5 @@
 #!/usr/bin/env tarantool
-os = require('os')
+local os = require('os')
 
 box.cfg{
     listen              = os.getenv("LISTEN"),
diff --git a/test/xlog/reader.result b/test/xlog/reader.result
index 9985aa2ac..74ac3579e 100644
--- a/test/xlog/reader.result
+++ b/test/xlog/reader.result
@@ -40,7 +40,7 @@ trun:cmd("setopt delimiter ';'")
 ...
 function collect_results(file)
     local val = {}
-    for k, v in xlog(file) do
+    for _, v in xlog(file) do
         table.insert(val, setmetatable(v, { __serialize = "map"}))
     end
     return val
diff --git a/test/xlog/reader.test.lua b/test/xlog/reader.test.lua
index 327af54dd..707ba394b 100644
--- a/test/xlog/reader.test.lua
+++ b/test/xlog/reader.test.lua
@@ -21,7 +21,7 @@ pattern_ok_v13 = fio.pathjoin(pattern_prefix, "v13/")
 trun:cmd("setopt delimiter ';'")
 function collect_results(file)
     local val = {}
-    for k, v in xlog(file) do
+    for _, v in xlog(file) do
         table.insert(val, setmetatable(v, { __serialize = "map"}))
     end
     return val
diff --git a/test/xlog/snap_io_rate.test.lua b/test/xlog/snap_io_rate.test.lua
index f71296269..5626ea1f4 100644
--- a/test/xlog/snap_io_rate.test.lua
+++ b/test/xlog/snap_io_rate.test.lua
@@ -9,6 +9,6 @@ for i = 0, 127 do box.space.snap:replace({i, digest.urandom(512 * 1024)}) end
 t1 = fiber.time()
 box.snapshot()
 t2 = fiber.time()
-t2 - t1 > 64 / box.cfg.snap_io_rate_limit * 0.95
+assert(t2 - t1 > 64 / box.cfg.snap_io_rate_limit * 0.95)
 
 box.space.snap:drop()
diff --git a/test/xlog/transaction.result b/test/xlog/transaction.result
index 63adb0f25..d45b60b0a 100644
--- a/test/xlog/transaction.result
+++ b/test/xlog/transaction.result
@@ -16,7 +16,7 @@ test_run:cmd("setopt delimiter ';'")
 ...
 function read_xlog(file)
     local val = {}
-    for k, v in xlog(file) do
+    for _, v in xlog(file) do
         table.insert(val, setmetatable(v, { __serialize = "map"}))
     end
     return val
diff --git a/test/xlog/transaction.test.lua b/test/xlog/transaction.test.lua
index 2d8090b4c..5fdeec625 100644
--- a/test/xlog/transaction.test.lua
+++ b/test/xlog/transaction.test.lua
@@ -6,7 +6,7 @@ test_run = env.new()
 test_run:cmd("setopt delimiter ';'")
 function read_xlog(file)
     local val = {}
-    for k, v in xlog(file) do
+    for _, v in xlog(file) do
         table.insert(val, setmetatable(v, { __serialize = "map"}))
     end
     return val
diff --git a/test/xlog/upgrade/2.1.3/gh-4771-upgrade-sequence/fill.lua b/test/xlog/upgrade/2.1.3/gh-4771-upgrade-sequence/fill.lua
index b159f2b67..8e9a9d13d 100644
--- a/test/xlog/upgrade/2.1.3/gh-4771-upgrade-sequence/fill.lua
+++ b/test/xlog/upgrade/2.1.3/gh-4771-upgrade-sequence/fill.lua
@@ -1,14 +1,14 @@
 box.cfg{}
-s1 = box.schema.create_space('test1')
-pk = s1:create_index('pk', {sequence = true})
+local s1 = box.schema.create_space('test1')
+s1:create_index('pk', {sequence = true})
 s1:replace{box.NULL}
 
-seq2 = box.schema.sequence.create('seq2')
-s2 = box.schema.create_space('test2')
-pk = s2:create_index('pk', {sequence = 'seq2'})
+box.schema.sequence.create('seq2')
+local s2 = box.schema.create_space('test2')
+s2:create_index('pk', {sequence = 'seq2'})
 s2:replace{box.NULL}
 
-seq3 = box.schema.sequence.create('seq3')
+local seq3 = box.schema.sequence.create('seq3')
 seq3:next()
 
 box.snapshot()
diff --git a/test/xlog/xlog.lua b/test/xlog/xlog.lua
index 004096d2d..aaf1a0ae6 100644
--- a/test/xlog/xlog.lua
+++ b/test/xlog/xlog.lua
@@ -1,5 +1,5 @@
 #!/usr/bin/env tarantool
-os = require('os')
+local os = require('os')
 
 box.cfg{
     listen              = os.getenv("LISTEN"),
-- 
2.23.0

  parent reply	other threads:[~2020-05-12  9:53 UTC|newest]

Thread overview: 39+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2020-05-12  9:49 [Tarantool-patches] [PATCH v5 00/10] Add static analysis with luacheck sergeyb
2020-05-12  9:49 ` [Tarantool-patches] [PATCH v5 01/10] Add initial luacheck config sergeyb
2020-05-26 22:15   ` Igor Munkin
2020-05-28 15:31     ` Sergey Bronnikov
2020-05-28 16:07       ` Sergey Bronnikov
2020-05-29 11:20         ` Igor Munkin
2020-11-10 14:30           ` Sergey Bronnikov
2020-11-10 14:49             ` Igor Munkin
2020-05-12  9:49 ` [Tarantool-patches] [PATCH v5 02/10] gitlab-ci: enable static analysis with luacheck sergeyb
2020-05-13 14:15   ` Alexander V. Tikhonov
2020-05-13 14:40     ` Sergey Bronnikov
2020-05-26 22:39   ` Igor Munkin
2020-05-28 10:03     ` Sergey Bronnikov
2020-05-12  9:49 ` [Tarantool-patches] [PATCH v5 03/10] Fix luacheck warnings in extra/dist/tarantoolctl.in sergeyb
2020-05-26 23:11   ` Igor Munkin
2020-05-28 10:13     ` Sergey Bronnikov
2020-05-12  9:49 ` [Tarantool-patches] [PATCH v5 04/10] Fix luacheck warnings in src/lua/ sergeyb
2020-05-27 11:22   ` Igor Munkin
2020-05-28 12:22     ` Sergey Bronnikov
2020-05-12  9:50 ` [Tarantool-patches] [PATCH v5 05/10] " sergeyb
2020-05-13 11:13   ` Sergey Bronnikov
2020-05-27 11:22   ` Igor Munkin
2020-05-12  9:50 ` [Tarantool-patches] [PATCH v5 06/10] Fix luacheck warnings in src/box/lua/ sergeyb
2020-05-27 16:54   ` Igor Munkin
2020-05-28 15:16     ` Sergey Bronnikov
2020-05-12  9:50 ` [Tarantool-patches] [PATCH v5 07/10] " sergeyb
2020-05-13 11:14   ` Sergey Bronnikov
2020-05-27 16:54   ` Igor Munkin
2020-05-28 11:19     ` Sergey Bronnikov
2020-05-12  9:50 ` sergeyb [this message]
2020-05-29 11:08   ` [Tarantool-patches] [PATCH v5 08/10] Fix luacheck warnings in test/ Igor Munkin
2020-05-29 14:08     ` Sergey Bronnikov
2020-05-12  9:50 ` [Tarantool-patches] [PATCH v5 09/10] Add luacheck supressions for luajit tests sergeyb
2020-05-26 20:45   ` Igor Munkin
2020-05-28 19:25     ` Sergey Bronnikov
2020-05-12 12:28 ` [Tarantool-patches] [PATCH 10/10] build: Enable 'make luacheck' target Sergey Bronnikov
2020-05-26 20:45   ` Igor Munkin
2020-05-28  9:59     ` Sergey Bronnikov
2020-05-26 20:38 ` [Tarantool-patches] [PATCH v5 11/10] test: fix warnings spotted by luacheck sergeyb

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=afaf7c097d3e004c26a9ad90c56c0717fb7863ed.1589275364.git.sergeyb@tarantool.org \
    --to=sergeyb@tarantool.org \
    --cc=o.piskunov@tarantool.org \
    --cc=tarantool-patches@dev.tarantool.org \
    --cc=v.shpilevoy@tarantool.org \
    --subject='Re: [Tarantool-patches] [PATCH v5 08/10] Fix luacheck warnings in test/' \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox