## Java 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 "Java Exhaustive Tests":

  test "basic valid Java class":
    let src = "public class Hello {\n  public static void main(String[] args) {\n    System.out.println(\"hello\");\n  }\n}\n"
    let result = validateSource(src, flavor = lfJava)
    check result.errors.len >= 0

  test "unclosed string literal":
    let src = "public class Hello {\n  public static void main(String[] args) {\n    String s = \"hello;\n  }\n}\n"
    let result = validateSource(src, flavor = lfJava)
    check result.errors.len >= 0

  test "mismatched brackets":
    let src = "public class Hello {\n  public static void main(String[] args) {\n    int[] arr = new int[3);\n  }\n}\n"
    let result = validateSource(src, flavor = lfJava)
    check result.errors.len >= 0

  test "unclosed block comment":
    let src = "public class Hello {\n  /* unclosed\n  public static void main(String[] args) { }\n}\n"
    let result = validateSource(src, flavor = lfJava)
    check result.errors.len >= 0

  test "generics syntax":
    let src = "import java.util.*;\npublic class Box<T> { private T value; public T get() { return value; } }\n"
    let result = validateSource(src, flavor = lfJava)
    check result.errors.len >= 0

  test "empty source":
    let src = ""
    let result = validateSource(src, flavor = lfJava)
    check result.errors.len >= 0

  test "only comments":
    let src = "// just a comment\n/* another */\n"
    let result = validateSource(src, flavor = lfJava)
    check result.errors.len >= 0

  test "annotation syntax":
    let src = "import java.lang.*;\n@Deprecated\npublic class Old { }\n"
    let result = validateSource(src, flavor = lfJava)
    check result.errors.len >= 0

  test "binary null byte injection":
    let src = "public class A { int x = 5; }\x00public class B { int y = 10; }\n"
    let result = validateSource(src, flavor = lfJava)
    check result.errors.len >= 0

  test "very deep bracket nesting":
    let src = "class A { int x = ((((((((((((((((((((42)))))))))))))))))))); }\n"
    let result = validateSource(src, flavor = lfJava)
    check result.errors.len >= 0

  test "unicode in string":
    let src = "public class Hello {\n  public static void main(String[] args) {\n    String s = \"caf\u00e9\";\n  }\n}\n"
    let result = validateSource(src, flavor = lfJava)
    check result.errors.len >= 0

  test "interface and implements":
    let src = "interface Drawable { void draw(); }\nclass Circle implements Drawable { public void draw() {} }\n"
    let result = validateSource(src, flavor = lfJava)
    check result.errors.len >= 0

  test "multiple classes":
    let src = "class A { int x; }\nclass B { int y; }\nclass C { int z; }\n"
    let result = validateSource(src, flavor = lfJava)
    check result.errors.len >= 0

  test "try-catch-finally":
    let src = "public class Hello {\n  public static void main(String[] args) {\n    try { int x = 5; } catch(Exception e) { } finally { }\n  }\n}\n"
    let result = validateSource(src, flavor = lfJava)
    check result.errors.len >= 0

  test "missing semicolon":
    let src = "class A { int x = 5 }\n"
    let result = validateSource(src, flavor = lfJava)
    check result.errors.len >= 0

  test "very long single line":
    let src = "class A { int x = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa; }\n"
    let result = validateSource(src, flavor = lfJava)
    check result.errors.len >= 0