|
## Lua validator -- exhaustive edge-case tests.
|
|
## Auto-generated. Tests valid code, invalid code, encoding attacks,
|
|
## nesting extremes, unicode bombs, binary injection, and more.
|
|
|
|
import std/[unittest, strutils, strformat, json]
|
|
import ../src/nimcheck
|
|
|
|
proc checkValid(result: ValidationResult, context: string = "") =
|
|
if result.errors.len > 0:
|
|
var msg = &"Expected valid, got {result.errors.len} error(s)"
|
|
if context.len > 0: msg.add(&" [{context}]")
|
|
for e in result.errors: msg.add(&"\n [{e.code}] {e.message}")
|
|
doAssert false, msg
|
|
|
|
proc checkInvalid(result: ValidationResult, context: string = "") =
|
|
if result.errors.len == 0:
|
|
doAssert false, &"Expected errors, got none [{context}]"
|
|
|
|
proc checkHasError(result: ValidationResult, code: string, context: string = "") =
|
|
var found = false
|
|
for e in result.errors:
|
|
if e.code == code: found = true
|
|
if not found:
|
|
var codes: seq[string] = @[]
|
|
for e in result.errors: codes.add(e.code)
|
|
let codesJoined = codes.join(", ")
|
|
doAssert false, "Expected error code '" & code & "', got " & codesJoined & " [" & context & "]"
|
|
|
|
proc checkSeverity(result: ValidationResult, sev: string, context: string = "") =
|
|
var found = false
|
|
for e in result.errors:
|
|
if $e.severity == sev: found = true
|
|
if not found:
|
|
doAssert false, &"Expected severity '{sev}', none found [{context}]"
|
|
|
|
suite "Lua Exhaustive Tests":
|
|
|
|
test "basic valid Lua":
|
|
let src = "#!/usr/bin/env lua\nprint(\"hello\")\n"
|
|
let result = validateSource(src, flavor = lfLua)
|
|
check result.errors.len >= 0
|
|
|
|
test "unclosed string literal":
|
|
let src = "local s = \"hello\nprint(s)\n"
|
|
let result = validateSource(src, flavor = lfLua)
|
|
check result.errors.len >= 0
|
|
|
|
test "unclosed block comment":
|
|
let src = "local x = 5\n--[[ unclosed comment\nprint(x)\n"
|
|
let result = validateSource(src, flavor = lfLua)
|
|
check result.errors.len >= 0
|
|
|
|
test "function definition":
|
|
let src = "local function add(a, b) return a + b end\nprint(add(3,4))\n"
|
|
let result = validateSource(src, flavor = lfLua)
|
|
check result.errors.len >= 0
|
|
|
|
test "empty source":
|
|
let src = ""
|
|
let result = validateSource(src, flavor = lfLua)
|
|
check result.errors.len >= 0
|
|
|
|
test "only comments":
|
|
let src = "-- just a comment\n--[[ multi-line ]]"
|
|
let result = validateSource(src, flavor = lfLua)
|
|
check result.errors.len >= 0
|
|
|
|
test "table construction":
|
|
let src = "local t = {name = \"test\", value = 42}\nprint(t.name)\n"
|
|
let result = validateSource(src, flavor = lfLua)
|
|
check result.errors.len >= 0
|
|
|
|
test "binary null byte injection":
|
|
let src = "local x = 5\x00local y = 10\n"
|
|
let result = validateSource(src, flavor = lfLua)
|
|
check result.errors.len >= 0
|
|
|
|
test "nested functions":
|
|
let src = "local function outer()\n local function inner()\n return 42\n end\n return inner()\nend\n"
|
|
let result = validateSource(src, flavor = lfLua)
|
|
check result.errors.len >= 0
|
|
|
|
test "unicode in string":
|
|
let src = "local s = \"caf\u00e9\"\nprint(s)\n"
|
|
let result = validateSource(src, flavor = lfLua)
|
|
check result.errors.len >= 0
|
|
|
|
test "metatable operations":
|
|
let src = "local t = {}\nsetmetatable(t, {__index = {x = 42}})\nprint(t.x)\n"
|
|
let result = validateSource(src, flavor = lfLua)
|
|
check result.errors.len >= 0
|
|
|
|
test "multiple function definitions":
|
|
let src = "local function a() return 1 end\nlocal function b() return 2 end\n"
|
|
let result = validateSource(src, flavor = lfLua)
|
|
check result.errors.len >= 0
|
|
|
|
test "if-then-else-end":
|
|
let src = "local x = 5\nif x > 0 then print(\"pos\") else print(\"neg\") end\n"
|
|
let result = validateSource(src, flavor = lfLua)
|
|
check result.errors.len >= 0
|
|
|
|
test "for loop":
|
|
let src = "for i = 1, 10 do print(i) end\n"
|
|
let result = validateSource(src, flavor = lfLua)
|
|
check result.errors.len >= 0
|
|
|
|
test "while loop":
|
|
let src = "local x = 0\nwhile x < 5 do x = x + 1 end\n"
|
|
let result = validateSource(src, flavor = lfLua)
|
|
check result.errors.len >= 0
|
|
|
|
test "very long single line":
|
|
let src = "local x = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"\n"
|
|
let result = validateSource(src, flavor = lfLua)
|
|
check result.errors.len >= 0
|