js4j 0.1.0

package/tests/comparison/run_comparison.js

@@ -0,0 +1,279 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Comparison test runner.
+ *
+ * 1. Starts the Java TestEntryPoint gateway server
+ * 2. Runs test_py4j.py (captures py4j results)
+ * 3. Runs test_js4j.js (captures js4j results)
+ * 4. Compares the two result sets and reports differences
+ *
+ * Prerequisites:
+ *   - Java installed (java on PATH)
+ *   - py4j Java JAR on CLASSPATH (or provide PY4J_JAR env var)
+ *   - Python 3 with py4j installed: pip install py4j
+ *   - TestEntryPoint.java compiled: javac -cp <py4j.jar> java/TestEntryPoint.java -d java/build
+ *
+ * Usage:
+ *   node tests/comparison/run_comparison.js
+ *   PY4J_JAR=/path/to/py4j.jar node tests/comparison/run_comparison.js
+ */
+
+const { spawn, execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const net = require('net');
+
+const ROOT = path.resolve(__dirname, '../..');
+const JAVA_DIR = path.join(ROOT, 'java');
+const BUILD_DIR = path.join(JAVA_DIR, 'build');
+const PY4J_JAR = process.env.PY4J_JAR || findPy4jJar();
+const GATEWAY_PORT = parseInt(process.env.GATEWAY_PORT || '25333', 10);
+const PY_RESULTS = path.join(__dirname, 'comparison_results_py4j.json');
+const JS_RESULTS = path.join(__dirname, 'comparison_results_js4j.json');
+
+// Numeric comparison tolerance
+const FLOAT_TOLERANCE = 1e-9;
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function findPy4jJar() {
+  // Try common locations
+  const candidates = [
+    '/usr/share/py4j/py4j.jar',
+    '/usr/local/share/py4j/py4j.jar',
+    // pip install py4j puts the jar here
+    ...(() => {
+      try {
+        const site = execSync('python3 -c "import py4j; import os; print(os.path.dirname(py4j.__file__))"', {
+          encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe']
+        }).trim();
+        return [
+          path.join(site, 'java', 'lib', 'py4j0.10.9.9.jar'),
+          path.join(site, 'java', 'lib', 'py4j0.10.9.8.jar'),
+          path.join(site, 'java', 'lib', 'py4j0.10.9.7.jar'),
+          ...fs.readdirSync(path.join(site, 'java', 'lib')).map(f => path.join(site, 'java', 'lib', f)),
+        ].filter(f => f.endsWith('.jar'));
+      } catch (_) {
+        return [];
+      }
+    })(),
+  ];
+  for (const c of candidates) {
+    try {
+      if (fs.existsSync(c)) return c;
+    } catch (_) {}
+  }
+  return null;
+}
+
+function waitForPort(port, host, timeout = 15000) {
+  return new Promise((resolve, reject) => {
+    const start = Date.now();
+    function attempt() {
+      const sock = new net.Socket();
+      sock.setTimeout(500);
+      sock.on('connect', () => { sock.destroy(); resolve(); });
+      sock.on('error', () => {
+        sock.destroy();
+        if (Date.now() - start > timeout) {
+          reject(new Error(`Timeout waiting for port ${port}`));
+        } else {
+          setTimeout(attempt, 300);
+        }
+      });
+      sock.on('timeout', () => {
+        sock.destroy();
+        setTimeout(attempt, 300);
+      });
+      sock.connect(port, host);
+    }
+    attempt();
+  });
+}
+
+function run(cmd, args, opts = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(cmd, args, { stdio: 'inherit', ...opts });
+    child.on('close', (code) => {
+      if (code !== 0 && !opts.allowFailure) {
+        reject(new Error(`${cmd} exited with code ${code}`));
+      } else {
+        resolve(code);
+      }
+    });
+    child.on('error', reject);
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Build Java
+// ---------------------------------------------------------------------------
+
+async function buildJava() {
+  if (!PY4J_JAR) {
+    throw new Error(
+      'py4j JAR not found. Set PY4J_JAR=/path/to/py4j.jar or install py4j: pip install py4j'
+    );
+  }
+  console.log(`Using py4j JAR: ${PY4J_JAR}`);
+
+  fs.mkdirSync(BUILD_DIR, { recursive: true });
+
+  console.log('Compiling TestEntryPoint.java...');
+  await run('javac', [
+    '-cp', PY4J_JAR,
+    '-d', BUILD_DIR,
+    path.join(JAVA_DIR, 'TestEntryPoint.java'),
+  ]);
+  console.log('Compiled successfully.\n');
+}
+
+// ---------------------------------------------------------------------------
+// Start gateway server
+// ---------------------------------------------------------------------------
+
+async function startGateway() {
+  console.log(`Starting Java GatewayServer on port ${GATEWAY_PORT}...`);
+  const child = spawn('java', [
+    '-cp', `${BUILD_DIR}:${PY4J_JAR}`,
+    'TestEntryPoint',
+    String(GATEWAY_PORT),
+  ], { stdio: ['pipe', 'pipe', 'inherit'] });
+
+  // Wait for "GATEWAY_STARTED:" line
+  await new Promise((resolve, reject) => {
+    let buf = '';
+    child.stdout.setEncoding('utf8');
+    child.stdout.on('data', (chunk) => {
+      buf += chunk;
+      process.stdout.write(chunk);
+      if (buf.includes('GATEWAY_STARTED:')) resolve();
+    });
+    child.on('error', reject);
+    child.on('close', (code) => {
+      if (code !== 0) reject(new Error(`Gateway exited with code ${code}`));
+    });
+    setTimeout(() => reject(new Error('Timeout waiting for gateway')), 15000);
+  });
+
+  await waitForPort(GATEWAY_PORT, '127.0.0.1');
+  console.log('Gateway is ready.\n');
+  return child;
+}
+
+// ---------------------------------------------------------------------------
+// Compare results
+// ---------------------------------------------------------------------------
+
+function floatEq(a, b) {
+  if (typeof a === 'number' && typeof b === 'number') {
+    return Math.abs(a - b) <= FLOAT_TOLERANCE * Math.max(1, Math.abs(a), Math.abs(b));
+  }
+  return false;
+}
+
+function valuesMatch(py, js) {
+  if (py === null && js === null) return true;
+  if (py === null || js === null) return false;
+  if (typeof py === 'boolean' && typeof js === 'boolean') return py === js;
+  if (typeof py === 'number' && typeof js === 'number') {
+    return py === js || floatEq(py, js);
+  }
+  if (typeof py === 'string' && typeof js === 'string') return py === js;
+  return String(py) === String(js);
+}
+
+function compareResults(pyResults, jsResults) {
+  const allKeys = new Set([...Object.keys(pyResults), ...Object.keys(jsResults)]);
+  let passed = 0, failed = 0, skipped = 0;
+
+  console.log('\n' + '='.repeat(70));
+  console.log('COMPARISON RESULTS');
+  console.log('='.repeat(70));
+
+  for (const key of [...allKeys].sort()) {
+    const py = pyResults[key];
+    const js = jsResults[key];
+
+    if (!py) { console.log(`  SKIP   ${key}  (missing from py4j results)`); skipped++; continue; }
+    if (!js) { console.log(`  SKIP   ${key}  (missing from js4j results)`); skipped++; continue; }
+
+    const statusMatch = py.status === js.status;
+    const valueMatch = statusMatch && valuesMatch(py.value, js.value);
+
+    if (statusMatch && valueMatch) {
+      console.log(`  PASS   ${key}  = ${JSON.stringify(py.value)}`);
+      passed++;
+    } else if (statusMatch && py.status !== 'ok') {
+      // Both threw an error (type matches) — consider it a pass for exception tests
+      console.log(`  PASS   ${key}  [both raised ${py.status}]`);
+      passed++;
+    } else {
+      console.log(`  FAIL   ${key}`);
+      console.log(`           py4j:  status=${py.status}  value=${JSON.stringify(py.value)}`);
+      console.log(`           js4j:  status=${js.status}  value=${JSON.stringify(js.value)}`);
+      failed++;
+    }
+  }
+
+  console.log('\n' + '='.repeat(70));
+  console.log(`Passed: ${passed}  Failed: ${failed}  Skipped: ${skipped}  Total: ${allKeys.size}`);
+  console.log('='.repeat(70) + '\n');
+
+  return failed === 0;
+}
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+
+async function main() {
+  let gateway = null;
+
+  try {
+    await buildJava();
+    gateway = await startGateway();
+
+    // Run py4j tests
+    console.log('Running py4j (Python) tests...\n');
+    await run('python3', [
+      path.join(__dirname, 'test_py4j.py'),
+      '--gateway-port', String(GATEWAY_PORT),
+      '--output', PY_RESULTS,
+    ], { allowFailure: true });
+
+    // Run js4j tests
+    console.log('\nRunning js4j (Node.js) tests...\n');
+    await run('node', [
+      path.join(__dirname, 'test_js4j.js'),
+      '--gateway-port', String(GATEWAY_PORT),
+      '--output', JS_RESULTS,
+    ], { allowFailure: true });
+
+    // Compare
+    if (!fs.existsSync(PY_RESULTS)) throw new Error(`py4j results file not found: ${PY_RESULTS}`);
+    if (!fs.existsSync(JS_RESULTS)) throw new Error(`js4j results file not found: ${JS_RESULTS}`);
+
+    const pyResults = JSON.parse(fs.readFileSync(PY_RESULTS, 'utf8'));
+    const jsResults = JSON.parse(fs.readFileSync(JS_RESULTS, 'utf8'));
+
+    const allPassed = compareResults(pyResults, jsResults);
+    process.exitCode = allPassed ? 0 : 1;
+
+  } catch (err) {
+    console.error('\nComparison runner error:', err.message);
+    process.exitCode = 1;
+  } finally {
+    if (gateway) {
+      console.log('Shutting down gateway...');
+      gateway.stdin.end();
+      gateway.kill('SIGTERM');
+    }
+  }
+}
+
+main();

package/tests/comparison/test_js4j.js

@@ -0,0 +1,187 @@
+'use strict';
+
+/**
+ * Comparison tests using js4j (Node.js implementation).
+ *
+ * Runs the exact same operations as test_py4j.py and writes results to
+ * comparison_results_js4j.json for comparison.
+ *
+ * Usage:
+ *   node test_js4j.js [--gateway-port 25333] [--output results_js4j.json]
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const { JavaGateway, GatewayParameters, Js4JJavaError } = require('../../index');
+
+// ---------------------------------------------------------------------------
+// Argument parsing
+// ---------------------------------------------------------------------------
+const argv = process.argv.slice(2);
+let gatewayPort = 25333;
+let outputFile = 'comparison_results_js4j.json';
+
+for (let i = 0; i < argv.length; i++) {
+  if (argv[i] === '--gateway-port' && argv[i + 1]) {
+    gatewayPort = parseInt(argv[++i], 10);
+  } else if (argv[i] === '--output' && argv[i + 1]) {
+    outputFile = argv[++i];
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Test runner
+// ---------------------------------------------------------------------------
+const results = {};
+
+async function runTest(name, fn) {
+  try {
+    const value = await fn();
+    results[name] = { status: 'ok', value: serialise(value) };
+    console.log(`  PASS  ${name} => ${JSON.stringify(results[name].value)}`);
+  } catch (err) {
+    if (err && (err.name === 'Js4JJavaError' || err.constructor.name === 'Js4JJavaError')) {
+      results[name] = { status: 'java_error', value: err.javaExceptionMessage || err.message };
+      console.log(`  JAVA_ERR  ${name}: ${err.message}`);
+    } else {
+      results[name] = { status: 'error', value: err.message || String(err) };
+      console.log(`  ERROR  ${name}: ${err.message}`);
+    }
+  }
+}
+
+function serialise(v) {
+  if (v === null || v === undefined) return null;
+  if (typeof v === 'boolean') return v;
+  if (typeof v === 'bigint') return Number(v);
+  if (typeof v === 'number') return v;
+  if (typeof v === 'string') return v;
+  // Java objects — return their string representation
+  return String(v);
+}
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+async function main() {
+  const gateway = new JavaGateway(new GatewayParameters({ port: gatewayPort }));
+  await gateway.connect();
+  const ep = gateway.entry_point;
+  const jvm = gateway.jvm;
+
+  console.log('\n--- Arithmetic ---');
+  await runTest('add_int',       () => ep.add(3, 4));
+  await runTest('add_negative',  () => ep.add(-10, 5));
+  await runTest('add_doubles',   () => ep.addDoubles(1.5, 2.5));
+  await runTest('multiply',      () => ep.multiply(6, 7));
+  await runTest('divide',        () => ep.divide(10.0, 4.0));
+
+  console.log('\n--- Strings ---');
+  await runTest('greet',             () => ep.greet('World'));
+  await runTest('concatenate',       () => ep.concatenate('foo', 'bar'));
+  await runTest('string_length',     () => ep.stringLength('hello'));
+  await runTest('to_upper_case',     () => ep.toUpperCase('hello'));
+  await runTest('contains_true',     () => ep.containsSubstring('foobar', 'oba'));
+  await runTest('contains_false',    () => ep.containsSubstring('foobar', 'xyz'));
+  await runTest('repeat_string',     () => ep.repeatString('ab', 3));
+
+  console.log('\n--- Booleans ---');
+  await runTest('and_true',  () => ep.andBool(true, true));
+  await runTest('and_false', () => ep.andBool(true, false));
+  await runTest('or_true',   () => ep.orBool(false, true));
+  await runTest('or_false',  () => ep.orBool(false, false));
+  await runTest('not_true',  () => ep.notBool(true));
+  await runTest('not_false', () => ep.notBool(false));
+
+  console.log('\n--- Null handling ---');
+  await runTest('maybe_null_returns_null', () => ep.maybeNull(true));
+  await runTest('maybe_null_returns_str',  () => ep.maybeNull(false));
+
+  console.log('\n--- Collections ---');
+  await runTest('list_size',  async () => { const l = await ep.getStringList(); return l.size(); });
+  await runTest('list_get_0', async () => { const l = await ep.getStringList(); return l.get(0); });
+  await runTest('list_get_2', async () => { const l = await ep.getStringList(); return l.get(2); });
+
+  await runTest('int_list_get_0', async () => { const l = await ep.getIntList(); return l.get(0); });
+  await runTest('int_list_get_4', async () => { const l = await ep.getIntList(); return l.get(4); });
+  await runTest('int_list_size',  async () => { const l = await ep.getIntList(); return l.size(); });
+
+  await runTest('set_size',         async () => { const s = await ep.getStringSet(); return s.size(); });
+  await runTest('set_contains_one', async () => { const s = await ep.getStringSet(); return s.contains('one'); });
+  await runTest('set_contains_xxx', async () => { const s = await ep.getStringSet(); return s.contains('xxx'); });
+
+  await runTest('map_size',           async () => { const m = await ep.getStringIntMap(); return m.size(); });
+  await runTest('map_get_a',          async () => { const m = await ep.getStringIntMap(); return m.get('a'); });
+  await runTest('map_get_c',          async () => { const m = await ep.getStringIntMap(); return m.get('c'); });
+  await runTest('map_contains_key_a', async () => { const m = await ep.getStringIntMap(); return m.containsKey('a'); });
+  await runTest('map_contains_key_z', async () => { const m = await ep.getStringIntMap(); return m.containsKey('z'); });
+
+  console.log('\n--- Type round-trips ---');
+  await runTest('echo_int_pos',    () => ep.echoInt(42));
+  await runTest('echo_int_neg',    () => ep.echoInt(-99));
+  await runTest('echo_long',       () => ep.echoLong(1000000000000));
+  await runTest('echo_double',     () => ep.echoDouble(3.14));
+  await runTest('echo_bool_true',  () => ep.echoBool(true));
+  await runTest('echo_bool_false', () => ep.echoBool(false));
+  await runTest('echo_string',     () => ep.echoString('js4j'));
+
+  console.log('\n--- Counter object ---');
+  await runTest('counter_initial', async () => {
+    const c = await ep.createCounter(10);
+    return c.getValue();
+  });
+  await runTest('counter_increment', async () => {
+    const c = await ep.createCounter(5);
+    await c.increment();
+    return c.getValue();
+  });
+  await runTest('counter_add', async () => {
+    const c = await ep.createCounter(3);
+    await c.add(7);
+    return c.getValue();
+  });
+
+  console.log('\n--- Exceptions ---');
+  await runTest('throw_exception', () => ep.throwException('boom'));
+  await runTest('divide_by_zero',  () => ep.divideInts(10, 0));
+
+  console.log('\n--- JVM namespace ---');
+  await runTest('Math_abs',           () => jvm.java.lang.Math.abs(-42));
+  await runTest('Math_max',           () => jvm.java.lang.Math.max(3, 7));
+  await runTest('Math_min',           () => jvm.java.lang.Math.min(3, 7));
+  await runTest('Math_PI',            () => gateway.getField(jvm.java.lang.Math, 'PI'));
+  await runTest('Integer_MAX',        () => gateway.getField(jvm.java.lang.Integer, 'MAX_VALUE'));
+  await runTest('String_valueOf_int', () => jvm.java.lang.String.valueOf(123));
+
+  console.log('\n--- StringBuilder (constructor via JVM) ---');
+  await runTest('stringbuilder_basic', async () => {
+    const sb = await jvm.java.lang.StringBuilder('Hello');
+    await sb.append(' World');
+    return sb.toString();
+  });
+
+  console.log('\n--- ArrayList (constructor via JVM) ---');
+  await runTest('arraylist_add_size', async () => {
+    const lst = await jvm.java.util.ArrayList();
+    await lst.add('x');
+    await lst.add('y');
+    return lst.size();
+  });
+
+  await gateway.close();
+
+  // Write results
+  const out = JSON.stringify(results, null, 2);
+  fs.writeFileSync(outputFile, out);
+  console.log(`\nResults written to ${outputFile}`);
+
+  const passed = Object.values(results).filter(r => r.status === 'ok').length;
+  const total = Object.keys(results).length;
+  console.log(`${passed}/${total} tests produced a result`);
+}
+
+main().catch((err) => {
+  console.error('Fatal error:', err);
+  process.exit(1);
+});

package/tests/comparison/test_py4j.py

@@ -0,0 +1,171 @@
+#!/usr/bin/env python3
+"""
+Comparison tests using py4j (Python implementation).
+
+Runs the same operations as test_js4j.js and writes results to
+comparison_results_py4j.json so they can be compared with js4j output.
+
+Usage:
+    python test_py4j.py [--gateway-port 25333] [--output results_py4j.json]
+"""
+
+import argparse
+import json
+import sys
+import traceback
+
+try:
+    from py4j.java_gateway import JavaGateway, GatewayParameters
+    from py4j.protocol import Py4JJavaError
+except ImportError:
+    print("ERROR: py4j is not installed. Run: pip install py4j", file=sys.stderr)
+    sys.exit(1)
+
+
+def run_test(name, fn, results):
+    """Run a single test and record the result."""
+    try:
+        value = fn()
+        results[name] = {"status": "ok", "value": value}
+        print(f"  PASS  {name} => {value!r}")
+    except Py4JJavaError as e:
+        results[name] = {"status": "java_error", "value": str(e.java_exception)}
+        print(f"  JAVA_ERR  {name}: {e.java_exception}")
+    except Exception as e:
+        results[name] = {"status": "error", "value": str(e)}
+        print(f"  ERROR  {name}: {e}")
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--gateway-port", type=int, default=25333)
+    parser.add_argument("--output", default="comparison_results_py4j.json")
+    args = parser.parse_args()
+
+    gateway = JavaGateway(
+        gateway_parameters=GatewayParameters(port=args.gateway_port)
+    )
+    ep = gateway.entry_point
+
+    results = {}
+
+    print("\n--- Arithmetic ---")
+    run_test("add_int",       lambda: ep.add(3, 4),         results)
+    run_test("add_negative",  lambda: ep.add(-10, 5),       results)
+    run_test("add_doubles",   lambda: ep.addDoubles(1.5, 2.5), results)
+    run_test("multiply",      lambda: ep.multiply(6, 7),    results)
+    run_test("divide",        lambda: ep.divide(10.0, 4.0), results)
+
+    print("\n--- Strings ---")
+    run_test("greet",             lambda: ep.greet("World"),               results)
+    run_test("concatenate",       lambda: ep.concatenate("foo", "bar"),    results)
+    run_test("string_length",     lambda: ep.stringLength("hello"),        results)
+    run_test("to_upper_case",     lambda: ep.toUpperCase("hello"),         results)
+    run_test("contains_true",     lambda: ep.containsSubstring("foobar", "oba"), results)
+    run_test("contains_false",    lambda: ep.containsSubstring("foobar", "xyz"), results)
+    run_test("repeat_string",     lambda: ep.repeatString("ab", 3),       results)
+
+    print("\n--- Booleans ---")
+    run_test("and_true",  lambda: ep.andBool(True, True),  results)
+    run_test("and_false", lambda: ep.andBool(True, False), results)
+    run_test("or_true",   lambda: ep.orBool(False, True),  results)
+    run_test("or_false",  lambda: ep.orBool(False, False), results)
+    run_test("not_true",  lambda: ep.notBool(True),        results)
+    run_test("not_false", lambda: ep.notBool(False),       results)
+
+    print("\n--- Null handling ---")
+    run_test("maybe_null_returns_null",  lambda: ep.maybeNull(True),  results)
+    run_test("maybe_null_returns_str",   lambda: ep.maybeNull(False), results)
+
+    print("\n--- Collections ---")
+    run_test("list_size",  lambda: ep.getStringList().size(), results)
+    run_test("list_get_0", lambda: ep.getStringList().get(0), results)
+    run_test("list_get_2", lambda: ep.getStringList().get(2), results)
+
+    run_test("int_list_get_0", lambda: ep.getIntList().get(0), results)
+    run_test("int_list_get_4", lambda: ep.getIntList().get(4), results)
+    run_test("int_list_size",  lambda: ep.getIntList().size(), results)
+
+    run_test("set_size",    lambda: ep.getStringSet().size(),                     results)
+    run_test("set_contains_one", lambda: ep.getStringSet().contains("one"),       results)
+    run_test("set_contains_xxx", lambda: ep.getStringSet().contains("xxx"),       results)
+
+    run_test("map_size",    lambda: ep.getStringIntMap().size(),                  results)
+    run_test("map_get_a",   lambda: ep.getStringIntMap().get("a"),                results)
+    run_test("map_get_c",   lambda: ep.getStringIntMap().get("c"),                results)
+    run_test("map_contains_key_a",  lambda: ep.getStringIntMap().containsKey("a"), results)
+    run_test("map_contains_key_z",  lambda: ep.getStringIntMap().containsKey("z"), results)
+
+    print("\n--- Type round-trips ---")
+    run_test("echo_int_pos",   lambda: ep.echoInt(42),        results)
+    run_test("echo_int_neg",   lambda: ep.echoInt(-99),       results)
+    run_test("echo_long",      lambda: ep.echoLong(10**12),   results)
+    run_test("echo_double",    lambda: ep.echoDouble(3.14),   results)
+    run_test("echo_bool_true", lambda: ep.echoBool(True),     results)
+    run_test("echo_bool_false",lambda: ep.echoBool(False),    results)
+    run_test("echo_string",    lambda: ep.echoString("js4j"), results)
+
+    print("\n--- Counter object ---")
+    run_test("counter_initial", lambda: ep.createCounter(10).getValue(),  results)
+    run_test("counter_increment", lambda: (
+        lambda c: (c.increment(), c.getValue())[1]
+    )(ep.createCounter(5)),                                                results)
+    run_test("counter_add", lambda: (
+        lambda c: (c.add(7), c.getValue())[1]
+    )(ep.createCounter(3)),                                                results)
+
+    print("\n--- Exceptions ---")
+    run_test("throw_exception", lambda: ep.throwException("boom"), results)
+    run_test("divide_by_zero",  lambda: ep.divideInts(10, 0),      results)
+
+    print("\n--- JVM namespace ---")
+    jvm = gateway.jvm
+    run_test("Math_abs",      lambda: jvm.java.lang.Math.abs(-42),     results)
+    run_test("Math_max",      lambda: jvm.java.lang.Math.max(3, 7),    results)
+    run_test("Math_min",      lambda: jvm.java.lang.Math.min(3, 7),    results)
+    run_test("Math_PI",       lambda: float(jvm.java.lang.Math.PI),    results)
+    run_test("Integer_MAX",   lambda: jvm.java.lang.Integer.MAX_VALUE, results)
+    run_test("String_valueOf_int", lambda: jvm.java.lang.String.valueOf(123), results)
+
+    print("\n--- StringBuilder (constructor via JVM) ---")
+    run_test("stringbuilder_basic", lambda: (
+        lambda sb: (sb.append(" World"), str(sb.toString()))[1]
+    )(jvm.java.lang.StringBuilder("Hello")),                              results)
+
+    print("\n--- ArrayList (constructor via JVM) ---")
+    run_test("arraylist_add_size", lambda: (
+        lambda lst: (lst.add("x"), lst.add("y"), lst.size())[2]
+    )(jvm.java.util.ArrayList()),                                          results)
+
+    gateway.close()
+
+    # Serialise — convert Java/py4j types to plain Python types
+    def serialise(v):
+        if v is None:
+            return None
+        if isinstance(v, bool):
+            return bool(v)
+        if isinstance(v, int):
+            return int(v)
+        if isinstance(v, float):
+            return float(v)
+        return str(v)
+
+    serialisable = {}
+    for key, rec in results.items():
+        serialisable[key] = {
+            "status": rec["status"],
+            "value": serialise(rec["value"]),
+        }
+
+    with open(args.output, "w") as f:
+        json.dump(serialisable, f, indent=2)
+
+    print(f"\nResults written to {args.output}")
+    passed = sum(1 for r in results.values() if r["status"] == "ok")
+    total = len(results)
+    print(f"{passed}/{total} tests produced a result (errors are expected for exception tests)")
+
+
+if __name__ == "__main__":
+    main()