1 files changed, 0 insertions, 504 deletions

diff --git a/LuaSL/testLua/yueliang-0.4.1/orig-5.0.3/test/test_llex.lua b/LuaSL/testLua/yueliang-0.4.1/orig-5.0.3/test/test_llex.lua
deleted file mode 100644
index 6bc834d..0000000
--- a/LuaSL/testLua/yueliang-0.4.1/orig-5.0.3/test/test_llex.lua
+++ /dev/null
@@ -1,504 +0,0 @@
---[[--------------------------------------------------------------------
-
-  test_llex.lua
-  Test for llex.lua
-  This file is part of Yueliang.
-
-  Copyright (c) 2005-2006 Kein-Hong Man <khman@users.sf.net>
-  The COPYRIGHT file describes the conditions
-  under which this software may be distributed.
-
-  See the ChangeLog for more information.
-
-----------------------------------------------------------------------]]
-
-------------------------------------------------------------------------
--- if BRIEF is not set to false, auto-test will silently succeed
-------------------------------------------------------------------------
-BRIEF = true  -- if set to true, messages are less verbose
-
-require("../lzio")
-require("../llex")
-luaX:init()
-
-------------------------------------------------------------------------
--- simple manual tests
-------------------------------------------------------------------------
-
---[[
-local L = {} -- LuaState
-local LS = {} -- LexState
-
-local function dump(z)
-  luaX:setinput(L, LS, z, z.name)
-  while true do
-    LS.t.token = luaX:lex(LS, LS.t)
-    local tok, seminfo = LS.t.token, LS.t.seminfo
-    if tok == "TK_NAME" then
-      seminfo = " "..seminfo
-    elseif tok == "TK_NUMBER" then
-      seminfo = " "..seminfo
-    elseif tok == "TK_STRING" then
-      seminfo = " '"..seminfo.."'"
-    else
-      seminfo = ""
-    end
-    io.stdout:write(tok..seminfo.."\n")
-    if tok == "TK_EOS" then break end
-  end
-end
-
-local function try_string(chunk)
-  dump(luaZ:init(luaZ:make_getS(chunk), nil, "=string"))
-end
-local function try_file(filename)
-  dump(luaZ:init(luaZ:make_getF(filename), nil, filename))
-end
-
-z = try_string("local c = luaZ:zgetc(z)")
-z = try_file("test_lzio.lua")
-z = try_file("test_llex.lua")
-os.exit()
---]]
-
-------------------------------------------------------------------------
--- auto-testing of simple test cases to validate lexer behaviour:
--- * NOTE coverage has not been checked; not comprehensive
--- * only test cases with non-empty comments are processed
--- * if no result, then the output is displayed for manual decision
---   (output may be used to set expected success or fail text)
--- * cases expected to be successful may be a partial match
--- * cases expected to fail may also be a partial match
-------------------------------------------------------------------------
-
--- [[
-local function auto_test()
-  local PASS, FAIL = true, false
-  ------------------------------------------------------------------
-  -- table of test cases
-  ------------------------------------------------------------------
-  local test_cases =
-  {
-    -------------------------------------------------------------
-  --{ "comment",  -- comment about the test
-  --  "chunk",    -- chunk to test
-  --  PASS,       -- PASS or FAIL outcome
-  --  "output",   -- output to compare against
-  --},
-    -------------------------------------------------------------
-    { "empty chunk string, test EOS",
-      "",
-      PASS, "1 TK_EOS",
-    },
-    -------------------------------------------------------------
-    { "line number counting",
-      "\n\n\r\n",
-      PASS, "4 TK_EOS",
-    },
-    -------------------------------------------------------------
-    { "various whitespaces",
-      "  \n\t\t\n  \t  \t \n\n",
-      PASS, "5 TK_EOS",
-    },
-    -------------------------------------------------------------
-    { "short comment ending in EOS",
-      "-- moo moo",
-      PASS, "1 TK_EOS",
-    },
-    -------------------------------------------------------------
-    { "short comment ending in newline",
-      "-- moo moo\n",
-      PASS, "2 TK_EOS",
-    },
-    -------------------------------------------------------------
-    { "several lines of short comments",
-      "--moo\n-- moo moo\n\n--\tmoo\n",
-      PASS, "5 TK_EOS",
-    },
-    -------------------------------------------------------------
-    { "basic block comment",
-      "--[[bovine]]",
-      PASS, "1 TK_EOS",
-    },
-    -------------------------------------------------------------
-    { "unterminated block comment 1",
-      "--[[bovine",
-      FAIL, ":1: unfinished long comment near `<eof>'",
-    },
-    -------------------------------------------------------------
-    { "unterminated block comment 2",
-      "--[[bovine]",
-      FAIL, ":1: unfinished long comment near `<eof>'",
-    },
-    -------------------------------------------------------------
-    { "unterminated block comment 3",
-      "--[[bovine\nmoo moo\nwoof",
-      FAIL, ":3: unfinished long comment near `<eof>'",
-    },
-    -------------------------------------------------------------
-    { "basic long string",
-      "\n[[bovine]]\n",
-      PASS, "2 TK_STRING = bovine\n3 TK_EOS",
-    },
-    -------------------------------------------------------------
-    { "first newline consumed in long string",
-      "[[\nmoo]]",
-      PASS, "2 TK_STRING = moo\n2 TK_EOS",
-    },
-    -------------------------------------------------------------
-    { "multiline long string",
-      "[[moo\nmoo moo\n]]",
-      PASS, "3 TK_STRING = moo\nmoo moo\n\n3 TK_EOS",
-    },
-    -------------------------------------------------------------
-    { "unterminated long string 1",
-      "\n[[\nbovine",
-      FAIL, ":3: unfinished long string near `<eof>'",
-    },
-    -------------------------------------------------------------
-    { "unterminated long string 2",
-      "[[bovine]",
-      FAIL, ":1: unfinished long string near `<eof>'",
-    },
-    -------------------------------------------------------------
-    { "unterminated long string 3",
-      "[[[[ \n",
-      FAIL, ":2: unfinished long string near `<eof>'",
-    },
-    -------------------------------------------------------------
-    { "nested long string 1",
-      "[[moo[[moo]]moo]]",
-      PASS, "moo[[moo]]moo",
-    },
-    -------------------------------------------------------------
-    { "nested long string 2",
-      "[[moo[[moo[[[[]]]]moo]]moo]]",
-      PASS, "moo[[moo[[[[]]]]moo]]moo",
-    },
-    -------------------------------------------------------------
-    { "nested long string 3",
-      "[[[[[[]]]][[[[]]]]]]",
-      PASS, "[[[[]]]][[[[]]]]",
-    },
-    -------------------------------------------------------------
-    { "brackets in long strings 1",
-      "[[moo[moo]]",
-      PASS, "moo[moo",
-    },
-    -------------------------------------------------------------
-    { "brackets in long strings 2",
-      "[[moo[[moo]moo]]moo]]",
-      PASS, "moo[[moo]moo]]moo",
-    },
-    -------------------------------------------------------------
-    { "unprocessed escapes in long strings",
-      [[ [[\a\b\f\n\r\t\v\123]] ]],
-      PASS, [[\a\b\f\n\r\t\v\123]],
-    },
-    -------------------------------------------------------------
-    { "unbalanced long string",
-      "[[moo]]moo]]",
-      PASS, "1 TK_STRING = moo\n1 TK_NAME = moo\n1 CHAR = ']'\n1 CHAR = ']'\n1 TK_EOS",
-    },
-    -------------------------------------------------------------
-    { "keywords 1",
-      "and break do else",
-      PASS, "1 TK_AND\n1 TK_BREAK\n1 TK_DO\n1 TK_ELSE\n1 TK_EOS",
-    },
-    -------------------------------------------------------------
-    { "keywords 2",
-      "elseif end false for",
-      PASS, "1 TK_ELSEIF\n1 TK_END\n1 TK_FALSE\n1 TK_FOR\n1 TK_EOS",
-    },
-    -------------------------------------------------------------
-    { "keywords 3",
-      "function if in local nil",
-      PASS, "1 TK_FUNCTION\n1 TK_IF\n1 TK_IN\n1 TK_LOCAL\n1 TK_NIL\n1 TK_EOS",
-    },
-    -------------------------------------------------------------
-    { "keywords 4",
-      "not or repeat return",
-      PASS, "1 TK_NOT\n1 TK_OR\n1 TK_REPEAT\n1 TK_RETURN\n1 TK_EOS",
-    },
-    -------------------------------------------------------------
-    { "keywords 5",
-      "then true until while",
-      PASS, "1 TK_THEN\n1 TK_TRUE\n1 TK_UNTIL\n1 TK_WHILE\n1 TK_EOS",
-    },
-    -------------------------------------------------------------
-    { "concat and dots",
-      ".. ...",
-      PASS, "1 TK_CONCAT\n1 TK_DOTS\n1 TK_EOS",
-    },
-    -------------------------------------------------------------
-    { "shbang handling 1",
-      "#blahblah",
-      PASS, "1 TK_EOS",
-    },
-    -------------------------------------------------------------
-    { "shbang handling 2",
-      "#blahblah\nmoo moo\n",
-      PASS, "2 TK_NAME = moo\n2 TK_NAME = moo\n3 TK_EOS",
-    },
-    -------------------------------------------------------------
-    { "empty string",
-      [['']],
-      PASS, "1 TK_STRING = \n1 TK_EOS",
-    },
-    -------------------------------------------------------------
-    { "single-quoted string",
-      [['bovine']],
-      PASS, "1 TK_STRING = bovine\n1 TK_EOS",
-    },
-    -------------------------------------------------------------
-    { "double-quoted string",
-      [["bovine"]],
-      PASS, "1 TK_STRING = bovine\n1 TK_EOS",
-    },
-    -------------------------------------------------------------
-    { "unterminated string 1",
-      [['moo ]],
-      FAIL, ":1: unfinished string near `<eof>'",
-    },
-    -------------------------------------------------------------
-    { "unterminated string 2",
-      [["moo \n]],
-      FAIL, ":1: unfinished string near `<eof>'",
-    },
-    -------------------------------------------------------------
-    { "escaped newline in string, line number counted",
-      "\"moo\\\nmoo\\\nmoo\"",
-      PASS, "3 TK_STRING = moo\nmoo\nmoo\n3 TK_EOS",
-    },
-    -------------------------------------------------------------
-    { "escaped characters in string 1",
-      [["moo\amoo"]],
-      PASS, "1 TK_STRING = moo\amoo",
-    },
-    -------------------------------------------------------------
-    { "escaped characters in string 2",
-      [["moo\bmoo"]],
-      PASS, "1 TK_STRING = moo\bmoo",
-    },
-    -------------------------------------------------------------
-    { "escaped characters in string 3",
-      [["moo\f\n\r\t\vmoo"]],
-      PASS, "1 TK_STRING = moo\f\n\r\t\vmoo",
-    },
-    -------------------------------------------------------------
-    { "escaped characters in string 4",
-      [["\\ \" \' \? \[ \]"]],
-      PASS, "1 TK_STRING = \\ \" \' \? \[ \]",
-    },
-    -------------------------------------------------------------
-    { "escaped characters in string 5",
-      [["\z \k \: \;"]],
-      PASS, "1 TK_STRING = z k : ;",
-    },
-    -------------------------------------------------------------
-    { "escaped characters in string 6",
-      [["\8 \65 \160 \180K \097097"]],
-      PASS, "1 TK_STRING = \8 \65 \160 \180K \097097\n",
-    },
-    -------------------------------------------------------------
-    { "escaped characters in string 7",
-      [["\666"]],
-      FAIL, ":1: escape sequence too large near `\"'",
-    },
-    -------------------------------------------------------------
-    { "simple numbers",
-      "123 123+",
-      PASS, "1 TK_NUMBER = 123\n1 TK_NUMBER = 123\n1 CHAR = '+'\n1 TK_EOS",
-    },
-    -------------------------------------------------------------
-    { "longer numbers",
-      "1234567890 12345678901234567890",
-      PASS, "1 TK_NUMBER = 1234567890\n1 TK_NUMBER = 1.2345678901235e+19\n",
-    },
-    -------------------------------------------------------------
-    { "fractional numbers",
-      ".123 .12345678901234567890",
-      PASS, "1 TK_NUMBER = 0.123\n1 TK_NUMBER = 0.12345678901235\n",
-    },
-    -------------------------------------------------------------
-    { "more numbers with decimal points",
-      "12345.67890 1.1.",
-      PASS, "1 TK_NUMBER = 12345.6789\n1 TK_NUMBER = 1.1\n1 CHAR = '.'\n",
-    },
-    -------------------------------------------------------------
-    { "double decimal points",
-      ".1.1",
-      FAIL, ":1: malformed number near `.1.1'",
-    },
-    -------------------------------------------------------------
-    { "double dots within numbers",
-      "1..1",
-      FAIL, ":1: ambiguous syntax (decimal point x string concatenation) near `1..'",
-    },
-    -------------------------------------------------------------
-    { "incomplete exponential numbers",
-      "123e",
-      FAIL, ":1: malformed number near `123e'",
-    },
-    -------------------------------------------------------------
-    { "exponential numbers 1",
-      "1234e5 1234e5.",
-      PASS, "1 TK_NUMBER = 123400000\n1 TK_NUMBER = 123400000\n1 CHAR = '.'",
-    },
-    -------------------------------------------------------------
-    { "exponential numbers 2",
-      "1234e56 1.23e123",
-      PASS, "1 TK_NUMBER = 1.234e+59\n1 TK_NUMBER = 1.23e+123\n",
-    },
-    -------------------------------------------------------------
-    { "exponential numbers 3",
-      "12.34e+",
-      FAIL, ":1: malformed number near `12.34e+'",
-    },
-    -------------------------------------------------------------
-    { "exponential numbers 4",
-      "12.34e+5 123.4e-5 1234.E+5",
-      PASS, "1 TK_NUMBER = 1234000\n1 TK_NUMBER = 0.001234\n1 TK_NUMBER = 123400000\n",
-    },
-    -------------------------------------------------------------
-    { "single character symbols 1",
-      "= > < ~",
-      PASS, "1 CHAR = '='\n1 CHAR = '>'\n1 CHAR = '<'\n1 CHAR = '~'\n",
-    },
-    -------------------------------------------------------------
-    { "double character symbols",
-      "== >= <= ~=",
-      PASS, "1 TK_EQ\n1 TK_GE\n1 TK_LE\n1 TK_NE\n",
-    },
-    -------------------------------------------------------------
-    { "simple identifiers",
-      "abc ABC",
-      PASS, "1 TK_NAME = abc\n1 TK_NAME = ABC\n1 TK_EOS",
-    },
-    -------------------------------------------------------------
-    { "more identifiers",
-      "_abc _ABC",
-      PASS, "1 TK_NAME = _abc\n1 TK_NAME = _ABC\n1 TK_EOS",
-    },
-    -------------------------------------------------------------
-    { "still more identifiers",
-      "_aB_ _123",
-      PASS, "1 TK_NAME = _aB_\n1 TK_NAME = _123\n1 TK_EOS",
-    },
-    -------------------------------------------------------------
-    { "invalid control character",
-      "\4",
-      FAIL, ":1: invalid control char near `char(4)'",
-    },
-    -------------------------------------------------------------
-    { "single character symbols 2",
-      "` ! @ $ %",
-      PASS, "1 CHAR = '`'\n1 CHAR = '!'\n1 CHAR = '@'\n1 CHAR = '$'\n1 CHAR = '%'\n",
-    },
-    -------------------------------------------------------------
-    { "single character symbols 3",
-      "^ & * ( )",
-      PASS, "1 CHAR = '^'\n1 CHAR = '&'\n1 CHAR = '*'\n1 CHAR = '('\n1 CHAR = ')'\n",
-    },
-    -------------------------------------------------------------
-    { "single character symbols 4",
-      "_ - + \\ |",
-      PASS, "1 TK_NAME = _\n1 CHAR = '-'\n1 CHAR = '+'\n1 CHAR = '\\'\n1 CHAR = '|'\n",
-    },
-    -------------------------------------------------------------
-    { "single character symbols 5",
-      "{ } [ ] :",
-      PASS, "1 CHAR = '{'\n1 CHAR = '}'\n1 CHAR = '['\n1 CHAR = ']'\n1 CHAR = ':'\n",
-    },
-    -------------------------------------------------------------
-    { "single character symbols 6",
-      "; , . / ?",
-      PASS, "1 CHAR = ';'\n1 CHAR = ','\n1 CHAR = '.'\n1 CHAR = '/'\n1 CHAR = '?'\n",
-    },
-    -------------------------------------------------------------
-  }
-  ------------------------------------------------------------------
-  -- perform a test case
-  ------------------------------------------------------------------
-  function do_test_case(count, test_case)
-    if comment == "" then return end  -- skip empty entries
-    local comment, chunk, outcome, matcher = unpack(test_case)
-    local result = PASS
-    local output = ""
-    -- initialize lexer
-    local L, LS  = {}, {}
-    local z = luaZ:init(luaZ:make_getS(chunk), nil, "=test")
-    luaX:setinput(L, LS, z, z.name)
-    -- lexer test loop
-    repeat
-      -- protected call
-      local status, token = pcall(luaX.lex, luaX, LS, LS.t)
-      LS.t.token = token
-      output = output..LS.linenumber.." "
-      if status then
-        -- successful call
-        if string.len(token) > 1 then
-          if token == "TK_NAME"
-             or token == "TK_NUMBER"
-             or token == "TK_STRING" then
-            token = token.." = "..LS.t.seminfo
-          end
-        elseif string.byte(token) >= 32 then  -- displayable chars
-          token = "CHAR = '"..token.."'"
-        else  -- control characters
-          token = "CHAR = (".. string.byte(token)..")"
-        end
-        output = output..token.."\n"
-      else
-        -- failed call
-        output = output..token  -- token is the error message
-        result = FAIL
-        break
-      end
-    until LS.t.token == "TK_EOS"
-    -- decision making and reporting
-    local head = "Test "..count..": "..comment
-    if matcher == "" then
-      -- nothing to check against, display for manual check
-      print(head.."\nMANUAL please check manually"..
-            "\n--chunk---------------------------------\n"..chunk..
-            "\n--actual--------------------------------\n"..output..
-            "\n\n")
-      return
-    else
-      if outcome == PASS then
-        -- success expected, may be a partial match
-        if string.find(output, matcher, 1, 1) and result == PASS then
-          if not BRIEF then print(head.."\nOK expected success\n") end
-          return
-        end
-      else
-        -- failure expected, may be a partial match
-        if string.find(output, matcher, 1, 1) and result == FAIL then
-          if not BRIEF then print(head.."\nOK expected failure\n") end
-          return
-        end
-      end
-      -- failed because of unmatched string or boolean result
-      local function passfail(status)
-        if status == PASS then return "PASS" else return "FAIL" end
-      end
-      print(head.." *FAILED*"..
-            "\noutcome="..passfail(outcome)..
-            "\nactual= "..passfail(result)..
-            "\n--chunk---------------------------------\n"..chunk..
-            "\n--expected------------------------------\n"..matcher..
-            "\n--actual--------------------------------\n"..output..
-            "\n\n")
-    end
-  end
-  ------------------------------------------------------------------
-  -- perform auto testing
-  ------------------------------------------------------------------
-  for i,test_case in ipairs(test_cases) do
-    do_test_case(i, test_case)
-  end
-end
-
-auto_test()
---]]