292 lines
8.5 KiB
Lua
292 lines
8.5 KiB
Lua
|
|
-- Tests for GLib Regex functions
|
|
-- written by Hadriel Kaplan, based on Lrexlib's test suite
|
|
-- This is a test script for tshark/wireshark.
|
|
-- This script runs inside tshark/wireshark, so to run it do:
|
|
-- tshark -r empty.cap -X lua_script:<path_to_testdir>/lua/gregex.lua -X lua_script1:glib
|
|
--
|
|
-- if you have to give addtional paths to find the dependent lua files,
|
|
-- use the '-X lua_script1:' syntax to add more arguments
|
|
--
|
|
-- available arguments:
|
|
-- -d<dir> provides path directory for lua include files
|
|
-- -v verbose mode
|
|
-- -V very verbose mode
|
|
|
|
|
|
-- save args before we do anything else
|
|
local args = {...}
|
|
for i,v in ipairs(args) do
|
|
print(i.." = "..v)
|
|
end
|
|
|
|
-- save current locale and replace it with C-locale
|
|
local old_locale = os.setlocale()
|
|
print("Previous locale was '" .. old_locale .. "', setting it to C-locale now")
|
|
os.setlocale("C")
|
|
|
|
local function testing(...)
|
|
print("---- Testing "..tostring(...).." ----")
|
|
end
|
|
|
|
local count = 0
|
|
|
|
local function test(name, ...)
|
|
count = count + 1
|
|
io.write("test "..name.."-"..count.."...")
|
|
if (...) == true then
|
|
io.write("passed\n")
|
|
io.flush()
|
|
else
|
|
io.write("failed!\n")
|
|
io.flush()
|
|
error(name.." test failed!")
|
|
end
|
|
end
|
|
|
|
------------- First test some basic stuff to make sure we're sane -----------
|
|
|
|
print("Lua version: ".._VERSION)
|
|
|
|
testing("Lrexlib GLib Regex library")
|
|
|
|
local lib = GRegex
|
|
test("global",_G.GRegex == lib)
|
|
|
|
for name, val in pairs(lib) do
|
|
print("\t"..name.." = "..type(val))
|
|
end
|
|
|
|
test("class",type(lib) == 'table')
|
|
test("class",type(lib._VERSION) == 'string')
|
|
test("class",type(lib.find) == 'function')
|
|
test("class",type(lib.compile_flags) == 'function')
|
|
test("class",type(lib.match_flags) == 'function')
|
|
test("class",type(lib.flags) == 'function')
|
|
test("class",type(lib.gsub) == 'function')
|
|
test("class",type(lib.gmatch) == 'function')
|
|
test("class",type(lib.new) == 'function')
|
|
test("class",type(lib.match) == 'function')
|
|
test("class",type(lib.split) == 'function')
|
|
test("class",type(lib.version) == 'function')
|
|
|
|
testing("info and flags")
|
|
|
|
test("typeof",typeof(lib) == 'GRegex')
|
|
|
|
print(lib._VERSION)
|
|
print("Glib version = "..lib.version())
|
|
|
|
local function getTSize(t)
|
|
local c = 0
|
|
for k,v in pairs(t) do
|
|
-- print(k.." = "..v)
|
|
c = c + 1
|
|
end
|
|
return c
|
|
end
|
|
|
|
local flags = lib.flags()
|
|
|
|
-- print("size = "..c)
|
|
-- it's 84 for newer GLib, 61 for older
|
|
test("flags", getTSize(flags) > 60)
|
|
test("cflags", getTSize(lib.compile_flags()) > 15)
|
|
test("eflags", getTSize(lib.match_flags()) > 8)
|
|
|
|
testing("new")
|
|
|
|
local results
|
|
local function checkFunc(objname,funcname,...)
|
|
results = { pcall(objname[funcname],...) }
|
|
if results[1] then
|
|
return true
|
|
end
|
|
-- print("Got this error: '"..tostring(results[2]).."'")
|
|
return false
|
|
end
|
|
|
|
test("new", checkFunc(lib,"new",".*"))
|
|
test("new", checkFunc(lib,"new",""))
|
|
test("new", checkFunc(lib,"new","(hello|world)"))
|
|
|
|
test("new_err", not checkFunc(lib,"new","*"))
|
|
test("new_err", not checkFunc(lib,"new"))
|
|
test("new_err", not checkFunc(lib,"new","(hello|world"))
|
|
test("new_err", not checkFunc(lib,"new","[0-9"))
|
|
-- invalid compile flag
|
|
test("new_err", not checkFunc(lib,"new","[0-9]",flags.PARTIAL))
|
|
|
|
|
|
local val1 = "hello world foo bar"
|
|
local val2 = "hello wORld FOO bar"
|
|
local patt = "hello (world) (.*) bar"
|
|
local rgx = lib.new(patt)
|
|
local rgx2 = lib.new(patt,flags.CASELESS)
|
|
|
|
testing("typeof")
|
|
test("typeof",typeof(rgx) == 'GRegex')
|
|
test("typeof",typeof(rgx2) == 'GRegex')
|
|
|
|
testing("match")
|
|
test("match", checkFunc(lib,"match", val1,patt, 1, flags.CASELESS) and results[2] == "world" and results[3] == "foo")
|
|
test("match", checkFunc(lib,"match", val2,patt, 1, flags.CASELESS) and results[2] == "wORld" and results[3] == "FOO")
|
|
test("match", checkFunc(lib,"match", val1,rgx) and results[2] == "world" and results[3] == "foo")
|
|
test("match", checkFunc(rgx,"match", rgx,val1) and results[2] == "world" and results[3] == "foo")
|
|
test("match", checkFunc(rgx2,"match", rgx2,val2, 1) and results[2] == "wORld" and results[3] == "FOO")
|
|
|
|
-- different offset won't match this pattern
|
|
test("match_err", checkFunc(rgx2,"match", rgx2,val2, 4) and results[2] == nil)
|
|
|
|
-- invalid compile flag
|
|
test("match_err", not checkFunc(lib,"match", val1,patt, 1, flags.PARTIAL))
|
|
-- invalid match flag
|
|
test("match_err", not checkFunc(rgx,"match", rgx,val1, 1, flags.CASELESS))
|
|
|
|
testing("find")
|
|
|
|
test("find", checkFunc(lib,"find", val1,patt) and results[2] == 1 and results[3] == val1:len()
|
|
and results[4] == "world" and results[5] == "foo")
|
|
test("find", checkFunc(lib,"find", val1,rgx) and results[2] == 1 and results[3] == val1:len()
|
|
and results[4] == "world" and results[5] == "foo")
|
|
test("find", checkFunc(rgx,"find", rgx,val1) and results[2] == 1 and results[3] == val1:len()
|
|
and results[4] == "world" and results[5] == "foo")
|
|
|
|
testing("match")
|
|
|
|
--checkFunc(rgx,"exec", rgx,val1)
|
|
--print(results[4][3],results[4][4])
|
|
test("exec", checkFunc(rgx,"exec", rgx,val1) and results[2] == 1 and results[3] == val1:len()
|
|
and results[4][1] == 7 and results[4][2] == 11 and results[4][3] == 13 and results[4][4] == 15)
|
|
|
|
print("\n----------------------------------------------------------\n")
|
|
|
|
------- OK, we're sane, so run all the library's real tests ---------
|
|
|
|
testing("Lrexlib-provided tests")
|
|
|
|
-- we're not using the "real" lib name
|
|
local GLIBNAME = "GRegex"
|
|
local isglobal = true
|
|
|
|
do
|
|
local dir
|
|
for i = 1, select ("#", ...) do
|
|
local arg = select (i, ...)
|
|
--print(arg)
|
|
if arg:sub(1,2) == "-d" then
|
|
dir = arg:sub(3)
|
|
end
|
|
end
|
|
dir = dir:gsub("[/\\]+$", "")
|
|
local path = dir .. "/?.lua;"
|
|
if package.path:sub(1, #path) ~= path then
|
|
package.path = path .. package.path
|
|
end
|
|
end
|
|
|
|
local luatest = require "luatest"
|
|
|
|
-- returns: number of failures
|
|
local function test_library (libname, setfile, verbose, really_verbose)
|
|
if verbose then
|
|
print (("[lib: %s; file: %s]"):format (libname, setfile))
|
|
end
|
|
local lib = isglobal and _G[libname] or require (libname)
|
|
local f = require (setfile)
|
|
local sets = f (libname, isglobal)
|
|
|
|
local n = 0 -- number of failures
|
|
for _, set in ipairs (sets) do
|
|
if verbose then
|
|
print (set.Name or "Unnamed set")
|
|
end
|
|
local err = luatest.test_set (set, lib, really_verbose)
|
|
if verbose then
|
|
for _,v in ipairs (err) do
|
|
print ("\nTest " .. v.i)
|
|
print (" Expected result:\n "..tostring(v))
|
|
luatest.print_results (v[1], " ")
|
|
table.remove(v,1)
|
|
print ("\n Got:")
|
|
luatest.print_results (v, " ")
|
|
end
|
|
end
|
|
n = n + #err
|
|
end
|
|
if verbose then
|
|
print ""
|
|
end
|
|
|
|
return n
|
|
end
|
|
|
|
local avail_tests = {
|
|
posix = { lib = "rex_posix", "common_sets", "posix_sets" },
|
|
gnu = { lib = "rex_gnu", "common_sets", "emacs_sets", "gnu_sets" },
|
|
oniguruma = { lib = "rex_onig", "common_sets", "oniguruma_sets", },
|
|
pcre = { lib = "rex_pcre", "common_sets", "pcre_sets", "pcre_sets2", },
|
|
glib = { lib = GLIBNAME, "common_sets", "pcre_sets", "pcre_sets2", "glib_sets" },
|
|
spencer = { lib = "rex_spencer", "common_sets", "posix_sets", "spencer_sets" },
|
|
tre = { lib = "rex_tre", "common_sets", "posix_sets", "spencer_sets", --[["tre_sets"]] },
|
|
}
|
|
|
|
do
|
|
local verbose, really_verbose, tests, nerr = false, false, {}, 0
|
|
local dir
|
|
|
|
-- check arguments
|
|
for i = 1, select ("#", ...) do
|
|
local arg = select (i, ...)
|
|
--print(arg)
|
|
if arg:sub(1,1) == "-" then
|
|
if arg == "-v" then
|
|
verbose = true
|
|
elseif arg == "-V" then
|
|
verbose = true
|
|
really_verbose = true
|
|
elseif arg:sub(1,2) == "-d" then
|
|
dir = arg:sub(3)
|
|
end
|
|
else
|
|
if avail_tests[arg] then
|
|
tests[#tests+1] = avail_tests[arg]
|
|
else
|
|
error ("invalid argument: [" .. arg .. "]")
|
|
end
|
|
end
|
|
end
|
|
assert (#tests > 0, "no library specified")
|
|
-- give priority to libraries located in the specified directory
|
|
if dir and not isglobal then
|
|
dir = dir:gsub("[/\\]+$", "")
|
|
for _, ext in ipairs {"dll", "so", "dylib"} do
|
|
if package.cpath:match ("%?%." .. ext) then
|
|
local cpath = dir .. "/?." .. ext .. ";"
|
|
if package.cpath:sub(1, #cpath) ~= cpath then
|
|
package.cpath = cpath .. package.cpath
|
|
end
|
|
break
|
|
end
|
|
end
|
|
end
|
|
-- do tests
|
|
for _, test in ipairs (tests) do
|
|
package.loaded[test.lib] = nil -- to force-reload the tested library
|
|
for _, setfile in ipairs (test) do
|
|
nerr = nerr + test_library (test.lib, setfile, verbose, really_verbose)
|
|
end
|
|
end
|
|
print ("Total number of failures: " .. nerr)
|
|
|
|
assert(nerr == 0, "Test failed!")
|
|
end
|
|
|
|
print("Resetting locale to: " .. old_locale)
|
|
os.setlocale(old_locale)
|
|
|
|
|
|
print("\n-----------------------------\n")
|
|
|
|
print("All tests passed!\n\n")
|