Lua: Remove on-life-support GRegex bindings

This code has been unmaintained and does not pass the lrexlib test
suite. GRegex itself has been obsolescent for some time, although GNOME
has recently restarted trying to move it to PCRE2.

Remove it in preparation for a move to lrexlib-pcre2.

9 files changed, 0 insertions, 1475 deletions

diff --git a/test/lua/common_sets.lua b/test/lua/common_sets.lua
deleted file mode 100644
index e71251fea8..0000000000
--- a/test/lua/common_sets.lua
+++ /dev/null
@@ -1,319 +0,0 @@
--- See Copyright Notice in the file LICENSE
-
--- This file should contain only test sets that behave identically
--- when being run with pcre or posix regex libraries.
-
-local luatest = require "luatest"
-local N = luatest.NT
-
-local function norm(a) return a==nil and N or a end
-
-local function get_gsub (lib)
-  return lib.gsub or
-    function (subj, pattern, repl, n)
-      return lib.new (pattern) : gsub (subj, repl, n)
-    end
-end
-
-local function set_f_gmatch (lib, flg)
-  -- gmatch (s, p, [cf], [ef])
-  local function test_gmatch (subj, patt)
-    local out, guard = {}, 10
-    for a, b in lib.gmatch (subj, patt) do
-      table.insert (out, { norm(a), norm(b) })
-      guard = guard - 1
-      if guard == 0 then break end
-    end
-    return unpack (out)
-  end
-  return {
-    Name = "Function gmatch",
-    Func = test_gmatch,
-  --{  subj             patt         results }
-    { {"ab",            lib.new"."}, {{"a",N}, {"b",N} } },
-    { {("abcd"):rep(3), "(.)b.(d)"}, {{"a","d"},{"a","d"},{"a","d"}} },
-    { {"abcd",          ".*" },      {{"abcd",N},{"",N}  } },--zero-length match
-    { {"abc",           "^." },      {{"a",N}} },--anchored pattern
-  }
-end
-
-local function set_f_split (lib, flg)
-  -- split (s, p, [cf], [ef])
-  local function test_split (subj, patt)
-    local out, guard = {}, 10
-    for a, b, c in lib.split (subj, patt) do
-      table.insert (out, { norm(a), norm(b), norm(c) })
-      guard = guard - 1
-      if guard == 0 then break end
-    end
-    return unpack (out)
-  end
-  return {
-    Name = "Function split",
-    Func = test_split,
-  --{  subj             patt      results }
-    { {"ab",     lib.new","},     {{"ab",N,N},                           } },
-    { {"ab",            ","},     {{"ab",N,N},                           } },
-    { {",",             ","},     {{"",",",N},     {"", N, N},           } },
-    { {",,",            ","},     {{"",",",N},     {"",",",N},  {"",N,N} } },
-    { {"a,b",           ","},     {{"a",",",N},    {"b",N,N},            } },
-    { {",a,b",          ","},     {{"",",",N},     {"a",",",N}, {"b",N,N}} },
-    { {"a,b,",          ","},     {{"a",",",N},    {"b",",",N}, {"",N,N} } },
-    { {"a,,b",          ","},     {{"a",",",N},    {"",",",N},  {"b",N,N}} },
-    { {"ab<78>c", "<(.)(.)>"},    {{"ab","7","8"}, {"c",N,N},            } },
-    { {"abc",          "^."},     {{"", "a",N},    {"bc",N,N},           } },--anchored pattern
-    { {"abc",           "^"},     {{"", "", N},    {"abc",N,N},          } },
---  { {"abc",           "$"},     {{"abc","",N},   {"",N,N},             } },
---  { {"abc",         "^|$"},     {{"", "", N},    {"abc","",N},{"",N,N},} },
-  }
-end
-
-local function set_f_find (lib, flg)
-  return {
-    Name = "Function find",
-    Func = lib.find,
-  --  {subj, patt, st},         { results }
-    { {"abcd", lib.new".+"},    { 1,4 }   },      -- [none]
-    { {"abcd", ".+"},           { 1,4 }   },      -- [none]
-    { {"abcd", ".+", 2},        { 2,4 }   },      -- positive st
-    { {"abcd", ".+", -2},       { 3,4 }   },      -- negative st
-    { {"abcd", ".*"},           { 1,4 }   },      -- [none]
-    { {"abc",  "bc"},           { 2,3 }   },      -- [none]
-    { {"abcd", "(.)b.(d)"},     { 1,4,"a","d" }}, -- [captures]
-  }
-end
-
-local function set_f_match (lib, flg)
-  return {
-    Name = "Function match",
-    Func = lib.match,
-  --  {subj, patt, st},         { results }
-    { {"abcd", lib.new".+"},    {"abcd"}  }, -- [none]
-    { {"abcd", ".+"},           {"abcd"}  }, -- [none]
-    { {"abcd", ".+", 2},        {"bcd"}   }, -- positive st
-    { {"abcd", ".+", -2},       {"cd"}    }, -- negative st
-    { {"abcd", ".*"},           {"abcd"}  }, -- [none]
-    { {"abc",  "bc"},           {"bc"}    }, -- [none]
-    { {"abcd", "(.)b.(d)"},     {"a","d"} }, -- [captures]
-  }
-end
-
-local function set_m_exec (lib, flg)
-  return {
-    Name = "Method exec",
-    Method = "exec",
-  --{patt},                 {subj, st}           { results }
-    { {".+"},               {"abcd"},            {1,4,{}}  }, -- [none]
-    { {".+"},               {"abcd",2},          {2,4,{}}  }, -- positive st
-    { {".+"},               {"abcd",-2},         {3,4,{}}  }, -- negative st
-    { {".*"},               {"abcd"},            {1,4,{}}  }, -- [none]
-    { {"bc"},               {"abc"},             {2,3,{}}  }, -- [none]
-    { { "(.)b.(d)"},        {"abcd"},            {1,4,{1,1,4,4}}},--[captures]
-    { {"(a+)6+(b+)"},       {"Taa66bbT",2},      {2,7,{2,3,6,7}}},--[st+captures]
-  }
-end
-
-local function set_m_tfind (lib, flg)
-  return {
-    Name = "Method tfind",
-    Method = "tfind",
-  --{patt},                 {subj, st}           { results }
-    { {".+"},               {"abcd"},            {1,4,{}}  }, -- [none]
-    { {".+"},               {"abcd",2},          {2,4,{}}  }, -- positive st
-    { {".+"},               {"abcd",-2},         {3,4,{}}  }, -- negative st
-    { {".*"},               {"abcd"},            {1,4,{}}  }, -- [none]
-    { {"bc"},               {"abc"},             {2,3,{}}  }, -- [none]
-    { {"(.)b.(d)"},         {"abcd"},            {1,4,{"a","d"}}},--[captures]
-  }
-end
-
-local function set_m_find (lib, flg)
-  return {
-    Name = "Method find",
-    Method = "find",
-  --{patt},                 {subj, st}           { results }
-    { {".+"},               {"abcd"},            {1,4}  }, -- [none]
-    { {".+"},               {"abcd",2},          {2,4}  }, -- positive st
-    { {".+"},               {"abcd",-2},         {3,4}  }, -- negative st
-    { {".*"},               {"abcd"},            {1,4}  }, -- [none]
-    { {"bc"},               {"abc"},             {2,3}  }, -- [none]
-    { {"(.)b.(d)"},         {"abcd"},            {1,4,"a","d"}},--[captures]
-  }
-end
-
-local function set_m_match (lib, flg)
-  return {
-    Name = "Method match",
-    Method = "match",
-  --{patt},                 {subj, st}           { results }
-    { {".+"},               {"abcd"},            {"abcd"}  }, -- [none]
-    { {".+"},               {"abcd",2},          {"bcd" }  }, -- positive st
-    { {".+"},               {"abcd",-2},         {"cd"  }  }, -- negative st
-    { {".*"},               {"abcd"},            {"abcd"}  }, -- [none]
-    { {"bc"},               {"abc"},             {"bc"  }  }, -- [none]
-    {{ "(.)b.(d)"},         {"abcd"},            {"a","d"} }, --[captures]
-  }
-end
-
-local function set_f_gsub1 (lib, flg)
-  local subj, pat = "abcdef", "[abef]+"
-  local cpat = lib.new(pat)
-  return {
-    Name = "Function gsub, set1",
-    Func = get_gsub (lib),
-  --{ s,       p,    f,   n,    res1,  res2, res3 },
-    { {subj,  cpat,  "",  0},   {subj,    0, 0} }, -- test "n" + empty_replace
-    { {subj,   pat,  "",  0},   {subj,    0, 0} }, -- test "n" + empty_replace
-    { {subj,   pat,  "", -1},   {subj,    0, 0} }, -- test "n" + empty_replace
-    { {subj,   pat,  "",  1},   {"cdef",  1, 1} },
-    { {subj,   pat,  "",  2},   {"cd",    2, 2} },
-    { {subj,   pat,  "",  3},   {"cd",    2, 2} },
-    { {subj,   pat,  ""    },   {"cd",    2, 2} },
-    { {subj,   pat,  "#", 0},   {subj,    0, 0} }, -- test "n" + non-empty_replace
-    { {subj,   pat,  "#", 1},   {"#cdef", 1, 1} },
-    { {subj,   pat,  "#", 2},   {"#cd#",  2, 2} },
-    { {subj,   pat,  "#", 3},   {"#cd#",  2, 2} },
-    { {subj,   pat,  "#"   },   {"#cd#",  2, 2} },
-    { {"abc",  "^.", "#"   },   {"#bc",   1, 1} }, -- anchored pattern
-  }
-end
-
-local function set_f_gsub2 (lib, flg)
-  local subj, pat = "abc", "([ac])"
-  return {
-    Name = "Function gsub, set2",
-    Func = get_gsub (lib),
-  --{ s,     p,   f,   n,     res1,    res2, res3 },
-    { {subj, pat, "<%1>" },   {"<a>b<c>", 2, 2} }, -- test non-escaped chars in f
-    { {subj, pat, "%<%1%>" }, {"<a>b<c>", 2, 2} }, -- test escaped chars in f
-    { {subj, pat, "" },       {"b",       2, 2} }, -- test empty replace
-    { {subj, pat, "1" },      {"1b1",     2, 2} }, -- test odd and even %'s in f
-    { {subj, pat, "%1" },     {"abc",     2, 2} },
-    { {subj, pat, "%%1" },    {"%1b%1",   2, 2} },
-    { {subj, pat, "%%%1" },   {"%ab%c",   2, 2} },
-    { {subj, pat, "%%%%1" },  {"%%1b%%1", 2, 2} },
-    { {subj, pat, "%%%%%1" }, {"%%ab%%c", 2, 2} },
-  }
-end
-
-local function set_f_gsub3 (lib, flg)
-  return {
-    Name = "Function gsub, set3",
-    Func = get_gsub (lib),
-  --{ s,      p,      f,  n,   res1,res2,res3 },
-    { {"abc", "a",    "%0" }, {"abc", 1, 1} }, -- test (in)valid capture index
-    { {"abc", "a",    "%1" }, {"abc", 1, 1} },
-    { {"abc", "[ac]", "%1" }, {"abc", 2, 2} },
-    { {"abc", "(a)",  "%1" }, {"abc", 1, 1} },
-    { {"abc", "(a)",  "%2" }, "invalid capture index" },
-  }
-end
-
-local function set_f_gsub4 (lib, flg)
-  return {
-    Name = "Function gsub, set4",
-    Func = get_gsub (lib),
-  --{ s,           p,              f, n,  res1,      res2, res3 },
-    { {"a2c3",     ".",            "#" }, {"####",      4, 4} }, -- test .
-    { {"a2c3",     ".+",           "#" }, {"#",         1, 1} }, -- test .+
-    { {"a2c3",     ".*",           "#" }, {"##",        2, 2} }, -- test .*
-    { {"/* */ */", "\\/\\*(.*)\\*\\/", "#" }, {"#",     1, 1} },
-    { {"a2c3",     "[0-9]",        "#" }, {"a#c#",      2, 2} }, -- test %d
-    { {"a2c3",     "[^0-9]",       "#" }, {"#2#3",      2, 2} }, -- test %D
-    { {"a \t\nb",  "[ \t\n]",      "#" }, {"a###b",     3, 3} }, -- test %s
-    { {"a \t\nb",  "[^ \t\n]",     "#" }, {"# \t\n#",   2, 2} }, -- test %S
-  }
-end
-
-local function set_f_gsub5 (lib, flg)
-  local function frep1 () end                       -- returns nothing
-  local function frep2 () return "#" end            -- ignores arguments
-  local function frep3 (...) return table.concat({...}, ",") end -- "normal"
-  local function frep4 () return {} end             -- invalid return type
-  local function frep5 () return "7", "a" end       -- 2-nd return is "a"
-  local function frep6 () return "7", "break" end   -- 2-nd return is "break"
-  local subj = "a2c3"
-  return {
-    Name = "Function gsub, set5",
-    Func = get_gsub (lib),
-  --{ s,     p,          f,   n,   res1,     res2, res3 },
-    { {subj, "a(.)c(.)", frep1 }, {subj,        1, 0} },
-    { {subj, "a(.)c(.)", frep2 }, {"#",         1, 1} },
-    { {subj, "a(.)c(.)", frep3 }, {"2,3",       1, 1} },
-    { {subj, "a.c.",     frep3 }, {subj,        1, 1} },
-    { {subj, "z*",       frep1 }, {subj,        5, 0} },
-    { {subj, "z*",       frep2 }, {"#a#2#c#3#", 5, 5} },
-    { {subj, "z*",       frep3 }, {subj,        5, 5} },
-    { {subj, subj,       frep4 }, "invalid return type" },
-    { {"abc",".",        frep5 }, {"777",       3, 3} },
-    { {"abc",".",        frep6 }, {"777",       3, 3} },
-  }
-end
-
-local function set_f_gsub6 (lib, flg)
-  local tab1, tab2, tab3 = {}, { ["2"] = 56 }, { ["2"] = {} }
-  local subj = "a2c3"
-  return {
-    Name = "Function gsub, set6",
-    Func = get_gsub (lib),
-  --{ s,     p,          f, n,   res1,res2,res3 },
-    { {subj, "a(.)c(.)", tab1 }, {subj,  1, 0} },
-    { {subj, "a(.)c(.)", tab2 }, {"56",  1, 1} },
-    { {subj, "a(.)c(.)", tab3 }, "invalid replacement type" },
-    { {subj, "a.c.",     tab1 }, {subj,  1, 0} },
-    { {subj, "a.c.",     tab2 }, {subj,  1, 0} },
-    { {subj, "a.c.",     tab3 }, {subj,  1, 0} },
-  }
-end
-
-local function set_f_gsub8 (lib, flg)
-  local subj, patt, repl = "abcdef", "..", "*"
-  return {
-    Name = "Function gsub, set8",
-    Func = get_gsub (lib),
-  --{ s,     p,       f, n,                                    res1,  res2, res3 },
-    { {subj, patt, repl, function() end },                    {"abcdef", 3, 0} },
-    { {subj, patt, repl, function() return nil end },         {"abcdef", 3, 0} },
-    { {subj, patt, repl, function() return false end },       {"abcdef", 3, 0} },
-    { {subj, patt, repl, function() return true end },        {"***",    3, 3} },
-    { {subj, patt, repl, function() return {} end },          {"***",    3, 3} },
-    { {subj, patt, repl, function() return "#" end },         {"###",    3, 3} },
-    { {subj, patt, repl, function() return 57 end },          {"575757", 3, 3} },
-    { {subj, patt, repl, function (from) return from end },   {"135",    3, 3} },
-    { {subj, patt, repl, function (from, to) return to end }, {"246",    3, 3} },
-    { {subj, patt, repl, function (from,to,rep) return rep end },
-                                                              {"***",    3, 3} },
-    { {subj, patt, repl, function (from, to, rep) return rep..to..from end },
-                                                           {"*21*43*65", 3, 3} },
-    { {subj, patt, repl, function() return nil end },         {"abcdef", 3, 0} },
-    { {subj, patt, repl, function() return nil, nil end },    {"abcdef", 3, 0} },
-    { {subj, patt, repl, function() return nil, false end },  {"abcdef", 3, 0} },
-    { {subj, patt, repl, function() return nil, true end },   {"ab**",   3, 2} },
-    { {subj, patt, repl, function() return true, true end },  {"***",    3, 3} },
-    { {subj, patt, repl, function() return nil, 0 end },      {"abcdef", 1, 0} },
-    { {subj, patt, repl, function() return true, 0 end },     {"*cdef",  1, 1} },
-    { {subj, patt, repl, function() return nil, 1 end },      {"ab*ef",  2, 1} },
-    { {subj, patt, repl, function() return true, 1 end },     {"**ef",   2, 2} },
-  }
-end
-
-return function (libname, isglobal)
-  local lib = isglobal and _G[libname] or require (libname)
-  return {
-    set_f_gmatch    (lib),
-    set_f_split     (lib),
-    set_f_find      (lib),
-    set_f_match     (lib),
-    set_m_exec      (lib),
-    set_m_tfind     (lib),
-    set_m_find      (lib),
-    set_m_match     (lib),
-    set_f_gsub1     (lib),
-    set_f_gsub2     (lib),
-    set_f_gsub3     (lib),
-    set_f_gsub4     (lib),
-    set_f_gsub5     (lib),
-    set_f_gsub6     (lib),
-    set_f_gsub8     (lib),
-  }
-end
diff --git a/test/lua/glib_sets.lua b/test/lua/glib_sets.lua
deleted file mode 100644
index 0c3f38a483..0000000000
--- a/test/lua/glib_sets.lua
+++ /dev/null
@@ -1,204 +0,0 @@
--- See Copyright Notice in the file LICENSE
-
-local pat2pcre = require "pat2pcre"
-local luatest = require "luatest"
-local N = luatest.NT
-
-local function norm(a) return a==nil and N or a end
-
-local function fill (n, m)
-  local t = {}
-  for i = n, m, -1 do table.insert (t, i) end
-  return t
-end
-
-
--- glib doesn't do partial matching return of matches, nor
--- does it support ovecsize being set through the API
-local function set_m_dfa_exec (lib, flg)
-  return {
-  Name = "Method dfa_exec for glib",
-  Method = "dfa_exec",
---{patt,cf,lo},           {subj,st,ef,os,ws}        { results }
-  { {".+"},               {"abcd"},                 {1,{4,3,2,1},4} }, -- [none]
-  { {".+"},               {"abcd",2},               {2,{4,3,2},  3} }, -- positive st
-  { {".+"},               {"abcd",-2},              {3,{4,3},    2} }, -- negative st
-  { {".+"},               {"abcd",5},               {N }            }, -- failing st
-  { {".*"},               {"abcd"},                 {1,{4,3,2,1,0},5}}, -- [none]
-  { {".*?"},              {"abcd"},                 {1,{4,3,2,1,0},5}}, -- non-greedy
-  { {"aBC",flg.CASELESS}, {"abc"},                  {1,{3},1}  }, -- cf
-  { {"aBC","i"         }, {"abc"},                  {1,{3},1}  }, -- cf
-  { {"bc"},               {"abc"},                  {2,{3},1}  }, -- [none]
-  { {"bc",flg.ANCHORED},  {"abc"},                  {N }       }, -- cf
-  { {"bc"},               {"abc",N, flg.ANCHORED},  {N }       }, -- ef
-  { { "(.)b.(d)"},        {"abcd"},                 {1,{4},1}  }, --[captures]
-  { {"abc"},              {"ab"},                   {N }       },
-  { {"abc"},              {"abc",N,flg.PARTIAL},    {1,{3},1}  },
-  { {"abc*"},             {"abcc",N,flg.PARTIAL},   {1,{4,3,2},3} },
-  { {"abc"},              {"ab",N,flg.PARTIAL},     {true} },
-  { {"bc"},               {"ab",N,flg.PARTIAL},     {true} },
-}
-end
-
-local function get_gsub (lib)
-  return lib.gsub or
-    function (subj, pattern, repl, n)
-      return lib.new (pattern) : gsub (subj, repl, n)
-    end
-end
-
--- sadly, glib *always* sets the PCRE_UCP compilation flag, regardless
--- of REGEX_RAW being set - this is, frankly, a bug in my opinion
--- but anyway, it means things like '[:alpha:]' and '\w' match things that Lua's
--- '%a' does not match
-local function set_f_gsub7 (lib, flg)
-  local subj = ""
-  for i = 0, 255 do
-    subj = subj .. string.char (i)
-  end
-
-  -- This set requires calling prepare_set before calling gsub_test
-  local set = {
-    Name = "Function gsub, set7 for glib",
-    Func = get_gsub (lib),
-  --{ s,     p,    f, n, },
-    { {subj, "[a-zA-Z]", "" }, },
-    { {subj, "[^a-zA-Z]", "" }, },
-    { {subj, "%c", "" }, },
-    { {subj, "%C", "" }, },
-    { {subj, "[a-z]", "" }, },
-    { {subj, "[^a-z]", "" }, },
-    { {subj, "%d", "" }, },
-    { {subj, "%D", "" }, },
-    { {subj, "%p", "" }, },
-    { {subj, "%P", "" }, },
---  { {subj, "%s", "" }, },
---  { {subj, "%S", "" }, },
-    { {subj, "[A-Z]", "" }, },
-    { {subj, "[^A-Z]", "" }, }, -- 10
-    { {subj, "[a-zA-Z0-9]", "" }, },
-    { {subj, "[^a-zA-Z0-9]", "" }, },
-    { {subj, "%x", "" }, },
-    { {subj, "%X", "" }, },
-    { {subj, "%z", "" }, },
-    { {subj, "%Z", "" }, },
-
---  { {subj, "[%a]", "" }, },
---  { {subj, "[%A]", "" }, },
-    { {subj, "[%c]", "" }, },
-    { {subj, "[%C]", "" }, },
-    { {subj, "[%d]", "" }, },
-    { {subj, "[%D]", "" }, },
---  { {subj, "[%l]", "" }, },
---  { {subj, "[%L]", "" }, },
-    { {subj, "[%p]", "" }, },
-    { {subj, "[%P]", "" }, },
---  { {subj, "[%u]", "" }, },
---  { {subj, "[%U]", "" }, },
---  { {subj, "[%w]", "" }, },
---  { {subj, "[%W]", "" }, },
-    { {subj, "[%x]", "" }, },
-    { {subj, "[%X]", "" }, },
-    { {subj, "[%z]", "" }, },
-    { {subj, "[%Z]", "" }, },
-
---  { {subj, "[%a_]", "" }, },
---  { {subj, "[%A_]", "" }, },
-    { {subj, "[%c_]", "" }, },
-    { {subj, "[%C_]", "" }, },
---  { {subj, "[%l_]", "" }, },
---  { {subj, "[%L_]", "" }, },
-    { {subj, "[%p_]", "" }, },
-    { {subj, "[%P_]", "" }, },
---  { {subj, "[%u_]", "" }, },
---  { {subj, "[%U_]", "" }, },
---  { {subj, "[%w_]", "" }, },
---  { {subj, "[%W_]", "" }, },
-    { {subj, "[%x_]", "" }, },
-    { {subj, "[%X_]", "" }, },
-    { {subj, "[%z_]", "" }, },
-    { {subj, "[%Z_]", "" }, },
-
---  { {subj, "[%a%d]", "" }, },
---  { {subj, "[%A%d]", "" }, },
-    { {subj, "[%c%d]", "" }, },
-    { {subj, "[%C%d]", "" }, },
---  { {subj, "[%l%d]", "" }, },
---  { {subj, "[%L%d]", "" }, },
-    { {subj, "[%p%d]", "" }, },
-    { {subj, "[%P%d]", "" }, },
---  { {subj, "[%u%d]", "" }, },
---  { {subj, "[%U%d]", "" }, },
---  { {subj, "[%w%d]", "" }, },
---  { {subj, "[%W%d]", "" }, },
-    { {subj, "[%x%d]", "" }, },
-    { {subj, "[%X%d]", "" }, },
-    { {subj, "[%z%d]", "" }, },
-    { {subj, "[%Z%d]", "" }, },
-
---  { {subj, "[^%a%d]", "" }, },
---  { {subj, "[^%A%d]", "" }, },
-    { {subj, "[^%c%d]", "" }, },
-    { {subj, "[^%C%d]", "" }, },
---  { {subj, "[^%l%d]", "" }, },
---  { {subj, "[^%L%d]", "" }, },
-    { {subj, "[^%p%d]", "" }, },
-    { {subj, "[^%P%d]", "" }, },
---  { {subj, "[^%u%d]", "" }, },
---  { {subj, "[^%U%d]", "" }, },
---  { {subj, "[^%w%d]", "" }, },
---  { {subj, "[^%W%d]", "" }, },
-    { {subj, "[^%x%d]", "" }, },
-    { {subj, "[^%X%d]", "" }, },
-    { {subj, "[^%z%d]", "" }, },
-    { {subj, "[^%Z%d]", "" }, },
-
---  { {subj, "[^%a_]", "" }, },
---  { {subj, "[^%A_]", "" }, },
-    { {subj, "[^%c_]", "" }, },
-    { {subj, "[^%C_]", "" }, },
---  { {subj, "[^%l_]", "" }, },
---  { {subj, "[^%L_]", "" }, },
-    { {subj, "[^%p_]", "" }, },
-    { {subj, "[^%P_]", "" }, },
---  { {subj, "[^%u_]", "" }, },
---  { {subj, "[^%U_]", "" }, },
---  { {subj, "[^%w_]", "" }, },
---  { {subj, "[^%W_]", "" }, },
-    { {subj, "[^%x_]", "" }, },
-    { {subj, "[^%X_]", "" }, },
-    { {subj, "[^%z_]", "" }, },
-    { {subj, "[^%Z_]", "" }, },
-
-    { {subj, "\100",          "" }, },
-    { {subj, "[\100]",        "" }, },
-    { {subj, "[^\100]",       "" }, },
-    { {subj, "[\100-\200]",   "" }, },
-    { {subj, "[^\100-\200]",  "" }, },
-    { {subj, "\100a",         "" }, },
-    { {subj, "[\100a]",       "" }, },
-    { {subj, "[^\100a]",      "" }, },
-    { {subj, "[\100-\200a]",  "" }, },
-    { {subj, "[^\100-\200a]", "" }, },
-  }
-  -- fill in reference results
-  for _,v in ipairs(set) do
-    local r0, r1, r2 = pcall (string.gsub, unpack (v[1]))
-    v[2] = r0 and { r1, r2, r2 } or { r0, r1 }
-  end
-  -- convert patterns: lua -> pcre
-  for _, test in ipairs (set) do
-    test[1][2] = pat2pcre (test[1][2])
-  end
-  return set
-end
-
-return function (libname, isglobal)
-  local lib = isglobal and _G[libname] or require (libname)
-  local flags = lib.flags and lib.flags ()
-  local sets = {
-    set_m_dfa_exec (lib, flags),
-    set_f_gsub7 (lib, flags)
-  }
-  return sets
-end
diff --git a/test/lua/globals_2.2.txt b/test/lua/globals_2.2.txt
index a6d3ab5231..baafc7e3b4 100644
--- a/test/lua/globals_2.2.txt
+++ b/test/lua/globals_2.2.txt
@@ -298,20 +298,6 @@
             ["__typeof"] = "FrameInfoConst"
         }
     },
-    ["GRegex"] = {
-        ["_VERSION"] = "Lrexlib 2.7.2 (for GLib Regex)",
-        ["__typeof"] = "GRegex",
-        ["compile_flags"] = '<function 135>',
-        ["find"] = '<function 136>',
-        ["flags"] = '<function 137>',
-        ["gmatch"] = '<function 138>',
-        ["gsub"] = '<function 139>',
-        ["match"] = '<function 140>',
-        ["match_flags"] = '<function 141>',
-        ["new"] = '<function 142>',
-        ["split"] = '<function 143>',
-        ["version"] = '<function 144>'
-    },
     ["GUI_ENABLED"] = false,
     ["H225_ALERTING"] = 3,
     ["H225_CALL_PROCEDING"] = 1,
diff --git a/test/lua/gregex.lua b/test/lua/gregex.lua
deleted file mode 100644
index fe89607a7e..0000000000
--- a/test/lua/gregex.lua
+++ /dev/null
@@ -1,291 +0,0 @@
-
--- 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")
diff --git a/test/lua/luatest.lua b/test/lua/luatest.lua
deleted file mode 100644
index 617329c9c6..0000000000
--- a/test/lua/luatest.lua
+++ /dev/null
@@ -1,174 +0,0 @@
--- See Copyright Notice in the file LICENSE
-
--- arrays: deep comparison
-local function eq (t1, t2, lut)
-  if t1 == t2 then return true end
-  if type(t1) ~= "table" or type(t2) ~= "table" or #t1 ~= #t2 then
-    return false
-  end
-
-  lut = lut or {} -- look-up table: are these 2 arrays already compared?
-  lut[t1] = lut[t1] or {}
-  if lut[t1][t2] then return true end
-  lut[t2] = lut[t2] or {}
-  lut[t1][t2], lut[t2][t1] = true, true
-
-  for k,v in ipairs (t1) do
-    if not eq (t2[k], v, lut) then return false end -- recursion
-  end
-  return true
-end
-
--- a "nil GUID", to be used instead of nils in datasets
-local NT = "b5f74fe5-46f4-483a-8321-e58ba2fa0e17"
-
--- pack vararg in table, replacing nils with "NT" items
-local function packNT (...)
-  local t = {}
-  for i=1, select ("#", ...) do
-    local v = select (i, ...)
-    t[i] = (v == nil) and NT or v
-  end
-  return t
-end
-
--- unpack table into vararg, replacing "NT" items with nils
-local function unpackNT (t)
-  local len = #t
-  local function unpack_from (i)
-    local v = t[i]
-    if v == NT then v = nil end
-    if i == len then return v end
-    return v, unpack_from (i+1)
-  end
-  if len > 0 then return unpack_from (1) end
-end
-
--- print results (deep into arrays)
-local function print_results (val, indent, lut)
-  indent = indent or ""
-  lut = lut or {} -- look-up table
-  local str = tostring (val)
-  if type (val) == "table" then
-    if lut[val] then
-      io.write (indent, str, "\n")
-    else
-      lut[val] = true
-      io.write (indent, str, "\n")
-      for i,v in ipairs (val) do
-        print_results (v, "  " .. indent, lut) -- recursion
-      end
-    end
-  else
-    io.write (indent, val == NT and "nil" or str, "\n")
-  end
-end
-
--- returns:
---  1) true, if success; false, if failure
---  2) test results table or error_message
-local function test_function (test, func)
-  local res
-  local t = packNT (pcall (func, unpackNT (test[1])))
-  if t[1] then
-    table.remove (t, 1)
-    res = t
-    if alien then
-      local subject = test[1][1]
-      local buf = alien.buffer (#subject)
-      if #subject > 0 then
-        alien.memmove (buf:topointer (), subject, #subject)
-      end
-      test[1][1] = buf
-      local t = packNT (pcall (func, unpackNT (test[1])))
-      if t[1] then
-        table.remove (t, 1)
-        res = t
-      else
-        print "alien test failed"
-        res = t[2] --> error_message
-      end
-    end
-  else
-    res = t[2] --> error_message
-  end
-  local how = (type (res) == type (test[2])) and
-    (type (res) == "string" or eq (res, test[2])) -- allow error messages to differ
-  return how, res
-end
-
--- returns:
---  1) true, if success; false, if failure
---  2) test results table or error_message
---  3) test results table or error_message
-local function test_method (test, constructor, name)
-  local res1, res2
-  local subject = test[2][1]
-  local ok, r = pcall (constructor, unpackNT (test[1]))
-  if ok then
-    local t = packNT (pcall (r[name], r, unpackNT (test[2])))
-    if t[1] then
-      table.remove (t, 1)
-      res1, res2 = t
-    else
-      res1, res2 = 2, t[2] --> 2, error_message
-    end
-  else
-    res1, res2 = 1, r  --> 1, error_message
-  end
-  return eq (res1, test[3]), res1, res2
-end
-
--- returns: a list of failed tests
-local function test_set (set, lib, verbose)
-  local list = {}
-
-  if type (set.Func) == "function" then
-    local func = set.Func
-
-    for i,test in ipairs (set) do
-      if verbose then
-        io.write ("    running function test "..i.."...")
-        io.flush ()
-      end
-      local ok, res = test_function (test, func)
-      if not ok then
-        if verbose then io.stdout:write("failed!\n") end
-        table.insert (list, {i=i, test[2], res})
-      elseif verbose then
-        io.write ("passed\n")
-        io.flush ()
-      end
-    end
-
-  elseif type (set.Method) == "string" then
-    for i,test in ipairs (set) do
-      if verbose then
-        io.write ("    running method test "..i.."...")
-        io.flush ()
-      end
-      local ok, res1, res2 = test_method (test, lib.new, set.Method)
-      if not ok then
-        if verbose then io.stdout:write("failed!\n") end
-        table.insert (list, {i=i, test[3], res1, res2})
-      elseif verbose then
-        io.write ("passed\n")
-        io.flush ()
-      end
-    end
-
-  else
-    error ("neither set.Func nor set.Method is valid")
-  end
-
-  return list
-end
-
-return {
-  eq = eq,
-  NT = NT,
-  print_results = print_results,
-  test_function = test_function,
-  test_method = test_method,
-  test_set = test_set,
-}
diff --git a/test/lua/pat2pcre.lua b/test/lua/pat2pcre.lua
deleted file mode 100644
index 2d60a443b2..0000000000
--- a/test/lua/pat2pcre.lua
+++ /dev/null
@@ -1,87 +0,0 @@
--- See Copyright Notice in the file lrexlib.h
-
--- Convert Lua regex pattern to its PCRE equivalent.
-
-local t_esc = {
-  a = "[:alpha:]",
-  A = "[:^alpha:]",
-  c = "[:cntrl:]",
-  C = "[:^cntrl:]",
-  d = "[:digit:]",
-  D = "[:^digit:]",
-  l = "[:lower:]",
-  L = "[:^lower:]",
-  p = "[:punct:]",
-  P = "[:^punct:]",
-  s = "[:space:]",
-  S = "[:^space:]",
-  u = "[:upper:]",
-  U = "[:^upper:]",
-  w = "[:alnum:]",
-  W = "[:^alnum:]",
-  x = "[:xdigit:]",
-  X = "[:^xdigit:]",
-  z = "\\x00",
-  Z = "\\x01-\\xFF",
-}
-
-local function rep_normal (ch)
-  assert (ch ~= "b", "\"%b\" subpattern is not supported")
-  assert (ch ~= "0", "invalid capture index")
-  local v = t_esc[ch]
-  return v and ("[" .. v .. "]") or ("\\" .. ch)
-end
-
-local function rep_charclass (ch)
-  return t_esc[ch] or ("\\" .. ch)
-end
-
-function pat2pcre (s)
-  local ind = 0
-
-  local function getc ()
-    ind = ind + 1
-    return string.sub (s, ind, ind)
-  end
-
-  local function getnum ()
-    local num = string.match (s, "^\\(%d%d?%d?)", ind)
-    if num then
-      ind = ind + #num
-      return string.format ("\\x%02X", num)
-    end
-  end
-
-  local out, state = "", "normal"
-  while ind < #s do
-    local ch = getc ()
-    if state == "normal" then
-      if ch == "%" then
-        out = out .. rep_normal (getc ())
-      elseif ch == "-" then
-        out = out .. "*?"
-      elseif ch == "." then
-        out = out .. "\\C"
-      elseif ch == "[" then
-        out = out .. ch
-        state = "charclass"
-      else
-        local num = getnum ()
-        out = num and (out .. num) or (out .. ch)
-      end
-    elseif state == "charclass" then
-      if ch == "%" then
-        out = out .. rep_charclass (getc ())
-      elseif ch == "]" then
-        out = out .. ch
-        state = "normal"
-      else
-        local num = getnum ()
-        out = num and (out .. num) or (out .. ch)
-      end
-    end
-  end
-  return out
-end
-
-return pat2pcre
diff --git a/test/lua/pcre_sets.lua b/test/lua/pcre_sets.lua
deleted file mode 100644
index d1e50390cc..0000000000
--- a/test/lua/pcre_sets.lua
+++ /dev/null
@@ -1,179 +0,0 @@
--- See Copyright Notice in the file lrexlib.h
-
-local luatest = require "luatest"
-local N = luatest.NT
-
-local function norm(a) return a==nil and N or a end
-
-local function fill (n, m)
-  local t = {}
-  for i = n, m, -1 do table.insert (t, i) end
-  return t
-end
-
-local function set_named_subpatterns (lib, flg)
-  return {
-    Name = "Named Subpatterns",
-    Func = function (subj, methodname, patt, name1, name2)
-      local r = lib.new (patt)
-      local _,_,caps = r[methodname] (r, subj)
-      return norm(caps[name1]), norm(caps[name2])
-    end,
-    --{} N.B. subject is always first element
-    { {"abcd", "tfind", "(?P<dog>.)b.(?P<cat>d)", "dog", "cat"},  {"a","d"} },
-    { {"abcd", "exec",  "(?P<dog>.)b.(?P<cat>d)", "dog", "cat"},  {"a","d"} },
-  }
-end
-
-local function set_f_find (lib, flg)
-  local cp1251 =
-    "ÀÁÂÃÄŨÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÜÛÚÝÞßàáâãäå¸æçèéêëìíîïðñòóôõö÷øùüûúýþÿ"
-  local loc = "Russian_Russia.1251"
-  return {
-  Name = "Function find",
-  Func = lib.find,
-  --{subj,   patt,      st,cf,ef,lo},        { results }
-  { {"abcd", ".+",      5},                  { N   } }, -- failing st
-  { {"abcd", ".*?"},                         { 1,0 } }, -- non-greedy
-  { {"abc",  "aBC",     N,flg.CASELESS},     { 1,3 } }, -- cf
-  { {"abc",  "aBC",     N,"i"         },     { 1,3 } }, -- cf
-  { {"abc",  "bc",      N,flg.ANCHORED},     { N   } }, -- cf
-  { {"abc",  "bc",      N,N,flg.ANCHORED},   { N   } }, -- ef
---{ {cp1251, "[[:upper:]]+", N,N,N, loc},    { 1,33} }, -- locale
---{ {cp1251, "[[:lower:]]+", N,N,N, loc},    {34,66} }, -- locale
-}
-end
-
-local function set_f_match (lib, flg)
-  return {
-  Name = "Function match",
-  Func = lib.match,
-  --{subj,   patt,      st,cf,ef,lo},        { results }
-  { {"abcd", ".+",      5},                  { N    }}, -- failing st
-  { {"abcd", ".*?"},                         { ""   }}, -- non-greedy
-  { {"abc",  "aBC",     N,flg.CASELESS},     {"abc" }}, -- cf
-  { {"abc",  "aBC",     N,"i"         },     {"abc" }}, -- cf
-  { {"abc",  "bc",      N,flg.ANCHORED},     { N    }}, -- cf
-  { {"abc",  "bc",      N,N,flg.ANCHORED},   { N    }}, -- ef
-}
-end
-
-local function set_f_gmatch (lib, flg)
-  -- gmatch (s, p, [cf], [ef])
-  local pCSV = "(^[^,]*)|,([^,]*)"
-  local F = false
-  local function test_gmatch (subj, patt)
-    local out, guard = {}, 10
-    for a, b in lib.gmatch (subj, patt) do
-      table.insert (out, { norm(a), norm(b) })
-      guard = guard - 1
-      if guard == 0 then break end
-    end
-    return unpack (out)
-  end
-  return {
-    Name = "Function gmatch",
-    Func = test_gmatch,
-  --{  subj             patt   results }
-    { {"a\0c",          "." }, {{"a",N},{"\0",N},{"c",N}} },--nuls in subj
-    { {"",              pCSV}, {{"",F}} },
-    { {"12",            pCSV}, {{"12",F}} },
-    { {",",             pCSV}, {{"", F},{F,""}} },
-    { {"12,,45",        pCSV}, {{"12",F},{F,""},{F,"45"}} },
-    { {",,12,45,,ab,",  pCSV}, {{"",F},{F,""},{F,"12"},{F,"45"},{F,""},{F,"ab"},{F,""}} },
-  }
-end
-
-local function set_f_split (lib, flg)
-  -- split (s, p, [cf], [ef])
-  local function test_split (subj, patt)
-    local out, guard = {}, 10
-    for a, b, c in lib.split (subj, patt) do
-      table.insert (out, { norm(a), norm(b), norm(c) })
-      guard = guard - 1
-      if guard == 0 then break end
-    end
-    return unpack (out)
-  end
-  return {
-    Name = "Function split",
-    Func = test_split,
-  --{  subj             patt      results }
-    { {"a,\0,c",       ","},     {{"a",",",N},{"\0",",",N},{"c",N,N},   } },--nuls in subj
-    { {"ab",           "$"},     {{"ab","",N}, {"",N,N},               } },
-    { {"ab",         "^|$"},     {{"", "", N}, {"ab","",N},  {"",N,N}, } },
-    { {"ab45ab","(?<=ab).*?"},   {{"ab","",N}, {"45ab","",N},{"",N,N}, } },
-    { {"ab",         "\\b"},     {{"", "", N}, {"ab","",N},  {"",N,N}, } },
-  }
-end
-
-local function set_m_exec (lib, flg)
-  return {
-  Name = "Method exec",
-  Method = "exec",
---{patt,cf,lo},           {subj,st,ef}              { results }
-  { {".+"},               {"abcd",5},               { N }    }, -- failing st
-  { {".*?"},              {"abcd"},                 {1,0,{}} }, -- non-greedy
-  { {"aBC",flg.CASELESS}, {"abc"},                  {1,3,{}} }, -- cf
-  { {"aBC","i"         }, {"abc"},                  {1,3,{}} }, -- cf
-  { {"bc",flg.ANCHORED},  {"abc"},                  { N }    }, -- cf
-  { {"bc"},               {"abc",N, flg.ANCHORED},  { N }    }, -- ef
-}
-end
-
-local function set_m_tfind (lib, flg)
-  return {
-  Name = "Method tfind",
-  Method = "tfind",
---{patt,cf,lo},           {subj,st,ef}              { results }
-  { {".+"},               {"abcd",5},               { N }    }, -- failing st
-  { {".*?"},              {"abcd"},                 {1,0,{}} }, -- non-greedy
-  { {"aBC",flg.CASELESS}, {"abc"},                  {1,3,{}} }, -- cf
-  { {"aBC","i"         }, {"abc"},                  {1,3,{}} }, -- cf
-  { {"bc",flg.ANCHORED},  {"abc"},                  { N }    }, -- cf
-  { {"bc"},               {"abc",N, flg.ANCHORED},  { N }    }, -- ef
-}
-end
-
-local function set_m_dfa_exec (lib, flg)
-  return {
-  Name = "Method dfa_exec",
-  Method = "dfa_exec",
---{patt,cf,lo},           {subj,st,ef,os,ws}        { results }
-  { {".+"},               {"abcd"},                 {1,{4,3,2,1},4} }, -- [none]
-  { {".+"},               {"abcd",2},               {2,{4,3,2},  3} }, -- positive st
-  { {".+"},               {"abcd",-2},              {3,{4,3},    2} }, -- negative st
-  { {".+"},               {"abcd",5},               {N }            }, -- failing st
-  { {".*"},               {"abcd"},                 {1,{4,3,2,1,0},5}}, -- [none]
-  { {".*?"},              {"abcd"},                 {1,{4,3,2,1,0},5}}, -- non-greedy
-  { {"aBC",flg.CASELESS}, {"abc"},                  {1,{3},1}  }, -- cf
-  { {"aBC","i"         }, {"abc"},                  {1,{3},1}  }, -- cf
-  { {"bc"},               {"abc"},                  {2,{3},1}  }, -- [none]
-  { {"bc",flg.ANCHORED},  {"abc"},                  {N }       }, -- cf
-  { {"bc"},               {"abc",N, flg.ANCHORED},  {N }       }, -- ef
-  { { "(.)b.(d)"},        {"abcd"},                 {1,{4},1}  }, --[captures]
-  { {"abc"},              {"ab"},                   {N }       },
-  { {"abc"},              {"ab",N,flg.PARTIAL},     {1,{2},flg.ERROR_PARTIAL} },
-  { {".+"},     {string.rep("a",50),N,N,50,50},     {1, fill(50,26), 0}},-- small ovecsize
-}
-end
-
-return function (libname, isglobal)
-  local lib = isglobal and _G[libname] or require (libname)
-  local flags = lib.flags ()
-  local sets = {
-    set_f_match  (lib, flags),
-    set_f_find   (lib, flags),
-    set_f_gmatch (lib, flags),
-    set_f_split  (lib, flags),
-    set_m_exec   (lib, flags),
-    set_m_tfind  (lib, flags),
-  }
-  if flags.MAJOR >= 4 then
-    table.insert (sets, set_named_subpatterns (lib, flags))
-  end
-  if flags.MAJOR >= 6 then
-    table.insert (sets, set_m_dfa_exec (lib, flags))
-  end
-  return sets
-end
diff --git a/test/lua/pcre_sets2.lua b/test/lua/pcre_sets2.lua
deleted file mode 100644
index c0c8d7a5b9..0000000000
--- a/test/lua/pcre_sets2.lua
+++ /dev/null
@@ -1,198 +0,0 @@
--- See Copyright Notice in the file LICENSE
-
-local pat2pcre = require "pat2pcre"
-
-local function get_gsub (lib)
-  return lib.gsub or
-    function (subj, pattern, repl, n)
-      return lib.new (pattern) : gsub (subj, repl, n)
-    end
-end
-
-local function set_f_gsub1 (lib, flg)
-  local subj, pat = "abcdef", "[abef]+"
-  return {
-    Name = "Function gsub, set1",
-    Func = get_gsub (lib),
-  --{ s,       p,    f,   n,    res1,  res2, res3 },
-    { {"a\0c", ".",  "#"   },   {"###",   3, 3} }, -- subj contains nuls
-  }
-end
-
-local function set_f_gsub4 (lib, flg)
-  local pCSV = "(^[^,]*)|,([^,]*)"
-  local fCSV = function (a,b) return "["..(a or b).."]" end
-  local set = {
-    Name = "Function gsub, set4",
-    Func = get_gsub (lib),
-  --{ s,           p,              f, n,  res1,      res2, res3 },
-    { {"/* */ */", "%/%*(.*)%*%/", "#" }, {"#",         1, 1} },
-    { {"a2c3",     ".-",           "#" }, {"#########", 9, 9} }, -- test .-
-    { {"/**/",     "%/%*(.-)%*%/", "#" }, {"#",         1, 1} },
-    { {"/* */ */", "%/%*(.-)%*%/", "#" }, {"# */",      1, 1} },
-    { {"a2c3",     "%d",           "#" }, {"a#c#",      2, 2} }, -- test %d
-    { {"a2c3",     "%D",           "#" }, {"#2#3",      2, 2} }, -- test %D
-    { {"a \t\nb",  "%s",           "#" }, {"a###b",     3, 3} }, -- test %s
-    { {"a \t\nb",  "%S",           "#" }, {"# \t\n#",   2, 2} }, -- test %S
-    { {"abcd",     "\\b",          "%1"}, {"abcd",      2, 2} },
-    { {"",                    pCSV,fCSV}, {"[]",        1, 1} },
-    { {"123",                 pCSV,fCSV}, {"[123]",     1, 1} },
-    { {",",                   pCSV,fCSV}, {"[][]",      2, 2} },
-    { {"123,,456",            pCSV,fCSV}, {"[123][][456]", 3, 3}},
-    { {",,123,456,,abc,789,", pCSV,fCSV}, {"[][][123][456][][abc][789][]", 8, 8}},
-  }
-  -- convert patterns: lua -> pcre
-  for _, test in ipairs (set) do
-    test[1][2] = pat2pcre (test[1][2])
-  end
-  return set
-end
-
-local function set_f_gsub7 (lib, flg)
-  local subj = ""
-  for i = 0, 255 do
-    subj = subj .. string.char (i)
-  end
-
-  -- This set requires calling prepare_set before calling gsub_test
-  local set = {
-    Name = "Function gsub, set7",
-    Func = get_gsub (lib),
-  --{ s,     p,    f, n, },
-    { {subj, "%a", "" }, },
-    { {subj, "%A", "" }, },
-    { {subj, "%c", "" }, },
-    { {subj, "%C", "" }, },
-    { {subj, "%l", "" }, },
-    { {subj, "%L", "" }, },
-    { {subj, "%p", "" }, },
-    { {subj, "%P", "" }, },
-    { {subj, "%u", "" }, },
-    { {subj, "%U", "" }, },
-    { {subj, "%w", "" }, },
-    { {subj, "%W", "" }, },
-    { {subj, "%x", "" }, },
-    { {subj, "%X", "" }, },
-    { {subj, "%z", "" }, },
-    { {subj, "%Z", "" }, },
-
-    { {subj, "[%a]", "" }, },
-    { {subj, "[%A]", "" }, },
-    { {subj, "[%c]", "" }, },
-    { {subj, "[%C]", "" }, },
-    { {subj, "[%l]", "" }, },
-    { {subj, "[%L]", "" }, },
-    { {subj, "[%p]", "" }, },
-    { {subj, "[%P]", "" }, },
-    { {subj, "[%u]", "" }, },
-    { {subj, "[%U]", "" }, },
-    { {subj, "[%w]", "" }, },
-    { {subj, "[%W]", "" }, },
-    { {subj, "[%x]", "" }, },
-    { {subj, "[%X]", "" }, },
-    { {subj, "[%z]", "" }, },
-    { {subj, "[%Z]", "" }, },
-
-    { {subj, "[%a_]", "" }, },
-    { {subj, "[%A_]", "" }, },
-    { {subj, "[%c_]", "" }, },
-    { {subj, "[%C_]", "" }, },
-    { {subj, "[%l_]", "" }, },
-    { {subj, "[%L_]", "" }, },
-    { {subj, "[%p_]", "" }, },
-    { {subj, "[%P_]", "" }, },
-    { {subj, "[%u_]", "" }, },
-    { {subj, "[%U_]", "" }, },
-    { {subj, "[%w_]", "" }, },
-    { {subj, "[%W_]", "" }, },
-    { {subj, "[%x_]", "" }, },
-    { {subj, "[%X_]", "" }, },
-    { {subj, "[%z_]", "" }, },
-    { {subj, "[%Z_]", "" }, },
-
-    { {subj, "[%a%d]", "" }, },
-    { {subj, "[%A%d]", "" }, },
-    { {subj, "[%c%d]", "" }, },
-    { {subj, "[%C%d]", "" }, },
-    { {subj, "[%l%d]", "" }, },
-    { {subj, "[%L%d]", "" }, },
-    { {subj, "[%p%d]", "" }, },
-    { {subj, "[%P%d]", "" }, },
-    { {subj, "[%u%d]", "" }, },
-    { {subj, "[%U%d]", "" }, },
-    { {subj, "[%w%d]", "" }, },
-    { {subj, "[%W%d]", "" }, },
-    { {subj, "[%x%d]", "" }, },
-    { {subj, "[%X%d]", "" }, },
-    { {subj, "[%z%d]", "" }, },
-    { {subj, "[%Z%d]", "" }, },
-
-    { {subj, "[^%a%d]", "" }, },
-    { {subj, "[^%A%d]", "" }, },
-    { {subj, "[^%c%d]", "" }, },
-    { {subj, "[^%C%d]", "" }, },
-    { {subj, "[^%l%d]", "" }, },
-    { {subj, "[^%L%d]", "" }, },
-    { {subj, "[^%p%d]", "" }, },
-    { {subj, "[^%P%d]", "" }, },
-    { {subj, "[^%u%d]", "" }, },
-    { {subj, "[^%U%d]", "" }, },
-    { {subj, "[^%w%d]", "" }, },
-    { {subj, "[^%W%d]", "" }, },
-    { {subj, "[^%x%d]", "" }, },
-    { {subj, "[^%X%d]", "" }, },
-    { {subj, "[^%z%d]", "" }, },
-    { {subj, "[^%Z%d]", "" }, },
-
-    { {subj, "[^%a_]", "" }, },
-    { {subj, "[^%A_]", "" }, },
-    { {subj, "[^%c_]", "" }, },
-    { {subj, "[^%C_]", "" }, },
-    { {subj, "[^%l_]", "" }, },
-    { {subj, "[^%L_]", "" }, },
-    { {subj, "[^%p_]", "" }, },
-    { {subj, "[^%P_]", "" }, },
-    { {subj, "[^%u_]", "" }, },
-    { {subj, "[^%U_]", "" }, },
-    { {subj, "[^%w_]", "" }, },
-    { {subj, "[^%W_]", "" }, },
-    { {subj, "[^%x_]", "" }, },
-    { {subj, "[^%X_]", "" }, },
-    { {subj, "[^%z_]", "" }, },
-    { {subj, "[^%Z_]", "" }, },
-
-    { {subj, "\100",          "" }, },
-    { {subj, "[\100]",        "" }, },
-    { {subj, "[^\100]",       "" }, },
-    { {subj, "[\100-\200]",   "" }, },
-    { {subj, "[^\100-\200]",  "" }, },
-    { {subj, "\100a",         "" }, },
-    { {subj, "[\100a]",       "" }, },
-    { {subj, "[^\100a]",      "" }, },
-    { {subj, "[\100-\200a]",  "" }, },
-    { {subj, "[^\100-\200a]", "" }, },
-  }
-  -- fill in reference results
-  for _,v in ipairs(set) do
-    local r0, r1, r2 = pcall (string.gsub, unpack (v[1]))
-    v[2] = r0 and { r1, r2, r2 } or { r0, r1 }
-  end
-  -- convert patterns: lua -> pcre
-  for _, test in ipairs (set) do
-    test[1][2] = pat2pcre (test[1][2])
-  end
-  return set
-end
-
-return function (libname, isglobal)
-  local lib = isglobal and _G[libname] or require (libname)
-  local flags = lib.flags and lib.flags ()
-  local sets = {
-    set_f_gsub1 (lib, flags),
-    set_f_gsub4 (lib, flags),
-  }
-  if flags.MAJOR*100 + flags.MINOR > 405 then
-    table.insert (sets, set_f_gsub7 (lib, flags))
-  end
-  return sets
-end
diff --git a/test/suite_wslua.py b/test/suite_wslua.py
index e5a421825d..a564860189 100644
--- a/test/suite_wslua.py
+++ b/test/suite_wslua.py
@@ -261,15 +261,6 @@ class case_wslua(subprocesstest.SubprocessTestCase):
             '-X', 'lua_script1:' + os.path.join(dirs.lua_dir, 'globals_2.2.txt'),
         )
 
-#    @unittest.skip('GRegex tests are broken since PCRE 8.34, see bug 12997.')
-#    def test_wslua_gregex(self, check_lua_script, dirs):
-#        '''wslua GRegex'''
-#        check_lua_script(self, 'gregex.lua', empty_pcap, True,
-#            '-X', 'lua_script1:-d' + os.path.join(dirs.lua_dir, ''),
-#            '-X', 'lua_script1:glib',
-#            '-X', 'lua_script1:-V',
-#        )
-
     def test_wslua_struct(self, check_lua_script):
         '''wslua struct'''
         check_lua_script(self, 'struct.lua', empty_pcap, True)