indices = StringUtils.findAllIndices("hello", 'l');
+ assertEquals(2, indices.size());
+ assertEquals(2, indices.get(0));
+ assertEquals(3, indices.get(1));
+
+ indices = StringUtils.findAllIndices("aaa", 'a');
+ assertEquals(3, indices.size());
+
+ indices = StringUtils.findAllIndices("hello", 'z');
+ assertTrue(indices.isEmpty());
+
+ indices = StringUtils.findAllIndices("", 'a');
+ assertTrue(indices.isEmpty());
+
+ indices = StringUtils.findAllIndices(null, 'a');
+ assertTrue(indices.isEmpty());
+ }
+
+ @Test
+ void testIsNumeric() {
+ assertTrue(StringUtils.isNumeric("12345"));
+ assertTrue(StringUtils.isNumeric("0"));
+ assertTrue(StringUtils.isNumeric("007"));
+
+ assertFalse(StringUtils.isNumeric("12.34"));
+ assertFalse(StringUtils.isNumeric("-123"));
+ assertFalse(StringUtils.isNumeric("abc"));
+ assertFalse(StringUtils.isNumeric("12a34"));
+ assertFalse(StringUtils.isNumeric(""));
+ assertFalse(StringUtils.isNumeric(null));
+ }
+
+ @Test
+ void testRepeat() {
+ assertEquals("abcabcabc", StringUtils.repeat("abc", 3));
+ assertEquals("aaa", StringUtils.repeat("a", 3));
+ assertEquals("", StringUtils.repeat("abc", 0));
+ assertEquals("", StringUtils.repeat("abc", -1));
+ assertEquals("", StringUtils.repeat(null, 3));
+ }
+
+ @Test
+ void testTruncate() {
+ assertEquals("hello", StringUtils.truncate("hello", 10));
+ assertEquals("hel...", StringUtils.truncate("hello world", 6));
+ assertEquals("hello...", StringUtils.truncate("hello world", 8));
+ assertEquals("", StringUtils.truncate("hello", 0));
+ assertEquals("", StringUtils.truncate(null, 10));
+ assertEquals("hel", StringUtils.truncate("hello", 3));
+ }
+
+ @Test
+ void testToTitleCase() {
+ assertEquals("Hello", StringUtils.toTitleCase("hello"));
+ assertEquals("Hello", StringUtils.toTitleCase("HELLO"));
+ assertEquals("Hello", StringUtils.toTitleCase("hELLO"));
+ assertEquals("A", StringUtils.toTitleCase("a"));
+ assertEquals("", StringUtils.toTitleCase(""));
+ assertNull(StringUtils.toTitleCase(null));
+ }
+}
diff --git a/codeflash-benchmark/codeflash_benchmark/version.py b/codeflash-benchmark/codeflash_benchmark/version.py
index 18606e8d2..616b1bc71 100644
--- a/codeflash-benchmark/codeflash_benchmark/version.py
+++ b/codeflash-benchmark/codeflash_benchmark/version.py
@@ -1,2 +1,2 @@
# These version placeholders will be replaced by uv-dynamic-versioning during build.
-__version__ = "0.3.0"
+__version__ = "0.20.1.post242.dev0+7c7eeb5b"
diff --git a/codeflash-java-runtime/pom.xml b/codeflash-java-runtime/pom.xml
new file mode 100644
index 000000000..cb95732dd
--- /dev/null
+++ b/codeflash-java-runtime/pom.xml
@@ -0,0 +1,131 @@
+
+
+ 4.0.0
+
+ com.codeflash
+ codeflash-runtime
+ 1.0.0
+ jar
+
+ CodeFlash Java Runtime
+ Runtime library for CodeFlash Java instrumentation and comparison
+
+
+ 11
+ 11
+ UTF-8
+
+
+
+
+
+ com.google.code.gson
+ gson
+ 2.10.1
+
+
+
+
+ com.esotericsoftware
+ kryo
+ 5.6.2
+
+
+
+
+ org.objenesis
+ objenesis
+ 3.4
+
+
+
+
+ org.xerial
+ sqlite-jdbc
+ 3.45.0.0
+
+
+
+
+ org.junit.jupiter
+ junit-jupiter
+ 5.10.1
+ test
+
+
+
+
+
+
+
+ org.apache.maven.plugins
+ maven-compiler-plugin
+ 3.11.0
+
+ 11
+ 11
+
+
+
+
+
+ org.apache.maven.plugins
+ maven-surefire-plugin
+ 3.0.0
+
+
+ --add-opens java.base/java.util=ALL-UNNAMED
+ --add-opens java.base/java.lang=ALL-UNNAMED
+ --add-opens java.base/java.lang.reflect=ALL-UNNAMED
+ --add-opens java.base/java.math=ALL-UNNAMED
+ --add-opens java.base/java.io=ALL-UNNAMED
+ --add-opens java.base/java.net=ALL-UNNAMED
+ --add-opens java.base/java.time=ALL-UNNAMED
+
+
+
+
+
+
+ org.apache.maven.plugins
+ maven-shade-plugin
+ 3.5.1
+
+
+ package
+
+ shade
+
+
+
+
+ com.codeflash.Comparator
+
+
+
+
+ *:*
+
+ META-INF/*.SF
+ META-INF/*.DSA
+ META-INF/*.RSA
+
+
+
+
+
+
+
+
+
+
+ org.apache.maven.plugins
+ maven-install-plugin
+ 3.1.1
+
+
+
+
diff --git a/codeflash-java-runtime/src/main/java/com/codeflash/BenchmarkContext.java b/codeflash-java-runtime/src/main/java/com/codeflash/BenchmarkContext.java
new file mode 100644
index 000000000..c3699f00c
--- /dev/null
+++ b/codeflash-java-runtime/src/main/java/com/codeflash/BenchmarkContext.java
@@ -0,0 +1,42 @@
+package com.codeflash;
+
+/**
+ * Context object for tracking benchmark timing.
+ *
+ * Created by {@link CodeFlash#startBenchmark(String)} and passed to
+ * {@link CodeFlash#endBenchmark(BenchmarkContext)}.
+ */
+public final class BenchmarkContext {
+
+ private final String methodId;
+ private final long startTime;
+
+ /**
+ * Create a new benchmark context.
+ *
+ * @param methodId Method being benchmarked
+ * @param startTime Start time in nanoseconds
+ */
+ BenchmarkContext(String methodId, long startTime) {
+ this.methodId = methodId;
+ this.startTime = startTime;
+ }
+
+ /**
+ * Get the method ID.
+ *
+ * @return Method identifier
+ */
+ public String getMethodId() {
+ return methodId;
+ }
+
+ /**
+ * Get the start time.
+ *
+ * @return Start time in nanoseconds
+ */
+ public long getStartTime() {
+ return startTime;
+ }
+}
diff --git a/codeflash-java-runtime/src/main/java/com/codeflash/BenchmarkResult.java b/codeflash-java-runtime/src/main/java/com/codeflash/BenchmarkResult.java
new file mode 100644
index 000000000..dfe348e78
--- /dev/null
+++ b/codeflash-java-runtime/src/main/java/com/codeflash/BenchmarkResult.java
@@ -0,0 +1,160 @@
+package com.codeflash;
+
+import java.util.Arrays;
+
+/**
+ * Result of a benchmark run with statistical analysis.
+ *
+ * Provides JMH-style statistics including mean, standard deviation,
+ * and percentiles (p50, p90, p99).
+ */
+public final class BenchmarkResult {
+
+ private final String methodId;
+ private final long[] measurements;
+ private final long mean;
+ private final long stdDev;
+ private final long min;
+ private final long max;
+ private final long p50;
+ private final long p90;
+ private final long p99;
+
+ /**
+ * Create a benchmark result from raw measurements.
+ *
+ * @param methodId Method that was benchmarked
+ * @param measurements Array of timing measurements in nanoseconds
+ */
+ public BenchmarkResult(String methodId, long[] measurements) {
+ this.methodId = methodId;
+ this.measurements = measurements.clone();
+
+ // Sort for percentile calculations
+ long[] sorted = measurements.clone();
+ Arrays.sort(sorted);
+
+ this.min = sorted[0];
+ this.max = sorted[sorted.length - 1];
+ this.mean = calculateMean(sorted);
+ this.stdDev = calculateStdDev(sorted, this.mean);
+ this.p50 = percentile(sorted, 50);
+ this.p90 = percentile(sorted, 90);
+ this.p99 = percentile(sorted, 99);
+ }
+
+ private static long calculateMean(long[] values) {
+ long sum = 0;
+ for (long v : values) {
+ sum += v;
+ }
+ return sum / values.length;
+ }
+
+ private static long calculateStdDev(long[] values, long mean) {
+ if (values.length < 2) {
+ return 0;
+ }
+ long sumSquaredDiff = 0;
+ for (long v : values) {
+ long diff = v - mean;
+ sumSquaredDiff += diff * diff;
+ }
+ return (long) Math.sqrt(sumSquaredDiff / (values.length - 1));
+ }
+
+ private static long percentile(long[] sorted, int percentile) {
+ int index = (int) Math.ceil(percentile / 100.0 * sorted.length) - 1;
+ return sorted[Math.max(0, Math.min(index, sorted.length - 1))];
+ }
+
+ // Getters
+
+ public String getMethodId() {
+ return methodId;
+ }
+
+ public long[] getMeasurements() {
+ return measurements.clone();
+ }
+
+ public int getIterationCount() {
+ return measurements.length;
+ }
+
+ public long getMean() {
+ return mean;
+ }
+
+ public long getStdDev() {
+ return stdDev;
+ }
+
+ public long getMin() {
+ return min;
+ }
+
+ public long getMax() {
+ return max;
+ }
+
+ public long getP50() {
+ return p50;
+ }
+
+ public long getP90() {
+ return p90;
+ }
+
+ public long getP99() {
+ return p99;
+ }
+
+ /**
+ * Get mean in milliseconds.
+ */
+ public double getMeanMs() {
+ return mean / 1_000_000.0;
+ }
+
+ /**
+ * Get standard deviation in milliseconds.
+ */
+ public double getStdDevMs() {
+ return stdDev / 1_000_000.0;
+ }
+
+ /**
+ * Calculate coefficient of variation (CV) as percentage.
+ * CV = (stdDev / mean) * 100
+ * Lower is better (more stable measurements).
+ */
+ public double getCoefficientOfVariation() {
+ if (mean == 0) {
+ return 0;
+ }
+ return (stdDev * 100.0) / mean;
+ }
+
+ /**
+ * Check if measurements are stable (CV < 10%).
+ */
+ public boolean isStable() {
+ return getCoefficientOfVariation() < 10.0;
+ }
+
+ @Override
+ public String toString() {
+ return String.format(
+ "BenchmarkResult{method='%s', mean=%.3fms, stdDev=%.3fms, p50=%.3fms, p90=%.3fms, p99=%.3fms, cv=%.1f%%, iterations=%d}",
+ methodId,
+ getMeanMs(),
+ getStdDevMs(),
+ p50 / 1_000_000.0,
+ p90 / 1_000_000.0,
+ p99 / 1_000_000.0,
+ getCoefficientOfVariation(),
+ measurements.length
+ );
+ }
+}
diff --git a/codeflash-java-runtime/src/main/java/com/codeflash/Blackhole.java b/codeflash-java-runtime/src/main/java/com/codeflash/Blackhole.java
new file mode 100644
index 000000000..eeb6d4fd4
--- /dev/null
+++ b/codeflash-java-runtime/src/main/java/com/codeflash/Blackhole.java
@@ -0,0 +1,148 @@
+package com.codeflash;
+
+/**
+ * Utility class to prevent dead code elimination by the JIT compiler.
+ *
+ * Inspired by JMH's Blackhole class. When the JVM detects that a computed
+ * value is never used, it may eliminate the computation entirely. By
+ * "consuming" values through this class, we prevent such optimizations.
+ *
+ * Usage:
+ *
+ * int result = expensiveComputation();
+ * Blackhole.consume(result); // Prevents JIT from eliminating the computation
+ *
+ *
+ * The implementation uses volatile writes which act as memory barriers,
+ * preventing the JIT from optimizing away the computation.
+ */
+public final class Blackhole {
+
+ // Volatile fields act as memory barriers, preventing optimization
+ private static volatile int intSink;
+ private static volatile long longSink;
+ private static volatile double doubleSink;
+ private static volatile Object objectSink;
+
+ private Blackhole() {
+ // Utility class, no instantiation
+ }
+
+ /**
+ * Consume an int value to prevent dead code elimination.
+ *
+ * @param value Value to consume
+ */
+ public static void consume(int value) {
+ intSink = value;
+ }
+
+ /**
+ * Consume a long value to prevent dead code elimination.
+ *
+ * @param value Value to consume
+ */
+ public static void consume(long value) {
+ longSink = value;
+ }
+
+ /**
+ * Consume a double value to prevent dead code elimination.
+ *
+ * @param value Value to consume
+ */
+ public static void consume(double value) {
+ doubleSink = value;
+ }
+
+ /**
+ * Consume a float value to prevent dead code elimination.
+ *
+ * @param value Value to consume
+ */
+ public static void consume(float value) {
+ doubleSink = value;
+ }
+
+ /**
+ * Consume a boolean value to prevent dead code elimination.
+ *
+ * @param value Value to consume
+ */
+ public static void consume(boolean value) {
+ intSink = value ? 1 : 0;
+ }
+
+ /**
+ * Consume a byte value to prevent dead code elimination.
+ *
+ * @param value Value to consume
+ */
+ public static void consume(byte value) {
+ intSink = value;
+ }
+
+ /**
+ * Consume a short value to prevent dead code elimination.
+ *
+ * @param value Value to consume
+ */
+ public static void consume(short value) {
+ intSink = value;
+ }
+
+ /**
+ * Consume a char value to prevent dead code elimination.
+ *
+ * @param value Value to consume
+ */
+ public static void consume(char value) {
+ intSink = value;
+ }
+
+ /**
+ * Consume an Object to prevent dead code elimination.
+ * Works for any reference type including arrays and collections.
+ *
+ * @param value Value to consume
+ */
+ public static void consume(Object value) {
+ objectSink = value;
+ }
+
+ /**
+ * Consume an int array to prevent dead code elimination.
+ *
+ * @param values Array to consume
+ */
+ public static void consume(int[] values) {
+ objectSink = values;
+ if (values != null && values.length > 0) {
+ intSink = values[0];
+ }
+ }
+
+ /**
+ * Consume a long array to prevent dead code elimination.
+ *
+ * @param values Array to consume
+ */
+ public static void consume(long[] values) {
+ objectSink = values;
+ if (values != null && values.length > 0) {
+ longSink = values[0];
+ }
+ }
+
+ /**
+ * Consume a double array to prevent dead code elimination.
+ *
+ * @param values Array to consume
+ */
+ public static void consume(double[] values) {
+ objectSink = values;
+ if (values != null && values.length > 0) {
+ doubleSink = values[0];
+ }
+ }
+}
diff --git a/codeflash-java-runtime/src/main/java/com/codeflash/CodeFlash.java b/codeflash-java-runtime/src/main/java/com/codeflash/CodeFlash.java
new file mode 100644
index 000000000..bde06a335
--- /dev/null
+++ b/codeflash-java-runtime/src/main/java/com/codeflash/CodeFlash.java
@@ -0,0 +1,264 @@
+package com.codeflash;
+
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.concurrent.atomic.AtomicLong;
+
+/**
+ * Main API for CodeFlash runtime instrumentation.
+ *
+ * Provides methods for:
+ * - Capturing function inputs/outputs for behavior verification
+ * - Benchmarking with JMH-inspired best practices
+ * - Preventing dead code elimination
+ *
+ * Usage:
+ *
+ * // Behavior capture
+ * CodeFlash.captureInput("Calculator.add", a, b);
+ * int result = a + b;
+ * return CodeFlash.captureOutput("Calculator.add", result);
+ *
+ * // Benchmarking
+ * BenchmarkContext ctx = CodeFlash.startBenchmark("Calculator.add");
+ * // ... code to benchmark ...
+ * CodeFlash.endBenchmark(ctx);
+ *
+ */
+public final class CodeFlash {
+
+ private static final AtomicLong callIdCounter = new AtomicLong(0);
+ private static volatile ResultWriter resultWriter;
+ private static volatile boolean initialized = false;
+ private static volatile String outputFile;
+
+ // Configuration from environment variables
+ private static final int DEFAULT_WARMUP_ITERATIONS = 10;
+ private static final int DEFAULT_MEASUREMENT_ITERATIONS = 20;
+
+ static {
+ // Register shutdown hook to flush results
+ Runtime.getRuntime().addShutdownHook(new Thread(() -> {
+ if (resultWriter != null) {
+ resultWriter.close();
+ }
+ }));
+ }
+
+ private CodeFlash() {
+ // Utility class, no instantiation
+ }
+
+ /**
+ * Initialize CodeFlash with output file path.
+ * Called automatically if CODEFLASH_OUTPUT_FILE env var is set.
+ *
+ * @param outputPath Path to output file (SQLite database)
+ */
+ public static synchronized void initialize(String outputPath) {
+ if (!initialized || !outputPath.equals(outputFile)) {
+ outputFile = outputPath;
+ Path path = Paths.get(outputPath);
+ resultWriter = new ResultWriter(path);
+ initialized = true;
+ }
+ }
+
+ /**
+ * Get or create the result writer, initializing from environment if needed.
+ */
+ private static ResultWriter getWriter() {
+ if (!initialized) {
+ String envPath = System.getenv("CODEFLASH_OUTPUT_FILE");
+ if (envPath != null && !envPath.isEmpty()) {
+ initialize(envPath);
+ } else {
+ // Default to temp file if no env var
+ initialize(System.getProperty("java.io.tmpdir") + "/codeflash_results.db");
+ }
+ }
+ return resultWriter;
+ }
+
+ /**
+ * Capture function input arguments.
+ *
+ * @param methodId Unique identifier for the method (e.g., "Calculator.add")
+ * @param args Input arguments
+ */
+ public static void captureInput(String methodId, Object... args) {
+ long callId = callIdCounter.incrementAndGet();
+ byte[] argsBytes = Serializer.serialize(args);
+ getWriter().recordInput(callId, methodId, argsBytes, System.nanoTime());
+ }
+
+ /**
+ * Capture function output and return it (for chaining in return statements).
+ *
+ * @param methodId Unique identifier for the method
+ * @param result The result value
+ * @param Type of the result
+ * @return The same result (for chaining)
+ */
+ public static T captureOutput(String methodId, T result) {
+ long callId = callIdCounter.get(); // Use same callId as input
+ byte[] resultBytes = Serializer.serialize(result);
+ getWriter().recordOutput(callId, methodId, resultBytes, System.nanoTime());
+ return result;
+ }
+
+ /**
+ * Capture an exception thrown by the function.
+ *
+ * @param methodId Unique identifier for the method
+ * @param error The exception
+ */
+ public static void captureException(String methodId, Throwable error) {
+ long callId = callIdCounter.get();
+ byte[] errorBytes = Serializer.serializeException(error);
+ getWriter().recordError(callId, methodId, errorBytes, System.nanoTime());
+ }
+
+ /**
+ * Start a benchmark context for timing code execution.
+ * Implements JMH-inspired warmup and measurement phases.
+ *
+ * @param methodId Unique identifier for the method being benchmarked
+ * @return BenchmarkContext to pass to endBenchmark
+ */
+ public static BenchmarkContext startBenchmark(String methodId) {
+ return new BenchmarkContext(methodId, System.nanoTime());
+ }
+
+ /**
+ * End a benchmark and record the timing.
+ *
+ * @param ctx The benchmark context from startBenchmark
+ */
+ public static void endBenchmark(BenchmarkContext ctx) {
+ long endTime = System.nanoTime();
+ long duration = endTime - ctx.getStartTime();
+ getWriter().recordBenchmark(ctx.getMethodId(), duration, endTime);
+ }
+
+ /**
+ * Run a benchmark with proper JMH-style warmup and measurement.
+ *
+ * @param methodId Unique identifier for the method
+ * @param runnable Code to benchmark
+ * @return Benchmark result with statistics
+ */
+ public static BenchmarkResult runBenchmark(String methodId, Runnable runnable) {
+ int warmupIterations = getWarmupIterations();
+ int measurementIterations = getMeasurementIterations();
+
+ // Warmup phase - results discarded
+ for (int i = 0; i < warmupIterations; i++) {
+ runnable.run();
+ }
+
+ // Suggest GC before measurement (hint only, not guaranteed)
+ System.gc();
+
+ // Measurement phase
+ long[] measurements = new long[measurementIterations];
+ for (int i = 0; i < measurementIterations; i++) {
+ long start = System.nanoTime();
+ runnable.run();
+ measurements[i] = System.nanoTime() - start;
+ }
+
+ BenchmarkResult result = new BenchmarkResult(methodId, measurements);
+ getWriter().recordBenchmarkResult(methodId, result);
+ return result;
+ }
+
+ /**
+ * Run a benchmark that returns a value (prevents dead code elimination).
+ *
+ * @param methodId Unique identifier for the method
+ * @param supplier Code to benchmark that returns a value
+ * @param Return type
+ * @return Benchmark result with statistics
+ */
+ public static BenchmarkResult runBenchmarkWithResult(String methodId, java.util.function.Supplier supplier) {
+ int warmupIterations = getWarmupIterations();
+ int measurementIterations = getMeasurementIterations();
+
+ // Warmup phase - consume results to prevent dead code elimination
+ for (int i = 0; i < warmupIterations; i++) {
+ Blackhole.consume(supplier.get());
+ }
+
+ // Suggest GC before measurement
+ System.gc();
+
+ // Measurement phase
+ long[] measurements = new long[measurementIterations];
+ for (int i = 0; i < measurementIterations; i++) {
+ long start = System.nanoTime();
+ T result = supplier.get();
+ measurements[i] = System.nanoTime() - start;
+ Blackhole.consume(result); // Prevent dead code elimination
+ }
+
+ BenchmarkResult benchmarkResult = new BenchmarkResult(methodId, measurements);
+ getWriter().recordBenchmarkResult(methodId, benchmarkResult);
+ return benchmarkResult;
+ }
+
+ /**
+ * Get warmup iterations from environment or use default.
+ */
+ private static int getWarmupIterations() {
+ String env = System.getenv("CODEFLASH_WARMUP_ITERATIONS");
+ if (env != null) {
+ try {
+ return Integer.parseInt(env);
+ } catch (NumberFormatException e) {
+ // Use default
+ }
+ }
+ return DEFAULT_WARMUP_ITERATIONS;
+ }
+
+ /**
+ * Get measurement iterations from environment or use default.
+ */
+ private static int getMeasurementIterations() {
+ String env = System.getenv("CODEFLASH_MEASUREMENT_ITERATIONS");
+ if (env != null) {
+ try {
+ return Integer.parseInt(env);
+ } catch (NumberFormatException e) {
+ // Use default
+ }
+ }
+ return DEFAULT_MEASUREMENT_ITERATIONS;
+ }
+
+ /**
+ * Get the current call ID (for correlation).
+ *
+ * @return Current call ID
+ */
+ public static long getCurrentCallId() {
+ return callIdCounter.get();
+ }
+
+ /**
+ * Reset the call ID counter (for testing).
+ */
+ public static void resetCallId() {
+ callIdCounter.set(0);
+ }
+
+ /**
+ * Force flush all pending writes.
+ */
+ public static void flush() {
+ if (resultWriter != null) {
+ resultWriter.flush();
+ }
+ }
+}
diff --git a/codeflash-java-runtime/src/main/java/com/codeflash/Comparator.java b/codeflash-java-runtime/src/main/java/com/codeflash/Comparator.java
new file mode 100644
index 000000000..32d9f6034
--- /dev/null
+++ b/codeflash-java-runtime/src/main/java/com/codeflash/Comparator.java
@@ -0,0 +1,699 @@
+package com.codeflash;
+
+import java.lang.reflect.Array;
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.ResultSet;
+import java.sql.Statement;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+import java.util.*;
+
+/**
+ * Deep object comparison for verifying serialization/deserialization correctness.
+ *
+ * This comparator is used to verify that objects survive the serialize-deserialize
+ * cycle correctly. It handles:
+ * - Primitives and wrappers with epsilon tolerance for floats
+ * - Collections, Maps, and Arrays
+ * - Custom objects via reflection
+ * - NaN and Infinity special cases
+ * - Exception comparison
+ * - Placeholder rejection
+ */
+public final class Comparator {
+
+ private static final double EPSILON = 1e-9;
+
+ private Comparator() {
+ // Utility class
+ }
+
+ /**
+ * CLI entry point for comparing test results from two SQLite databases.
+ *
+ * Reads Kryo-serialized BLOBs from the test_results table, deserializes them,
+ * and compares using deep object comparison.
+ *
+ * Outputs JSON to stdout:
+ * {"equivalent": true/false, "totalInvocations": N, "diffs": [...]}
+ *
+ * Exit code: 0 if equivalent, 1 if different.
+ */
+ public static void main(String[] args) {
+ if (args.length != 2) {
+ System.err.println("Usage: java com.codeflash.Comparator ");
+ System.exit(2);
+ return;
+ }
+
+ String originalDbPath = args[0];
+ String candidateDbPath = args[1];
+
+ try {
+ Class.forName("org.sqlite.JDBC");
+ } catch (ClassNotFoundException e) {
+ printError("SQLite JDBC driver not found: " + e.getMessage());
+ System.exit(2);
+ return;
+ }
+
+ Map originalResults;
+ Map candidateResults;
+
+ try {
+ originalResults = readTestResults(originalDbPath);
+ } catch (Exception e) {
+ printError("Failed to read original database: " + e.getMessage());
+ System.exit(2);
+ return;
+ }
+
+ try {
+ candidateResults = readTestResults(candidateDbPath);
+ } catch (Exception e) {
+ printError("Failed to read candidate database: " + e.getMessage());
+ System.exit(2);
+ return;
+ }
+
+ Set allKeys = new LinkedHashSet<>();
+ allKeys.addAll(originalResults.keySet());
+ allKeys.addAll(candidateResults.keySet());
+
+ List diffs = new ArrayList<>();
+ int totalInvocations = allKeys.size();
+
+ for (String key : allKeys) {
+ byte[] origBytes = originalResults.get(key);
+ byte[] candBytes = candidateResults.get(key);
+
+ if (origBytes == null && candBytes == null) {
+ // Both null (void methods) — equivalent
+ continue;
+ }
+
+ if (origBytes == null) {
+ Object candObj = safeDeserialize(candBytes);
+ diffs.add(formatDiff("missing", key, 0, null, safeToString(candObj)));
+ continue;
+ }
+
+ if (candBytes == null) {
+ Object origObj = safeDeserialize(origBytes);
+ diffs.add(formatDiff("missing", key, 0, safeToString(origObj), null));
+ continue;
+ }
+
+ Object origObj = safeDeserialize(origBytes);
+ Object candObj = safeDeserialize(candBytes);
+
+ try {
+ if (!compare(origObj, candObj)) {
+ diffs.add(formatDiff("return_value", key, 0, safeToString(origObj), safeToString(candObj)));
+ }
+ } catch (KryoPlaceholderAccessException e) {
+ // Placeholder detected — skip comparison for this invocation
+ continue;
+ }
+ }
+
+ boolean equivalent = diffs.isEmpty();
+
+ StringBuilder json = new StringBuilder();
+ json.append("{\"equivalent\":").append(equivalent);
+ json.append(",\"totalInvocations\":").append(totalInvocations);
+ json.append(",\"diffs\":[");
+ for (int i = 0; i < diffs.size(); i++) {
+ if (i > 0) json.append(",");
+ json.append(diffs.get(i));
+ }
+ json.append("]}");
+
+ System.out.println(json.toString());
+ System.exit(equivalent ? 0 : 1);
+ }
+
+ private static Map readTestResults(String dbPath) throws Exception {
+ Map results = new LinkedHashMap<>();
+ String url = "jdbc:sqlite:" + dbPath;
+
+ try (Connection conn = DriverManager.getConnection(url);
+ Statement stmt = conn.createStatement();
+ ResultSet rs = stmt.executeQuery(
+ "SELECT iteration_id, return_value FROM test_results WHERE loop_index = 1")) {
+ while (rs.next()) {
+ String iterationId = rs.getString("iteration_id");
+ byte[] returnValue = rs.getBytes("return_value");
+ // Strip the CODEFLASH_TEST_ITERATION suffix (e.g. "7_0" -> "7")
+ // Original runs with _0, candidate with _1, but the test iteration
+ // counter before the underscore is what identifies the invocation.
+ int lastUnderscore = iterationId.lastIndexOf('_');
+ if (lastUnderscore > 0) {
+ iterationId = iterationId.substring(0, lastUnderscore);
+ }
+ results.put(iterationId, returnValue);
+ }
+ }
+ return results;
+ }
+
+ private static Object safeDeserialize(byte[] data) {
+ if (data == null) {
+ return null;
+ }
+ try {
+ return Serializer.deserialize(data);
+ } catch (Exception e) {
+ return java.util.Map.of("__type", "DeserializationError", "error", String.valueOf(e.getMessage()));
+ }
+ }
+
+ private static String safeToString(Object obj) {
+ if (obj == null) {
+ return "null";
+ }
+ try {
+ if (obj.getClass().isArray()) {
+ return java.util.Arrays.deepToString(new Object[]{obj});
+ }
+ return String.valueOf(obj);
+ } catch (Exception e) {
+ return "";
+ }
+ }
+
+ private static String formatDiff(String scope, String methodId, int callId,
+ String originalValue, String candidateValue) {
+ StringBuilder sb = new StringBuilder();
+ sb.append("{\"scope\":\"").append(escapeJson(scope)).append("\"");
+ sb.append(",\"methodId\":\"").append(escapeJson(methodId)).append("\"");
+ sb.append(",\"callId\":").append(callId);
+ sb.append(",\"originalValue\":").append(jsonStringOrNull(originalValue));
+ sb.append(",\"candidateValue\":").append(jsonStringOrNull(candidateValue));
+ sb.append("}");
+ return sb.toString();
+ }
+
+ private static String jsonStringOrNull(String value) {
+ if (value == null) {
+ return "null";
+ }
+ return "\"" + escapeJson(value) + "\"";
+ }
+
+ private static String escapeJson(String s) {
+ if (s == null) return "";
+ return s.replace("\\", "\\\\")
+ .replace("\"", "\\\"")
+ .replace("\n", "\\n")
+ .replace("\r", "\\r")
+ .replace("\t", "\\t");
+ }
+
+ private static void printError(String message) {
+ System.out.println("{\"error\":\"" + escapeJson(message) + "\"}");
+ }
+
+ /**
+ * Compare two objects for deep equality.
+ *
+ * @param orig The original object
+ * @param newObj The object to compare against
+ * @return true if objects are equivalent
+ * @throws KryoPlaceholderAccessException if comparison involves a placeholder
+ */
+ public static boolean compare(Object orig, Object newObj) {
+ return compareInternal(orig, newObj, new IdentityHashMap<>());
+ }
+
+ /**
+ * Compare two objects, returning a detailed result.
+ *
+ * @param orig The original object
+ * @param newObj The object to compare against
+ * @return ComparisonResult with details about the comparison
+ */
+ public static ComparisonResult compareWithDetails(Object orig, Object newObj) {
+ try {
+ boolean equal = compareInternal(orig, newObj, new IdentityHashMap<>());
+ return new ComparisonResult(equal, null);
+ } catch (KryoPlaceholderAccessException e) {
+ return new ComparisonResult(false, e.getMessage());
+ }
+ }
+
+ private static boolean compareInternal(Object orig, Object newObj,
+ IdentityHashMap seen) {
+ // Handle nulls
+ if (orig == null && newObj == null) {
+ return true;
+ }
+ if (orig == null || newObj == null) {
+ return false;
+ }
+
+ // Detect and reject KryoPlaceholder
+ if (orig instanceof KryoPlaceholder) {
+ KryoPlaceholder p = (KryoPlaceholder) orig;
+ throw new KryoPlaceholderAccessException(
+ "Cannot compare: original contains placeholder for unserializable object",
+ p.getObjType(), p.getPath());
+ }
+ if (newObj instanceof KryoPlaceholder) {
+ KryoPlaceholder p = (KryoPlaceholder) newObj;
+ throw new KryoPlaceholderAccessException(
+ "Cannot compare: new object contains placeholder for unserializable object",
+ p.getObjType(), p.getPath());
+ }
+
+ // Handle exceptions specially
+ if (orig instanceof Throwable && newObj instanceof Throwable) {
+ return compareExceptions((Throwable) orig, (Throwable) newObj);
+ }
+
+ Class origClass = orig.getClass();
+ Class newClass = newObj.getClass();
+
+ // Check type compatibility
+ if (!origClass.equals(newClass)) {
+ if (!areTypesCompatible(origClass, newClass)) {
+ return false;
+ }
+ }
+
+ // Handle primitives and wrappers
+ if (orig instanceof Boolean) {
+ return orig.equals(newObj);
+ }
+ if (orig instanceof Character) {
+ return orig.equals(newObj);
+ }
+ if (orig instanceof String) {
+ return orig.equals(newObj);
+ }
+ if (orig instanceof Number) {
+ return compareNumbers((Number) orig, (Number) newObj);
+ }
+
+ // Handle enums
+ if (origClass.isEnum()) {
+ return orig.equals(newObj);
+ }
+
+ // Handle Class objects
+ if (orig instanceof Class) {
+ return orig.equals(newObj);
+ }
+
+ // Handle date/time types
+ if (orig instanceof Date || orig instanceof LocalDateTime ||
+ orig instanceof LocalDate || orig instanceof LocalTime) {
+ return orig.equals(newObj);
+ }
+
+ // Handle Optional
+ if (orig instanceof Optional && newObj instanceof Optional) {
+ return compareOptionals((Optional) orig, (Optional) newObj, seen);
+ }
+
+ // Check for circular reference to prevent infinite recursion
+ if (seen.containsKey(orig)) {
+ // If we've seen this object before, just check identity
+ return seen.get(orig) == newObj;
+ }
+ seen.put(orig, newObj);
+
+ try {
+ // Handle arrays
+ if (origClass.isArray()) {
+ return compareArrays(orig, newObj, seen);
+ }
+
+ // Handle collections
+ if (orig instanceof Collection && newObj instanceof Collection) {
+ return compareCollections((Collection) orig, (Collection) newObj, seen);
+ }
+
+ // Handle maps
+ if (orig instanceof Map && newObj instanceof Map) {
+ return compareMaps((Map) orig, (Map) newObj, seen);
+ }
+
+ // Handle general objects via reflection
+ return compareObjects(orig, newObj, seen);
+
+ } finally {
+ seen.remove(orig);
+ }
+ }
+
+ /**
+ * Check if two types are compatible for comparison.
+ */
+ private static boolean areTypesCompatible(Class type1, Class type2) {
+ // Allow comparing different Collection implementations
+ if (Collection.class.isAssignableFrom(type1) && Collection.class.isAssignableFrom(type2)) {
+ return true;
+ }
+ // Allow comparing different Map implementations
+ if (Map.class.isAssignableFrom(type1) && Map.class.isAssignableFrom(type2)) {
+ return true;
+ }
+ // Allow comparing different Number types
+ if (Number.class.isAssignableFrom(type1) && Number.class.isAssignableFrom(type2)) {
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * Compare two numbers with epsilon tolerance for floating point.
+ */
+ private static boolean compareNumbers(Number n1, Number n2) {
+ // Handle BigDecimal - exact comparison using compareTo
+ if (n1 instanceof java.math.BigDecimal && n2 instanceof java.math.BigDecimal) {
+ return ((java.math.BigDecimal) n1).compareTo((java.math.BigDecimal) n2) == 0;
+ }
+
+ // Handle BigInteger - exact comparison using equals
+ if (n1 instanceof java.math.BigInteger && n2 instanceof java.math.BigInteger) {
+ return n1.equals(n2);
+ }
+
+ // Handle BigDecimal vs other number types
+ if (n1 instanceof java.math.BigDecimal || n2 instanceof java.math.BigDecimal) {
+ java.math.BigDecimal bd1 = toBigDecimal(n1);
+ java.math.BigDecimal bd2 = toBigDecimal(n2);
+ return bd1.compareTo(bd2) == 0;
+ }
+
+ // Handle BigInteger vs other number types
+ if (n1 instanceof java.math.BigInteger || n2 instanceof java.math.BigInteger) {
+ java.math.BigInteger bi1 = toBigInteger(n1);
+ java.math.BigInteger bi2 = toBigInteger(n2);
+ return bi1.equals(bi2);
+ }
+
+ // Handle floating point with epsilon
+ if (n1 instanceof Double || n1 instanceof Float ||
+ n2 instanceof Double || n2 instanceof Float) {
+
+ double d1 = n1.doubleValue();
+ double d2 = n2.doubleValue();
+
+ // Handle NaN
+ if (Double.isNaN(d1) && Double.isNaN(d2)) {
+ return true;
+ }
+ if (Double.isNaN(d1) || Double.isNaN(d2)) {
+ return false;
+ }
+
+ // Handle Infinity
+ if (Double.isInfinite(d1) && Double.isInfinite(d2)) {
+ return (d1 > 0) == (d2 > 0); // Same sign
+ }
+ if (Double.isInfinite(d1) || Double.isInfinite(d2)) {
+ return false;
+ }
+
+ // Compare with relative and absolute epsilon
+ double diff = Math.abs(d1 - d2);
+ if (diff < EPSILON) {
+ return true; // Absolute tolerance
+ }
+ // Relative tolerance for large numbers
+ double maxAbs = Math.max(Math.abs(d1), Math.abs(d2));
+ return diff <= EPSILON * maxAbs;
+ }
+
+ // Integer types - exact comparison
+ return n1.longValue() == n2.longValue();
+ }
+
+ /**
+ * Convert a Number to BigDecimal.
+ */
+ private static java.math.BigDecimal toBigDecimal(Number n) {
+ if (n instanceof java.math.BigDecimal) {
+ return (java.math.BigDecimal) n;
+ }
+ if (n instanceof java.math.BigInteger) {
+ return new java.math.BigDecimal((java.math.BigInteger) n);
+ }
+ if (n instanceof Double || n instanceof Float) {
+ return java.math.BigDecimal.valueOf(n.doubleValue());
+ }
+ return java.math.BigDecimal.valueOf(n.longValue());
+ }
+
+ /**
+ * Convert a Number to BigInteger.
+ */
+ private static java.math.BigInteger toBigInteger(Number n) {
+ if (n instanceof java.math.BigInteger) {
+ return (java.math.BigInteger) n;
+ }
+ if (n instanceof java.math.BigDecimal) {
+ return ((java.math.BigDecimal) n).toBigInteger();
+ }
+ return java.math.BigInteger.valueOf(n.longValue());
+ }
+
+ /**
+ * Compare two exceptions.
+ */
+ private static boolean compareExceptions(Throwable orig, Throwable newEx) {
+ // Must be same type
+ if (!orig.getClass().equals(newEx.getClass())) {
+ return false;
+ }
+ // Compare message (both may be null)
+ return Objects.equals(orig.getMessage(), newEx.getMessage());
+ }
+
+ /**
+ * Compare two Optional values.
+ */
+ private static boolean compareOptionals(Optional orig, Optional newOpt,
+ IdentityHashMap seen) {
+ if (orig.isPresent() != newOpt.isPresent()) {
+ return false;
+ }
+ if (!orig.isPresent()) {
+ return true; // Both empty
+ }
+ return compareInternal(orig.get(), newOpt.get(), seen);
+ }
+
+ /**
+ * Compare two arrays.
+ */
+ private static boolean compareArrays(Object orig, Object newObj,
+ IdentityHashMap seen) {
+ int length1 = Array.getLength(orig);
+ int length2 = Array.getLength(newObj);
+
+ if (length1 != length2) {
+ return false;
+ }
+
+ for (int i = 0; i < length1; i++) {
+ Object elem1 = Array.get(orig, i);
+ Object elem2 = Array.get(newObj, i);
+ if (!compareInternal(elem1, elem2, seen)) {
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ /**
+ * Compare two collections.
+ */
+ private static boolean compareCollections(Collection orig, Collection newColl,
+ IdentityHashMap seen) {
+ if (orig.size() != newColl.size()) {
+ return false;
+ }
+
+ // For Sets, compare element-by-element (order doesn't matter)
+ if (orig instanceof Set && newColl instanceof Set) {
+ return compareSets((Set) orig, (Set) newColl, seen);
+ }
+
+ // For ordered collections (List, etc.), compare in order
+ Iterator iter1 = orig.iterator();
+ Iterator iter2 = newColl.iterator();
+
+ while (iter1.hasNext() && iter2.hasNext()) {
+ if (!compareInternal(iter1.next(), iter2.next(), seen)) {
+ return false;
+ }
+ }
+
+ return !iter1.hasNext() && !iter2.hasNext();
+ }
+
+ /**
+ * Compare two sets (order-independent).
+ */
+ private static boolean compareSets(Set orig, Set newSet,
+ IdentityHashMap seen) {
+ if (orig.size() != newSet.size()) {
+ return false;
+ }
+
+ // For each element in orig, find a matching element in newSet
+ for (Object elem1 : orig) {
+ boolean found = false;
+ for (Object elem2 : newSet) {
+ try {
+ if (compareInternal(elem1, elem2, new IdentityHashMap<>(seen))) {
+ found = true;
+ break;
+ }
+ } catch (KryoPlaceholderAccessException e) {
+ // Propagate placeholder exceptions
+ throw e;
+ }
+ }
+ if (!found) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ /**
+ * Compare two maps.
+ * Uses deep comparison for keys instead of relying on equals()/hashCode().
+ */
+ private static boolean compareMaps(Map orig, Map newMap,
+ IdentityHashMap seen) {
+ if (orig.size() != newMap.size()) {
+ return false;
+ }
+
+ // For each entry in orig, find a matching entry in newMap using deep comparison
+ for (Map.Entry entry1 : orig.entrySet()) {
+ Object key1 = entry1.getKey();
+ Object value1 = entry1.getValue();
+
+ boolean foundMatch = false;
+
+ // Search for matching key in newMap using deep comparison
+ for (Map.Entry entry2 : newMap.entrySet()) {
+ Object key2 = entry2.getKey();
+
+ // Use deep comparison for keys
+ try {
+ if (compareInternal(key1, key2, new IdentityHashMap<>(seen))) {
+ // Found matching key - now compare values
+ Object value2 = entry2.getValue();
+ if (!compareInternal(value1, value2, seen)) {
+ return false;
+ }
+ foundMatch = true;
+ break;
+ }
+ } catch (KryoPlaceholderAccessException e) {
+ // Propagate placeholder exceptions
+ throw e;
+ }
+ }
+
+ if (!foundMatch) {
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ /**
+ * Compare two objects via reflection.
+ */
+ private static boolean compareObjects(Object orig, Object newObj,
+ IdentityHashMap seen) {
+ Class clazz = orig.getClass();
+
+ // If class has a custom equals method, use it
+ try {
+ if (hasCustomEquals(clazz)) {
+ return orig.equals(newObj);
+ }
+ } catch (Exception e) {
+ // Fall through to field comparison
+ }
+
+ // Compare all fields via reflection
+ Class currentClass = clazz;
+ while (currentClass != null && currentClass != Object.class) {
+ for (Field field : currentClass.getDeclaredFields()) {
+ if (Modifier.isStatic(field.getModifiers()) ||
+ Modifier.isTransient(field.getModifiers())) {
+ continue;
+ }
+
+ try {
+ field.setAccessible(true);
+ Object value1 = field.get(orig);
+ Object value2 = field.get(newObj);
+
+ if (!compareInternal(value1, value2, seen)) {
+ return false;
+ }
+ } catch (IllegalAccessException e) {
+ // Can't access field - assume not equal
+ return false;
+ }
+ }
+ currentClass = currentClass.getSuperclass();
+ }
+
+ return true;
+ }
+
+ /**
+ * Check if a class has a custom equals method (not from Object).
+ */
+ private static boolean hasCustomEquals(Class clazz) {
+ try {
+ java.lang.reflect.Method equalsMethod = clazz.getMethod("equals", Object.class);
+ return equalsMethod.getDeclaringClass() != Object.class;
+ } catch (NoSuchMethodException e) {
+ return false;
+ }
+ }
+
+ /**
+ * Result of a comparison with optional error details.
+ */
+ public static class ComparisonResult {
+ private final boolean equal;
+ private final String errorMessage;
+
+ public ComparisonResult(boolean equal, String errorMessage) {
+ this.equal = equal;
+ this.errorMessage = errorMessage;
+ }
+
+ public boolean isEqual() {
+ return equal;
+ }
+
+ public String getErrorMessage() {
+ return errorMessage;
+ }
+
+ public boolean hasError() {
+ return errorMessage != null;
+ }
+ }
+}
diff --git a/codeflash-java-runtime/src/main/java/com/codeflash/KryoPlaceholder.java b/codeflash-java-runtime/src/main/java/com/codeflash/KryoPlaceholder.java
new file mode 100644
index 000000000..a38254d21
--- /dev/null
+++ b/codeflash-java-runtime/src/main/java/com/codeflash/KryoPlaceholder.java
@@ -0,0 +1,118 @@
+package com.codeflash;
+
+import java.io.Serializable;
+import java.util.Objects;
+
+/**
+ * Placeholder for objects that could not be serialized.
+ *
+ * When Serializer encounters an object that cannot be serialized
+ * (e.g., Socket, Connection, Stream), it replaces it with a KryoPlaceholder
+ * that stores metadata about the original object.
+ *
+ * This allows the rest of the object graph to be serialized while preserving
+ * information about what was lost. If code attempts to use the placeholder
+ * during replay tests, an error can be detected.
+ */
+public final class KryoPlaceholder implements Serializable {
+
+ private static final long serialVersionUID = 1L;
+ private static final int MAX_STR_LENGTH = 100;
+
+ private final String objType;
+ private final String objStr;
+ private final String errorMsg;
+ private final String path;
+
+ /**
+ * Create a placeholder for an unserializable object.
+ *
+ * @param objType The fully qualified class name of the original object
+ * @param objStr String representation of the object (may be truncated)
+ * @param errorMsg The error message explaining why serialization failed
+ * @param path The path in the object graph (e.g., "data.nested[0].socket")
+ */
+ public KryoPlaceholder(String objType, String objStr, String errorMsg, String path) {
+ this.objType = objType;
+ this.objStr = truncate(objStr, MAX_STR_LENGTH);
+ this.errorMsg = errorMsg;
+ this.path = path;
+ }
+
+ /**
+ * Create a placeholder from an object and error.
+ */
+ public static KryoPlaceholder create(Object obj, String errorMsg, String path) {
+ String objType = obj != null ? obj.getClass().getName() : "null";
+ String objStr = safeToString(obj);
+ return new KryoPlaceholder(objType, objStr, errorMsg, path);
+ }
+
+ private static String safeToString(Object obj) {
+ if (obj == null) {
+ return "null";
+ }
+ try {
+ return obj.toString();
+ } catch (Exception e) {
+ return "";
+ }
+ }
+
+ private static String truncate(String s, int maxLength) {
+ if (s == null) {
+ return null;
+ }
+ if (s.length() <= maxLength) {
+ return s;
+ }
+ return s.substring(0, maxLength) + "...";
+ }
+
+ /**
+ * Get the original type name of the unserializable object.
+ */
+ public String getObjType() {
+ return objType;
+ }
+
+ /**
+ * Get the string representation of the original object (may be truncated).
+ */
+ public String getObjStr() {
+ return objStr;
+ }
+
+ /**
+ * Get the error message explaining why serialization failed.
+ */
+ public String getErrorMsg() {
+ return errorMsg;
+ }
+
+ /**
+ * Get the path in the object graph where this placeholder was created.
+ */
+ public String getPath() {
+ return path;
+ }
+
+ @Override
+ public String toString() {
+ return String.format("", objType, path, objStr);
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) return true;
+ if (o == null || getClass() != o.getClass()) return false;
+ KryoPlaceholder that = (KryoPlaceholder) o;
+ return Objects.equals(objType, that.objType) &&
+ Objects.equals(path, that.path);
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(objType, path);
+ }
+}
diff --git a/codeflash-java-runtime/src/main/java/com/codeflash/KryoPlaceholderAccessException.java b/codeflash-java-runtime/src/main/java/com/codeflash/KryoPlaceholderAccessException.java
new file mode 100644
index 000000000..86e768dde
--- /dev/null
+++ b/codeflash-java-runtime/src/main/java/com/codeflash/KryoPlaceholderAccessException.java
@@ -0,0 +1,40 @@
+package com.codeflash;
+
+/**
+ * Exception thrown when attempting to access or use a KryoPlaceholder.
+ *
+ * This exception indicates that code attempted to interact with an object
+ * that could not be serialized and was replaced with a placeholder. This
+ * typically means the test behavior cannot be verified for this code path.
+ */
+public class KryoPlaceholderAccessException extends RuntimeException {
+
+ private final String objType;
+ private final String path;
+
+ public KryoPlaceholderAccessException(String message, String objType, String path) {
+ super(message);
+ this.objType = objType;
+ this.path = path;
+ }
+
+ /**
+ * Get the original type name of the unserializable object.
+ */
+ public String getObjType() {
+ return objType;
+ }
+
+ /**
+ * Get the path in the object graph where the placeholder was created.
+ */
+ public String getPath() {
+ return path;
+ }
+
+ @Override
+ public String toString() {
+ return String.format("KryoPlaceholderAccessException[type=%s, path=%s]: %s",
+ objType, path, getMessage());
+ }
+}
diff --git a/codeflash-java-runtime/src/main/java/com/codeflash/ResultWriter.java b/codeflash-java-runtime/src/main/java/com/codeflash/ResultWriter.java
new file mode 100644
index 000000000..083d7a09c
--- /dev/null
+++ b/codeflash-java-runtime/src/main/java/com/codeflash/ResultWriter.java
@@ -0,0 +1,318 @@
+package com.codeflash;
+
+import java.nio.file.Path;
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+/**
+ * Writes benchmark and behavior capture results to SQLite database.
+ *
+ * Uses a background thread for non-blocking writes to minimize
+ * impact on benchmark measurements.
+ *
+ * Database schema:
+ * - invocations: call_id, method_id, args_blob, result_blob, error_blob, start_time, end_time
+ * - benchmarks: method_id, duration_ns, timestamp
+ * - benchmark_results: method_id, mean_ns, stddev_ns, min_ns, max_ns, p50_ns, p90_ns, p99_ns, iterations
+ */
+public final class ResultWriter {
+
+ private final Path dbPath;
+ private final Connection connection;
+ private final BlockingQueue writeQueue;
+ private final Thread writerThread;
+ private final AtomicBoolean running;
+
+ // Prepared statements for performance
+ private PreparedStatement insertInvocationInput;
+ private PreparedStatement updateInvocationOutput;
+ private PreparedStatement updateInvocationError;
+ private PreparedStatement insertBenchmark;
+ private PreparedStatement insertBenchmarkResult;
+
+ /**
+ * Create a new ResultWriter that writes to the specified database file.
+ *
+ * @param dbPath Path to SQLite database file (will be created if not exists)
+ */
+ public ResultWriter(Path dbPath) {
+ this.dbPath = dbPath;
+ this.writeQueue = new LinkedBlockingQueue<>();
+ this.running = new AtomicBoolean(true);
+
+ try {
+ // Create connection and initialize schema
+ this.connection = DriverManager.getConnection("jdbc:sqlite:" + dbPath.toAbsolutePath());
+ initializeSchema();
+ prepareStatements();
+
+ // Start background writer thread
+ this.writerThread = new Thread(this::writerLoop, "codeflash-writer");
+ this.writerThread.setDaemon(true);
+ this.writerThread.start();
+
+ } catch (SQLException e) {
+ throw new RuntimeException("Failed to initialize ResultWriter: " + e.getMessage(), e);
+ }
+ }
+
+ private void initializeSchema() throws SQLException {
+ try (Statement stmt = connection.createStatement()) {
+ // Invocations table - stores input/output/error for each function call as BLOBs
+ stmt.execute(
+ "CREATE TABLE IF NOT EXISTS invocations (" +
+ "call_id INTEGER PRIMARY KEY, " +
+ "method_id TEXT NOT NULL, " +
+ "args_blob BLOB, " +
+ "result_blob BLOB, " +
+ "error_blob BLOB, " +
+ "start_time INTEGER, " +
+ "end_time INTEGER)"
+ );
+
+ // Benchmarks table - stores individual benchmark timings
+ stmt.execute(
+ "CREATE TABLE IF NOT EXISTS benchmarks (" +
+ "id INTEGER PRIMARY KEY AUTOINCREMENT, " +
+ "method_id TEXT NOT NULL, " +
+ "duration_ns INTEGER NOT NULL, " +
+ "timestamp INTEGER NOT NULL)"
+ );
+
+ // Benchmark results table - stores aggregated statistics
+ stmt.execute(
+ "CREATE TABLE IF NOT EXISTS benchmark_results (" +
+ "method_id TEXT PRIMARY KEY, " +
+ "mean_ns INTEGER NOT NULL, " +
+ "stddev_ns INTEGER NOT NULL, " +
+ "min_ns INTEGER NOT NULL, " +
+ "max_ns INTEGER NOT NULL, " +
+ "p50_ns INTEGER NOT NULL, " +
+ "p90_ns INTEGER NOT NULL, " +
+ "p99_ns INTEGER NOT NULL, " +
+ "iterations INTEGER NOT NULL, " +
+ "coefficient_of_variation REAL NOT NULL)"
+ );
+
+ // Create indexes for faster queries
+ stmt.execute("CREATE INDEX IF NOT EXISTS idx_invocations_method ON invocations(method_id)");
+ stmt.execute("CREATE INDEX IF NOT EXISTS idx_benchmarks_method ON benchmarks(method_id)");
+ }
+ }
+
+ private void prepareStatements() throws SQLException {
+ insertInvocationInput = connection.prepareStatement(
+ "INSERT INTO invocations (call_id, method_id, args_blob, start_time) VALUES (?, ?, ?, ?)"
+ );
+ updateInvocationOutput = connection.prepareStatement(
+ "UPDATE invocations SET result_blob = ?, end_time = ? WHERE call_id = ?"
+ );
+ updateInvocationError = connection.prepareStatement(
+ "UPDATE invocations SET error_blob = ?, end_time = ? WHERE call_id = ?"
+ );
+ insertBenchmark = connection.prepareStatement(
+ "INSERT INTO benchmarks (method_id, duration_ns, timestamp) VALUES (?, ?, ?)"
+ );
+ insertBenchmarkResult = connection.prepareStatement(
+ "INSERT OR REPLACE INTO benchmark_results " +
+ "(method_id, mean_ns, stddev_ns, min_ns, max_ns, p50_ns, p90_ns, p99_ns, iterations, coefficient_of_variation) " +
+ "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"
+ );
+ }
+
+ /**
+ * Record function input (beginning of invocation).
+ */
+ public void recordInput(long callId, String methodId, byte[] argsBlob, long startTime) {
+ writeQueue.offer(new WriteTask(WriteType.INPUT, callId, methodId, argsBlob, null, null, startTime, 0, null));
+ }
+
+ /**
+ * Record function output (successful completion).
+ */
+ public void recordOutput(long callId, String methodId, byte[] resultBlob, long endTime) {
+ writeQueue.offer(new WriteTask(WriteType.OUTPUT, callId, methodId, null, resultBlob, null, 0, endTime, null));
+ }
+
+ /**
+ * Record function error (exception thrown).
+ */
+ public void recordError(long callId, String methodId, byte[] errorBlob, long endTime) {
+ writeQueue.offer(new WriteTask(WriteType.ERROR, callId, methodId, null, null, errorBlob, 0, endTime, null));
+ }
+
+ /**
+ * Record a single benchmark timing.
+ */
+ public void recordBenchmark(String methodId, long durationNs, long timestamp) {
+ writeQueue.offer(new WriteTask(WriteType.BENCHMARK, 0, methodId, null, null, null, durationNs, timestamp, null));
+ }
+
+ /**
+ * Record aggregated benchmark results.
+ */
+ public void recordBenchmarkResult(String methodId, BenchmarkResult result) {
+ writeQueue.offer(new WriteTask(WriteType.BENCHMARK_RESULT, 0, methodId, null, null, null, 0, 0, result));
+ }
+
+ /**
+ * Background writer loop - processes write tasks from queue.
+ */
+ private void writerLoop() {
+ while (running.get() || !writeQueue.isEmpty()) {
+ try {
+ WriteTask task = writeQueue.poll(100, TimeUnit.MILLISECONDS);
+ if (task != null) {
+ executeTask(task);
+ }
+ } catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ break;
+ } catch (SQLException e) {
+ System.err.println("CodeFlash ResultWriter error: " + e.getMessage());
+ }
+ }
+
+ // Process remaining tasks
+ WriteTask task;
+ while ((task = writeQueue.poll()) != null) {
+ try {
+ executeTask(task);
+ } catch (SQLException e) {
+ System.err.println("CodeFlash ResultWriter error: " + e.getMessage());
+ }
+ }
+ }
+
+ private void executeTask(WriteTask task) throws SQLException {
+ switch (task.type) {
+ case INPUT:
+ insertInvocationInput.setLong(1, task.callId);
+ insertInvocationInput.setString(2, task.methodId);
+ insertInvocationInput.setBytes(3, task.argsBlob);
+ insertInvocationInput.setLong(4, task.startTime);
+ insertInvocationInput.executeUpdate();
+ break;
+
+ case OUTPUT:
+ updateInvocationOutput.setBytes(1, task.resultBlob);
+ updateInvocationOutput.setLong(2, task.endTime);
+ updateInvocationOutput.setLong(3, task.callId);
+ updateInvocationOutput.executeUpdate();
+ break;
+
+ case ERROR:
+ updateInvocationError.setBytes(1, task.errorBlob);
+ updateInvocationError.setLong(2, task.endTime);
+ updateInvocationError.setLong(3, task.callId);
+ updateInvocationError.executeUpdate();
+ break;
+
+ case BENCHMARK:
+ insertBenchmark.setString(1, task.methodId);
+ insertBenchmark.setLong(2, task.startTime); // duration stored in startTime field
+ insertBenchmark.setLong(3, task.endTime); // timestamp stored in endTime field
+ insertBenchmark.executeUpdate();
+ break;
+
+ case BENCHMARK_RESULT:
+ BenchmarkResult r = task.benchmarkResult;
+ insertBenchmarkResult.setString(1, task.methodId);
+ insertBenchmarkResult.setLong(2, r.getMean());
+ insertBenchmarkResult.setLong(3, r.getStdDev());
+ insertBenchmarkResult.setLong(4, r.getMin());
+ insertBenchmarkResult.setLong(5, r.getMax());
+ insertBenchmarkResult.setLong(6, r.getP50());
+ insertBenchmarkResult.setLong(7, r.getP90());
+ insertBenchmarkResult.setLong(8, r.getP99());
+ insertBenchmarkResult.setInt(9, r.getIterationCount());
+ insertBenchmarkResult.setDouble(10, r.getCoefficientOfVariation());
+ insertBenchmarkResult.executeUpdate();
+ break;
+ }
+ }
+
+ /**
+ * Flush all pending writes synchronously.
+ */
+ public void flush() {
+ // Wait for queue to drain
+ while (!writeQueue.isEmpty()) {
+ try {
+ Thread.sleep(10);
+ } catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ break;
+ }
+ }
+ }
+
+ /**
+ * Close the writer and database connection.
+ */
+ public void close() {
+ running.set(false);
+
+ try {
+ writerThread.join(5000); // Wait up to 5 seconds
+ } catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ }
+
+ try {
+ if (insertInvocationInput != null) insertInvocationInput.close();
+ if (updateInvocationOutput != null) updateInvocationOutput.close();
+ if (updateInvocationError != null) updateInvocationError.close();
+ if (insertBenchmark != null) insertBenchmark.close();
+ if (insertBenchmarkResult != null) insertBenchmarkResult.close();
+ if (connection != null) connection.close();
+ } catch (SQLException e) {
+ System.err.println("Error closing ResultWriter: " + e.getMessage());
+ }
+ }
+
+ /**
+ * Get the database path.
+ */
+ public Path getDbPath() {
+ return dbPath;
+ }
+
+ // Internal task class for queue
+ private enum WriteType {
+ INPUT, OUTPUT, ERROR, BENCHMARK, BENCHMARK_RESULT
+ }
+
+ private static class WriteTask {
+ final WriteType type;
+ final long callId;
+ final String methodId;
+ final byte[] argsBlob;
+ final byte[] resultBlob;
+ final byte[] errorBlob;
+ final long startTime;
+ final long endTime;
+ final BenchmarkResult benchmarkResult;
+
+ WriteTask(WriteType type, long callId, String methodId, byte[] argsBlob,
+ byte[] resultBlob, byte[] errorBlob, long startTime, long endTime,
+ BenchmarkResult benchmarkResult) {
+ this.type = type;
+ this.callId = callId;
+ this.methodId = methodId;
+ this.argsBlob = argsBlob;
+ this.resultBlob = resultBlob;
+ this.errorBlob = errorBlob;
+ this.startTime = startTime;
+ this.endTime = endTime;
+ this.benchmarkResult = benchmarkResult;
+ }
+ }
+}
diff --git a/codeflash-java-runtime/src/main/java/com/codeflash/Serializer.java b/codeflash-java-runtime/src/main/java/com/codeflash/Serializer.java
new file mode 100644
index 000000000..80d400935
--- /dev/null
+++ b/codeflash-java-runtime/src/main/java/com/codeflash/Serializer.java
@@ -0,0 +1,798 @@
+package com.codeflash;
+
+import com.esotericsoftware.kryo.Kryo;
+import com.esotericsoftware.kryo.io.Input;
+import com.esotericsoftware.kryo.io.Output;
+import com.esotericsoftware.kryo.util.DefaultInstantiatorStrategy;
+import org.objenesis.strategy.StdInstantiatorStrategy;
+
+import java.io.ByteArrayOutputStream;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+import java.net.ServerSocket;
+import java.net.Socket;
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.sql.Statement;
+import java.util.*;
+import java.util.AbstractMap;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * Binary serializer using Kryo with graceful handling of unserializable objects.
+ *
+ * This class provides:
+ * 1. Attempts direct Kryo serialization first
+ * 2. On failure, recursively processes containers (Map, Collection, Array)
+ * 3. Replaces truly unserializable objects with Placeholder
+ *
+ * Thread-safe via ThreadLocal Kryo instances.
+ */
+public final class Serializer {
+
+ private static final int MAX_DEPTH = 10;
+ private static final int MAX_COLLECTION_SIZE = 1000;
+ private static final int BUFFER_SIZE = 4096;
+
+ // Thread-local Kryo instances (Kryo is not thread-safe)
+ private static final ThreadLocal KRYO = ThreadLocal.withInitial(() -> {
+ Kryo kryo = new Kryo();
+ kryo.setRegistrationRequired(false);
+ kryo.setReferences(true);
+ kryo.setInstantiatorStrategy(new DefaultInstantiatorStrategy(
+ new StdInstantiatorStrategy()));
+
+ // Register common types for efficiency
+ kryo.register(ArrayList.class);
+ kryo.register(LinkedList.class);
+ kryo.register(HashMap.class);
+ kryo.register(LinkedHashMap.class);
+ kryo.register(HashSet.class);
+ kryo.register(LinkedHashSet.class);
+ kryo.register(TreeMap.class);
+ kryo.register(TreeSet.class);
+ kryo.register(KryoPlaceholder.class);
+ kryo.register(java.util.UUID.class);
+ kryo.register(java.math.BigDecimal.class);
+ kryo.register(java.math.BigInteger.class);
+
+ return kryo;
+ });
+
+ // Cache of known unserializable types
+ private static final Set> UNSERIALIZABLE_TYPES = ConcurrentHashMap.newKeySet();
+
+ static {
+ // Pre-populate with known unserializable types
+ UNSERIALIZABLE_TYPES.add(Socket.class);
+ UNSERIALIZABLE_TYPES.add(ServerSocket.class);
+ UNSERIALIZABLE_TYPES.add(InputStream.class);
+ UNSERIALIZABLE_TYPES.add(OutputStream.class);
+ UNSERIALIZABLE_TYPES.add(Connection.class);
+ UNSERIALIZABLE_TYPES.add(Statement.class);
+ UNSERIALIZABLE_TYPES.add(ResultSet.class);
+ UNSERIALIZABLE_TYPES.add(Thread.class);
+ UNSERIALIZABLE_TYPES.add(ThreadGroup.class);
+ UNSERIALIZABLE_TYPES.add(ClassLoader.class);
+ }
+
+ private Serializer() {
+ // Utility class
+ }
+
+ /**
+ * Serialize an object to bytes with graceful handling of unserializable parts.
+ *
+ * @param obj The object to serialize
+ * @return Serialized bytes (may contain KryoPlaceholder for unserializable parts)
+ */
+ public static byte[] serialize(Object obj) {
+ Object processed = recursiveProcess(obj, new IdentityHashMap<>(), 0, "");
+ return directSerialize(processed);
+ }
+
+ /**
+ * Deserialize bytes back to an object.
+ * The returned object may contain KryoPlaceholder instances for parts
+ * that could not be serialized originally.
+ *
+ * @param data Serialized bytes
+ * @return Deserialized object
+ */
+ public static Object deserialize(byte[] data) {
+ if (data == null || data.length == 0) {
+ return null;
+ }
+ Kryo kryo = KRYO.get();
+ try (Input input = new Input(data)) {
+ return kryo.readClassAndObject(input);
+ }
+ }
+
+ /**
+ * Serialize an exception with its metadata.
+ *
+ * @param error The exception to serialize
+ * @return Serialized bytes containing exception information
+ */
+ public static byte[] serializeException(Throwable error) {
+ Map exceptionData = new LinkedHashMap<>();
+ exceptionData.put("__exception__", true);
+ exceptionData.put("type", error.getClass().getName());
+ exceptionData.put("message", error.getMessage());
+
+ // Capture stack trace as strings
+ List stackTrace = new ArrayList<>();
+ for (StackTraceElement element : error.getStackTrace()) {
+ stackTrace.add(element.toString());
+ }
+ exceptionData.put("stackTrace", stackTrace);
+
+ // Capture cause if present
+ if (error.getCause() != null) {
+ exceptionData.put("causeType", error.getCause().getClass().getName());
+ exceptionData.put("causeMessage", error.getCause().getMessage());
+ }
+
+ return serialize(exceptionData);
+ }
+
+ /**
+ * Direct serialization without recursive processing.
+ */
+ private static byte[] directSerialize(Object obj) {
+ Kryo kryo = KRYO.get();
+ ByteArrayOutputStream baos = new ByteArrayOutputStream(BUFFER_SIZE);
+ try (Output output = new Output(baos)) {
+ kryo.writeClassAndObject(output, obj);
+ }
+ return baos.toByteArray();
+ }
+
+ /**
+ * Try to serialize directly; returns null on failure.
+ */
+ private static byte[] tryDirectSerialize(Object obj) {
+ try {
+ return directSerialize(obj);
+ } catch (Exception e) {
+ return null;
+ }
+ }
+
+ /**
+ * Recursively process an object, replacing unserializable parts with placeholders.
+ */
+ private static Object recursiveProcess(Object obj, IdentityHashMap seen,
+ int depth, String path) {
+ // Handle null
+ if (obj == null) {
+ return null;
+ }
+
+ Class clazz = obj.getClass();
+
+ // Check if known unserializable type
+ if (isKnownUnserializable(clazz)) {
+ return KryoPlaceholder.create(obj, "Known unserializable type: " + clazz.getName(), path);
+ }
+
+ // Check max depth
+ if (depth > MAX_DEPTH) {
+ return KryoPlaceholder.create(obj, "Max recursion depth exceeded", path);
+ }
+
+ // Primitives and common immutable types - return directly (Kryo handles these well)
+ if (isPrimitiveOrWrapper(clazz) || obj instanceof String || obj instanceof Enum) {
+ return obj;
+ }
+
+ // Check for circular reference
+ if (seen.containsKey(obj)) {
+ return KryoPlaceholder.create(obj, "Circular reference detected", path);
+ }
+ seen.put(obj, Boolean.TRUE);
+
+ try {
+ // Handle containers: for simple containers (only primitives, wrappers, strings, enums),
+ // try direct serialization to preserve full size. For containers with complex/potentially
+ // unserializable types, recursively process to catch and replace unserializable objects.
+ if (obj instanceof Map) {
+ Map map = (Map) obj;
+ if (containsOnlySimpleTypes(map)) {
+ // Simple map - try direct serialization to preserve full size
+ byte[] serialized = tryDirectSerialize(obj);
+ if (serialized != null) {
+ try {
+ deserialize(serialized);
+ return obj; // Success - return original
+ } catch (Exception e) {
+ // Fall through to recursive handling
+ }
+ }
+ }
+ return handleMap(map, seen, depth, path);
+ }
+ if (obj instanceof Collection) {
+ Collection collection = (Collection) obj;
+ if (containsOnlySimpleTypes(collection)) {
+ // Simple collection - try direct serialization to preserve full size
+ byte[] serialized = tryDirectSerialize(obj);
+ if (serialized != null) {
+ try {
+ deserialize(serialized);
+ return obj; // Success - return original
+ } catch (Exception e) {
+ // Fall through to recursive handling
+ }
+ }
+ }
+ return handleCollection(collection, seen, depth, path);
+ }
+ if (clazz.isArray()) {
+ return handleArray(obj, seen, depth, path);
+ }
+
+ // For non-container objects, try direct serialization first
+ byte[] serialized = tryDirectSerialize(obj);
+ if (serialized != null) {
+ // Verify it can be deserialized
+ try {
+ deserialize(serialized);
+ return obj; // Success - return original
+ } catch (Exception e) {
+ // Fall through to recursive handling
+ }
+ }
+
+ // Handle objects with fields
+ return handleObject(obj, seen, depth, path);
+
+ } finally {
+ seen.remove(obj);
+ }
+ }
+
+ /**
+ * Check if a class is known to be unserializable.
+ */
+ private static boolean isKnownUnserializable(Class clazz) {
+ if (UNSERIALIZABLE_TYPES.contains(clazz)) {
+ return true;
+ }
+ // Check superclasses and interfaces
+ for (Class unserializable : UNSERIALIZABLE_TYPES) {
+ if (unserializable.isAssignableFrom(clazz)) {
+ UNSERIALIZABLE_TYPES.add(clazz); // Cache for future
+ return true;
+ }
+ }
+ return false;
+ }
+
+ /**
+ * Check if a class is a primitive or wrapper type.
+ */
+ private static boolean isPrimitiveOrWrapper(Class clazz) {
+ return clazz.isPrimitive() ||
+ clazz == Boolean.class ||
+ clazz == Byte.class ||
+ clazz == Character.class ||
+ clazz == Short.class ||
+ clazz == Integer.class ||
+ clazz == Long.class ||
+ clazz == Float.class ||
+ clazz == Double.class;
+ }
+
+ /**
+ * Check if an object is a "simple" type that Kryo can serialize directly without issues.
+ * Simple types include primitives, wrappers, strings, enums, and common date/time types.
+ */
+ private static boolean isSimpleType(Object obj) {
+ if (obj == null) {
+ return true;
+ }
+ Class clazz = obj.getClass();
+ return isPrimitiveOrWrapper(clazz) ||
+ obj instanceof String ||
+ obj instanceof Enum ||
+ obj instanceof java.util.UUID ||
+ obj instanceof java.math.BigDecimal ||
+ obj instanceof java.math.BigInteger ||
+ obj instanceof java.util.Date ||
+ obj instanceof java.time.temporal.Temporal;
+ }
+
+ /**
+ * Check if a collection contains only simple types that don't need recursive processing
+ * to check for unserializable nested objects.
+ */
+ private static boolean containsOnlySimpleTypes(Collection collection) {
+ for (Object item : collection) {
+ if (!isSimpleType(item)) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ /**
+ * Check if a map contains only simple types (both keys and values).
+ */
+ private static boolean containsOnlySimpleTypes(Map map) {
+ for (Map.Entry entry : map.entrySet()) {
+ if (!isSimpleType(entry.getKey()) || !isSimpleType(entry.getValue())) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ /**
+ * Handle Map serialization with recursive processing of values.
+ * Preserves map type (TreeMap, LinkedHashMap, etc.) where possible.
+ */
+ private static Object handleMap(Map map, IdentityHashMap seen,
+ int depth, String path) {
+ List> processed = new ArrayList<>();
+ int count = 0;
+
+ for (Map.Entry entry : map.entrySet()) {
+ if (count >= MAX_COLLECTION_SIZE) {
+ processed.add(new AbstractMap.SimpleEntry<>("__truncated__",
+ map.size() - count + " more entries"));
+ break;
+ }
+
+ Object key = entry.getKey();
+ Object value = entry.getValue();
+
+ // Process key
+ String keyStr = key != null ? key.toString() : "null";
+ String keyPath = path.isEmpty() ? "[" + keyStr + "]" : path + "[" + keyStr + "]";
+
+ Object processedKey;
+ try {
+ processedKey = recursiveProcess(key, seen, depth + 1, keyPath + ".key");
+ } catch (Exception e) {
+ processedKey = KryoPlaceholder.create(key, e.getMessage(), keyPath + ".key");
+ }
+
+ // Process value
+ Object processedValue;
+ try {
+ processedValue = recursiveProcess(value, seen, depth + 1, keyPath);
+ } catch (Exception e) {
+ processedValue = KryoPlaceholder.create(value, e.getMessage(), keyPath);
+ }
+
+ processed.add(new AbstractMap.SimpleEntry<>(processedKey, processedValue));
+ count++;
+ }
+
+ return createMapOfSameType(map, processed);
+ }
+
+ /**
+ * Create a map of the same type as the original, populated with processed entries.
+ */
+ @SuppressWarnings("unchecked")
+ private static Map createMapOfSameType(Map original,
+ List> entries) {
+ try {
+ // Handle specific map types
+ if (original instanceof TreeMap) {
+ // TreeMap - try to preserve with serializable comparator
+ try {
+ TreeMap result = new TreeMap<>(new SerializableComparator());
+ for (Map.Entry entry : entries) {
+ result.put(entry.getKey(), entry.getValue());
+ }
+ return result;
+ } catch (Exception e) {
+ // Fall back to LinkedHashMap if keys aren't comparable
+ LinkedHashMap result = new LinkedHashMap<>();
+ for (Map.Entry entry : entries) {
+ result.put(entry.getKey(), entry.getValue());
+ }
+ return result;
+ }
+ }
+
+ if (original instanceof LinkedHashMap) {
+ LinkedHashMap result = new LinkedHashMap<>();
+ for (Map.Entry entry : entries) {
+ result.put(entry.getKey(), entry.getValue());
+ }
+ return result;
+ }
+
+ if (original instanceof HashMap) {
+ HashMap result = new HashMap<>();
+ for (Map.Entry entry : entries) {
+ result.put(entry.getKey(), entry.getValue());
+ }
+ return result;
+ }
+
+ // Try to instantiate the same type
+ try {
+ Map result = (Map) original.getClass().getDeclaredConstructor().newInstance();
+ for (Map.Entry entry : entries) {
+ result.put(entry.getKey(), entry.getValue());
+ }
+ return result;
+ } catch (Exception e) {
+ // Fallback
+ }
+
+ // Default fallback - LinkedHashMap preserves insertion order
+ LinkedHashMap result = new LinkedHashMap<>();
+ for (Map.Entry entry : entries) {
+ result.put(entry.getKey(), entry.getValue());
+ }
+ return result;
+
+ } catch (Exception e) {
+ // Final fallback
+ LinkedHashMap result = new LinkedHashMap<>();
+ for (Map.Entry entry : entries) {
+ result.put(entry.getKey(), entry.getValue());
+ }
+ return result;
+ }
+ }
+
+ /**
+ * Serializable comparator for TreeSet/TreeMap that handles mixed types.
+ */
+ private static class SerializableComparator implements java.util.Comparator