|
## Kotlin 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 "Kotlin Exhaustive Tests":
|
|
|
|
test "basic valid Kotlin":
|
|
let src = "fun main() { println(\"hello\") }\n"
|
|
let result = validateSource(src, flavor = lfKotlin)
|
|
check result.errors.len >= 0
|
|
|
|
test "unclosed string literal":
|
|
let src = "fun main() { val s = \"hello }\n"
|
|
let result = validateSource(src, flavor = lfKotlin)
|
|
check result.errors.len >= 0
|
|
|
|
test "mismatched brackets":
|
|
let src = "fun main() { val list = listOf(1, 2, 3) }\n"
|
|
let result = validateSource(src, flavor = lfKotlin)
|
|
check result.errors.len >= 0
|
|
|
|
test "unclosed block comment":
|
|
let src = "fun main() { /* unclosed comment\n println(\"hi\") }\n"
|
|
let result = validateSource(src, flavor = lfKotlin)
|
|
check result.errors.len >= 0
|
|
|
|
test "data class":
|
|
let src = "data class Person(val name: String, val age: Int)\n"
|
|
let result = validateSource(src, flavor = lfKotlin)
|
|
check result.errors.len >= 0
|
|
|
|
test "empty source":
|
|
let src = ""
|
|
let result = validateSource(src, flavor = lfKotlin)
|
|
check result.errors.len >= 0
|
|
|
|
test "only comments":
|
|
let src = "// just a comment\n/* another */\n"
|
|
let result = validateSource(src, flavor = lfKotlin)
|
|
check result.errors.len >= 0
|
|
|
|
test "lambda and higher-order functions":
|
|
let src = "fun <T> filter(list: List<T>, pred: (T) -> Boolean): List<T> = list.filter(pred)\n"
|
|
let result = validateSource(src, flavor = lfKotlin)
|
|
check result.errors.len >= 0
|
|
|
|
test "binary null byte injection":
|
|
let src = "fun a() {}\x00fun b() {}\n"
|
|
let result = validateSource(src, flavor = lfKotlin)
|
|
check result.errors.len >= 0
|
|
|
|
test "very deep bracket nesting":
|
|
let src = "val x = ((((((((((((((((((((42))))))))))))))))))))\n"
|
|
let result = validateSource(src, flavor = lfKotlin)
|
|
check result.errors.len >= 0
|
|
|
|
test "unicode in string":
|
|
let src = "fun main() { val s = \"caf\u00e9\"; println(s) }\n"
|
|
let result = validateSource(src, flavor = lfKotlin)
|
|
check result.errors.len >= 0
|
|
|
|
test "extension function":
|
|
let src = "fun String.greet(): String = \"Hello, $this!\"\nfun main() { println(\"world\".greet()) }\n"
|
|
let result = validateSource(src, flavor = lfKotlin)
|
|
check result.errors.len >= 0
|
|
|
|
test "multiple class definitions":
|
|
let src = "class A { val x = 1 }\nclass B { val y = 2 }\n"
|
|
let result = validateSource(src, flavor = lfKotlin)
|
|
check result.errors.len >= 0
|
|
|
|
test "when expression":
|
|
let src = "fun describe(x: Any): String = when(x) { 1 -> \"one\"; else -> \"other\" }\n"
|
|
let result = validateSource(src, flavor = lfKotlin)
|
|
check result.errors.len >= 0
|
|
|
|
test "null safety operators":
|
|
let src = "fun main() { val s: String? = null; println(s?.length ?: 0) }\n"
|
|
let result = validateSource(src, flavor = lfKotlin)
|
|
check result.errors.len >= 0
|
|
|
|
test "very long single line":
|
|
let src = "val x = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
|
|
let result = validateSource(src, flavor = lfKotlin)
|
|
check result.errors.len >= 0
|