|
## Rust 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 "Rust Exhaustive Tests":
|
|
|
|
test "basic valid main":
|
|
let src = "fn main() { println!(\"hello\"); }\n"
|
|
let result = validateSource(src, flavor = lfRust)
|
|
check result.errors.len >= 0
|
|
|
|
test "unclosed string literal":
|
|
let src = "fn main() { let s = \"hello\n}"
|
|
let result = validateSource(src, flavor = lfRust)
|
|
check result.errors.len >= 0
|
|
|
|
test "raw string r#":
|
|
let src = "fn main() { let s = r#\"raw string\"#; }\n"
|
|
let result = validateSource(src, flavor = lfRust)
|
|
check result.errors.len >= 0
|
|
|
|
test "unclosed raw string":
|
|
let src = "fn main() { let s = r#\"unclosed\n}"
|
|
let result = validateSource(src, flavor = lfRust)
|
|
check result.errors.len >= 0
|
|
|
|
test "struct with derive":
|
|
let src = "#[derive(Debug, Clone)]\npub struct Point { pub x: f64, pub y: f64 }\n"
|
|
let result = validateSource(src, flavor = lfRust)
|
|
check result.errors.len >= 0
|
|
|
|
test "enum with match":
|
|
let src = "enum Color { Red, Green, Blue }\nfn describe(c: Color) -> &'static str {\n\tmatch c {\n\t\tColor::Red => \"red\",\n\t\tColor::Green => \"green\",\n\t\tColor::Blue => \"blue\",\n\t}\n}\n"
|
|
let result = validateSource(src, flavor = lfRust)
|
|
check result.errors.len >= 0
|
|
|
|
test "impl block":
|
|
let src = "struct Square { side: f64 }\nimpl Square {\n\tfn area(&self) -> f64 { self.side * self.side }\n}\n"
|
|
let result = validateSource(src, flavor = lfRust)
|
|
check result.errors.len >= 0
|
|
|
|
test "generic function":
|
|
let src = "fn identity<T>(x: T) -> T { x }\n"
|
|
let result = validateSource(src, flavor = lfRust)
|
|
check result.errors.len >= 0
|
|
|
|
test "lifetime annotation":
|
|
let src = "fn longest<'a>(x: &'a str, y: &'a str) -> &'a str { if x.len() > y.len() { x } else { y } }\n"
|
|
let result = validateSource(src, flavor = lfRust)
|
|
check result.errors.len >= 0
|
|
|
|
test "empty source":
|
|
let src = ""
|
|
let result = validateSource(src, flavor = lfRust)
|
|
check result.errors.len >= 0
|
|
|
|
test "null byte injection":
|
|
let src = "fn main() {}\x00fn other() {}\n"
|
|
let result = validateSource(src, flavor = lfRust)
|
|
check result.errors.len >= 0
|
|
|
|
test "very deep nesting":
|
|
let src = "fn main() { [[[[[[[[[[[[[[[[[[[[42]]]]]]]]]]]]]]]]]]]]; }\n"
|
|
let result = validateSource(src, flavor = lfRust)
|
|
check result.errors.len >= 0
|
|
|
|
test "unicode identifiers":
|
|
let src = "fn café() -> i32 { 1 }\n"
|
|
let result = validateSource(src, flavor = lfRust)
|
|
check result.errors.len >= 0
|
|
|
|
test "only comments and whitespace":
|
|
let src = "// just a comment\n \n/* block comment */\n"
|
|
let result = validateSource(src, flavor = lfRust)
|
|
check result.errors.len >= 0
|
|
|
|
test "macro invocation":
|
|
let src = "fn main() { let v = vec![1, 2, 3]; println!(\"{:?}\", v); }\n"
|
|
let result = validateSource(src, flavor = lfRust)
|
|
check result.errors.len >= 0
|