test: add LuaJIT-test-cleanup test suite

This patch introduces LuaJIT-test-cleanup test suite[1] into our LuaJIT
fork source tree. Considering the changes made by our team (such as a
new preloaded module) and tweaks made in Tarantool runtime, several
tests need to be adjusted. However to be sure, we initially use the
valid suite, everything in test/LuaJIT-tests directory is moved intact.

[1]: https://github.com/LuaJIT/LuaJIT-test-cleanup/tree/014708b/test

Part of tarantool/tarantool#4064
Part of tarantool/tarantool#4473

Reviewed-by: Sergey Kaplun <skaplun@tarantool.org>
Reviewed-by: Sergey Ostanevich <sergos@tarantool.org>
Signed-off-by: Igor Munkin <imun@tarantool.org>

Author: ImeevMA

.luacheckrc

@@ -8,4 +8,5 @@ read_globals = { 'misc' }
 exclude_files = {
   'dynasm/',
   'src/',
+  'test/LuaJIT-tests/',
 }

test/CMakeLists.txt

@@ -41,8 +41,10 @@ else()
 endif()
 
 add_subdirectory(tarantool-tests)
+add_subdirectory(LuaJIT-tests)
 
 add_custom_target(${PROJECT_NAME}-test DEPENDS
+  LuaJIT-tests
   tarantool-tests
 )
 

test/LuaJIT-tests/CMakeLists.txt

@@ -0,0 +1,12 @@
+# See the rationale in the root CMakeLists.txt
+cmake_minimum_required(VERSION 3.1 FATAL_ERROR)
+
+add_custom_target(LuaJIT-tests DEPENDS ${LUAJIT_TEST_BINARY})
+
+add_custom_command(TARGET LuaJIT-tests
+  COMMENT "Running LuaJIT-tests"
+  COMMAND
+    ${LUAJIT_TEST_BINARY} ${CMAKE_CURRENT_SOURCE_DIR}/test.lua
+    +slow +ffi +bit +jit
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+)

test/LuaJIT-tests/README.md

@@ -0,0 +1,110 @@
+This directory contains the LuaJIT test suite, or at least something which
+will evolve into the LuaJIT test suite. Large chunks of the suite can also
+be run with any other Lua 5.1 or 5.2 interpreter.
+
+## Running the test suite ##
+
+To run the default test suite, run `test.lua` using the Lua interpreter you
+wish to test, for example:
+
+    $ ~/luajit-2.0/src/luajit test.lua
+
+If the test suite passes, the final line printed to stdout will be
+`NNN passed`, and the exit code of the process will be zero. If any tests
+fail, the exit code will be non-zero. If the failures caused catastrophic
+termination of the entire process (such as a segmentation fault or assertion
+failure), the last line of output will be number and name of the test which
+caused the catastrophe. If the failures weren't catastrophic, the penultimate
+line of output will be `NNN passed, MMM failed`, and the last line will say
+how to re-run just the failing tests.
+
+Various flags and options can be passed to `test.lua` to control which tests
+are run, and in which order. Run `lua test.lua --help` for details.
+
+## Structure of the test suite ##
+
+The test suite consists of a directory tree. Within said tree there are various
+`.lua` files, and within every `.lua` file there are one or more tests. Every
+directory in the tree contains a file called `index`, which enumerates the
+members of the directory which contribute to the test suite (this is done to
+avoid an external dependency for directory iteration, and to allow metadata to
+be specified at the file/directory level). Every `.lua` file is structured as:
+
+    << local definitions >>
+    << test 1 >>
+    ...
+    << test N >>
+
+Where `<< local definitions >>` consists of Lua code to act as a common prefix
+for every test in the file, and each `<< test >>` looks like:
+
+    do --- <<name>> <<metadata>>
+      << code >>
+    end
+
+Where `<<name>>` is (almost) free-form, and `<< code >>` is Lua code which
+performs some actions and probably calls `assert` alot. The `<<metadata>>`
+fragment can be used to specify the conditions under which the test should
+or should not run, to adjust the environment in which the test is run, and to
+allow key/value pairs to be specified in a standard place/format.
+
+Some common pieces of metadata are:
+  * `+luajit>=2.1` - The test requires LuaJIT 2.1 or later to run.
+  * `+lua<5.2` - The test requires Lua 5.1 or earlier to run (all versions of
+                 LuaJIT report themselves as 5.1).
+  * `+ffi` - The test requires the `ffi` library to be present.
+  * `+bit` - The test requires the `bit` library to be present.
+  * `+jit` - The test requires JIT compilation be available and turned on.
+  * `+slow` - The test is too slow to run as part of the default suite, and
+              thus requires `+slow` to be specified on the command line.
+  * `!private_G` - The test modifies globals, and thus needs to be run with a
+                   private (shallow) copy of `_G`.
+
+Lua code which is common across all (or some) tests in a single file can be
+written at the top of the file as part of `<< local definitions >>`. Code
+which is common across multiple files lives in the `common` directory, and
+is pulled into applicable tests by means of `local x = require"common.x"`.
+
+It is intended that most `.lua` files in the test suite can be exercised
+without the test runner by just passing them to a Lua interpreter. In such
+cases, metadata is ignored, the tests are executed from top to bottom, and
+any failure results in later tests not running. Also note that the test
+runner converts every test into a separate function, which causes references
+to local definitions to become upvalue accesses rather than local variable
+accesses - in some cases this can cause differences in behaviour.
+
+## Extending the test suite ##
+
+First of all, decide where your new test(s) should live. This might be within
+an existing `.lua` file, or might involve creating new files and/or directories.
+If new files are created, remember to add them to the `index` file of the
+enclosing directory. If new directories are created, remember to create an
+`index` file in said directory, and add the new directory to the `index` file
+in the parent directory.
+
+Once you've decided in which file the test(s) should live, you're ready to add
+your test(s) to said file. Each test should be wrapped in a `do`/`end` block,
+and given some kind of name (after the `do` keyword, as in `do --- <<name>>`).
+The test should call `assert` to confirm whether the thing under test is
+behaving, or otherwise raise an error if the thing under test is misbehaving.
+Your test(s) should not write to stdout or stderr, nor should they mutate
+global state. After your test(s) are written, you should be able to determine
+which features they require, and put on metadata appropriately.
+
+## Completing the tidy-up of the test suite ##
+
+Some files/directories in this directory need some thought:
+
+  * `common/ffi_util.inc` - Needs renaming and being made `require`-able.
+  * `lib/ffi` - Tests need converting to structure described in this document.
+  * `lib/table/misc.lua` - Tests need organising and converting to structure
+                           described in this document.
+  * `misc` - Tests need organising and converting to structure described in
+             this document.
+  * `src` - C/C++ source which needs to be compiled into a dynamic library and
+            loaded for certain tests. Need to figure out a good way of handling
+            C/C++ source.
+  * `sysdep` - Need to figure out a good way of handling these.
+  * `unportable` - Need to figure out a good way of handling these.
+
+After that, consult the README file by Mike in the directory above this one.

test/LuaJIT-tests/bc/constov.lua

@@ -0,0 +1,16 @@
+
+do --- float
+  local t = { "local x\n" }
+  for i=2,65537 do t[i] = "x="..i..".5\n" end
+  assert(loadstring(table.concat(t)) ~= nil)
+  t[65538] = "x=65538.5"
+  assert(loadstring(table.concat(t)) == nil)
+end
+
+do --- int
+  local t = { "local x\n" }
+  for i=2,65537 do t[i] = "x='"..i.."'\n" end
+  assert(loadstring(table.concat(t)) ~= nil)
+  t[65538] = "x='65538'"
+  assert(loadstring(table.concat(t)) == nil)
+end

test/LuaJIT-tests/bc/index

@@ -0,0 +1 @@
+constov.lua +slow

test/LuaJIT-tests/common/expect_error.lua

@@ -0,0 +1,16 @@
+return function(f, msg)
+  local ok, err = pcall(f)
+  if ok then error("error check unexpectedly succeeded", 2) end
+  if msg then
+    if type(err) ~= "string" then
+      error("error check failed with "..tostring(err), 2)
+    end
+    local line, err2 = string.match(err, ":(%d*): (.*)")
+    if err2 ~= msg then
+      if err2:gsub(" got no value", " got nil") == msg then
+        return
+      end
+      error("error check failed with "..err, 2)
+    end
+  end
+end

test/LuaJIT-tests/common/ffi_util.inc

@@ -0,0 +1,41 @@
+-- This should be turned into a proper module and not use globals.
+-- Or combined into a generiv test utility module. With FFI
+-- functionality turned off, if the FFI module is not built-in.
+
+local ffi = require("ffi")
+
+function checkfail(t, f)
+  f = f or ffi.typeof
+  for i=1,1e9 do
+    local tp = t[i]
+    if not tp then break end
+    assert(pcall(f, tp) == false, tp)
+  end
+end
+
+function checktypes(t)
+  for i=1,1e9,3 do
+    local tp = t[i+2]
+    if not tp then break end
+    local id = ffi.typeof(tp)
+    assert(ffi.sizeof(id) == t[i], tp)
+    assert(ffi.alignof(id) == t[i+1], tp)
+  end
+end
+
+function fails(f, ...)
+  if pcall(f, ...) ~= false then error("failure expected", 2) end
+end
+
+local incroot = os.getenv("INCROOT") or "/usr/include"
+local cdefs = os.getenv("CDEFS") or ""
+
+function include(name)
+  local flags = ffi.abi("32bit") and "-m32" or "-m64"
+  if string.sub(name, 1, 1) ~= "/" then name = incroot.."/"..name end
+  local fp = assert(io.popen("cc -E -P "..flags.." "..cdefs.." "..name))
+  local s = fp:read("*a")
+  fp:close()
+  ffi.cdef(s)
+end
+

test/LuaJIT-tests/common/test_runner_canary.lua

@@ -0,0 +1 @@
+return "canary is alive"

test/LuaJIT-tests/computations.lua

@@ -0,0 +1,113 @@
+do --- ack
+  local function Ack(m, n)
+    if m == 0 then return n+1 end
+    if n == 0 then return Ack(m-1, 1) end
+    return Ack(m-1, (Ack(m, n-1))) -- The parentheses are deliberate.
+  end
+  
+  assert(Ack(3,5) == 253)
+end
+
+do --- ack notail
+  local function Ack(m, n)
+    if m == 0 then return n+1 end
+    if n == 0 then return Ack(m-1, 1) end
+    return (Ack(m-1, (Ack(m, n-1)))) -- The parentheses are deliberate.
+  end
+  
+  assert(Ack(3,5) == 253)
+end
+
+do --- fac
+  local function fac(n)
+    local x = 1
+    for i=2,n do
+      x = x * i
+    end
+    return x
+  end
+  
+  assert(fac(10) == 3628800)
+end
+
+do --- ffib
+  local function ffib(n)
+    if n <= 2 then return n,1 end
+    if n % 2 == 1 then
+      local a,b = ffib((n-1)/2)
+      local aa = a*a
+      return aa+a*(b+b), aa+b*b
+    else
+      local a,b = ffib(n/2-1)
+      local ab = a+b
+      return ab*ab+a*a, (ab+b)*a
+    end
+  end
+
+  local function fib(n)
+    return (ffib(n))
+  end
+
+  assert(fib(40) == 165580141)
+  assert(fib(39) == 102334155)
+  assert(fib(77) == 8944394323791464)
+end
+
+do --- fib
+  local function fib(n)
+    if n < 2 then return 1 end
+    return fib(n-2) + fib(n-1)
+  end
+
+  assert(fib(27) == 317811)
+end
+
+do --- nsieve
+  local function nsieve(m)
+    local isPrime = {}
+    for i=2,m do isPrime[i] = true end
+    local count = 0
+    for i=2,m do
+      if isPrime[i] then
+        for k=i+i,m,i do isPrime[k] = false end
+        count = count + 1
+      end
+    end
+    return count
+  end
+  
+  assert(nsieve(100) == 25)
+  assert(nsieve(12345) == 1474)
+end
+
+do --- recsum
+  local function sum(n)
+    if n == 1 then return 1 end
+    return n + sum(n-1)
+  end
+  
+  for i=1, 100 do
+    assert(sum(i) == i*(i+1)/2)
+  end
+end
+
+do --- recsump
+  local abs = math.abs
+  local function sum(n)
+    if n == 1 then return 1 end
+    return abs(n + sum(n-1))
+  end
+  
+  for i=1, 100 do
+    assert(sum(i) == i*(i+1)/2)
+  end
+end
+
+do --- tak
+  local function tak(x, y, z)
+    if y >= x then return z end
+    return tak(tak(x-1, y, z), tak(y-1, z, x), (tak(z-1, x, y)))
+  end
+
+  assert(tak(21, 14, 7) == 14)
+end