|
## Go 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 "Go Exhaustive Tests":
|
|
|
|
test "basic valid Go package":
|
|
let src = "package main\n\nfunc main() {}\n"
|
|
let result = validateSource(src, flavor = lfGo)
|
|
check result.errors.len >= 0
|
|
|
|
test "unclosed string literal":
|
|
let src = "package main\nfunc main() { s := \"hello\n}"
|
|
let result = validateSource(src, flavor = lfGo)
|
|
check result.errors.len >= 0
|
|
|
|
test "raw string backtick":
|
|
let src = "package main\nfunc main() { s := `raw\\nstring` }\n"
|
|
let result = validateSource(src, flavor = lfGo)
|
|
check result.errors.len >= 0
|
|
|
|
test "unclosed raw string backtick":
|
|
let src = "package main\nfunc main() { s := `unclosed\n}"
|
|
let result = validateSource(src, flavor = lfGo)
|
|
check result.errors.len >= 0
|
|
|
|
test "multiple return values":
|
|
let src = "package main\nfunc div(a, b int) (int, error) {\n\tif b == 0 { return 0, nil }\n\treturn a / b, nil\n}\n"
|
|
let result = validateSource(src, flavor = lfGo)
|
|
check result.errors.len >= 0
|
|
|
|
test "defer statement":
|
|
let src = "package main\nimport \"fmt\"\nfunc main() { defer fmt.Println(\"done\") }\n"
|
|
let result = validateSource(src, flavor = lfGo)
|
|
check result.errors.len >= 0
|
|
|
|
test "goroutine and channel":
|
|
let src = "package main\nfunc main() {\n\tch := make(chan int)\n\tgo func() { ch <- 42 }()\n\t<-ch\n}\n"
|
|
let result = validateSource(src, flavor = lfGo)
|
|
check result.errors.len >= 0
|
|
|
|
test "struct with methods":
|
|
let src = "package main\ntype Point struct { X, Y float64 }\nfunc (p Point) Distance() float64 { return p.X + p.Y }\n"
|
|
let result = validateSource(src, flavor = lfGo)
|
|
check result.errors.len >= 0
|
|
|
|
test "interface definition":
|
|
let src = "package main\ntype Shape interface {\n\tArea() float64\n\tPerimeter() float64\n}\n"
|
|
let result = validateSource(src, flavor = lfGo)
|
|
check result.errors.len >= 0
|
|
|
|
test "type switch":
|
|
let src = "package main\nfunc test(v interface{}) {\n\tswitch t := v.(type) {\n\tcase int: _ = t\n\tcase string: _ = t\n\t}\n}\n"
|
|
let result = validateSource(src, flavor = lfGo)
|
|
check result.errors.len >= 0
|
|
|
|
test "empty source":
|
|
let src = ""
|
|
let result = validateSource(src, flavor = lfGo)
|
|
check result.errors.len >= 0
|
|
|
|
test "null byte injection":
|
|
let src = "package main\nfunc main() {}\x00func other() {}\n"
|
|
let result = validateSource(src, flavor = lfGo)
|
|
check result.errors.len >= 0
|
|
|
|
test "very deep bracket nesting":
|
|
let src = "package main\nfunc main() { x := [][][][][][][][][][]{}{}{}{}{}{}{}{}{}{} }\n"
|
|
let result = validateSource(src, flavor = lfGo)
|
|
check result.errors.len >= 0
|
|
|
|
test "unicode identifiers":
|
|
let src = "package main\nfunc café() int { return 1 }\n"
|
|
let result = validateSource(src, flavor = lfGo)
|
|
check result.errors.len >= 0
|
|
|
|
test "only whitespace and comments":
|
|
let src = "// just a comment\n \n/* another */\n"
|
|
let result = validateSource(src, flavor = lfGo)
|
|
check result.errors.len >= 0
|