Home /Modules/tests/jdk28_functional_equivalence.py

jdk28_functional_equivalence.py

tests/jdk28_functional_equivalence.py · 121 line(s) · py

#!/usr/bin/env python3
"""JDK 28 SLeeLa/Java conformance and functional-equivalence audit.

This test deliberately distinguishes:
  1. API identity: a .sleela file names a real documented JDK 28 type.
  2. Envelope contract: the generated SLeeLa declaration exposes the required
     SLeeLa/Java bridge operations.
  3. Functional equivalence: the SLeeLa declaration actually represents the
     Java type's documented constructors, methods, fields and inheritance.

The current generated envelopes are contracts, not implementations. Therefore
the functional-equivalence gate is expected to fail until the compiler/runtime
can execute the Java API surface rather than merely identify it.
"""
from __future__ import annotations
import argparse, html, re, sys, urllib.request
from pathlib import Path
from urllib.parse import urljoin, urlparse

INDEX_URL = "https://download.java.net/java/early_access/jdk28/docs/api/allclasses-index.html"
ROOT = Path(__file__).resolve().parents[1] / "lib" / "java"
REQUIRED = {
    "typeName": r'String\s+typeName\s*\(',
    "available": r'boolean\s+available\s*\(',
    "construct": r'String\s+construct\s*\(',
    "invoke": r'String\s+invoke\s*\(\s*String\s+operation\s*\)',
    "invokeStatic": r'String\s+invokeStatic\s*\(\s*String\s+operation\s*\)',
}

def fetch(url: str) -> str:
    req = urllib.request.Request(url, headers={"User-Agent": "SLeeLa-JDK28-Conformance/1.0"})
    with urllib.request.urlopen(req, timeout=60) as r:
        return r.read().decode("utf-8", errors="replace")

def documented_types(index: str) -> set[str]:
    out=set()
    for raw in re.findall(r'href=["\']([^"\']+\.html(?:#[^"\']*)?)["\']', index):
        href=html.unescape(raw.split("#",1)[0])
        p=urlparse(urljoin(INDEX_URL, href)).path.strip("/").split("/")
        if len(p) < 3 or not p[-1].endswith(".html"):
            continue
        name=p[-1][:-5]
        if name in {"module-info","package-info","package-summary","module-summary","package-use","deprecated-list","index","overview-summary","class-use","serialized-form"}:
            continue
        if any(x in {"doc-files","index-files"} for x in p):
            continue
        out.add(".".join(p[1:-1]+[name]))
    return out

def source_types() -> list[tuple[Path,str,str,str]]:
    result=[]
    for f in ROOT.rglob("*.sleela"):
        s=f.read_text(encoding="utf-8", errors="replace")
        m=re.search(r'String\s+javaType\s*=\s*"([^"]+)"\s*;', s)
        c=re.search(r'\bclass\s+([A-Za-z_$][\w$]*)\s*\{', s)
        if not m or not c:
            result.append((f,"","",s))
        else:
            result.append((f,m.group(1),c.group(1),s))
    return sorted(result)

def main() -> int:
    ap=argparse.ArgumentParser()
    ap.add_argument("--functional", action="store_true",
                    help="require actual Java API behavior/signature representation")
    ap.add_argument("--offline-index", type=Path)
    args=ap.parse_args()

    index=(args.offline_index.read_text(encoding="utf-8") if args.offline_index else fetch(INDEX_URL))
    docs=documented_types(index)
    files=source_types()

    malformed=[]; unknown=[]; missing_contract=[]; behavioral=[]
    for f,qt,cn,s in files:
        if not qt or not cn:
            malformed.append(str(f)); continue
        if qt not in docs:
            unknown.append((str(f),qt))
        for name,pat in REQUIRED.items():
            if not re.search(pat,s):
                missing_contract.append((str(f),name))
        # A true implementation must declare the Java API surface. The current
        # envelopes contain only the bridge methods above, so flag them rather
        # than treating the generic invoke() operation as Java-method parity.
        bridge_only = all(re.search(pat,s) for pat in REQUIRED.values())
        declared_api = re.findall(r'\b(?:public|protected|private)?\s*(?:static\s+)?[A-Za-z_$][\w$<>,\[\].?]*\s+[A-Za-z_$][\w$]*\s*\([^;{}]*\)\s*\{', s)
        if bridge_only and len(declared_api) <= len(REQUIRED):
            behavioral.append((str(f),qt))

    print(f"JDK 28 documented types: {len(docs)}")
    print(f"SLeeLa .sleela files inspected: {len(files)}")
    print(f"Malformed SLeeLa envelopes: {len(malformed)}")
    print(f"Types not found in JDK 28 index: {len(unknown)}")
    print(f"Missing envelope contract methods: {len(missing_contract)}")
    print(f"Not behaviorally represented by Java API declarations: {len(behavioral)}")

    if malformed or unknown or missing_contract:
        for x in malformed[:20]: print("MALFORMED",x)
        for x in unknown[:20]: print("UNKNOWN",*x)
        for x in missing_contract[:20]: print("MISSING_CONTRACT",*x)
        return 1

    if args.functional and behavioral:
        print()
        print("FUNCTIONAL-EQUIVALENCE GATE: FAIL")
        print("The inspected SLeeLa files identify Java types and provide bridge")
        print("operations, but do not declare the Java cousins' actual API members.")
        print("They are source contracts, not functional implementations.")
        for x in behavioral[:25]: print("BEHAVIORAL_GAP",*x)
        if len(behavioral) > 25:
            print(f"... {len(behavioral)-25} additional behavioral gaps")
        return 2

    print("API-IDENTITY/ENVELOPE-CONTRACT GATE: PASS")
    if not args.functional:
        print("Functional equivalence was not requested.")
    return 0

if __name__ == "__main__":
    raise SystemExit(main())