result = new LinkedHashMap<>();
+ result.put("__type__", obj.getClass().getName());
+
+ Class currentClass = obj.getClass();
+ 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 value = field.get(obj);
+ String fieldPath = path.isEmpty() ? field.getName() : path + "." + field.getName();
+
+ Object processedValue = recursiveProcess(value, seen, depth + 1, fieldPath);
+ result.put(field.getName(), processedValue);
+ } catch (Exception e) {
+ result.put(field.getName(),
+ KryoPlaceholder.create(null, "Field access error: " + e.getMessage(),
+ path + "." + field.getName()));
+ }
+ }
+ currentClass = currentClass.getSuperclass();
+ }
+
+ return result;
+ }
+
+ /**
+ * Try to create an instance of a class.
+ */
+ private static Object createInstance(Class clazz) {
+ try {
+ return clazz.getDeclaredConstructor().newInstance();
+ } catch (Exception e) {
+ // Try Objenesis via Kryo's instantiator
+ try {
+ Kryo kryo = KRYO.get();
+ return kryo.newInstance(clazz);
+ } catch (Exception e2) {
+ return null;
+ }
+ }
+ }
+
+ /**
+ * Add a type to the known unserializable types cache.
+ */
+ public static void registerUnserializableType(Class clazz) {
+ UNSERIALIZABLE_TYPES.add(clazz);
+ }
+
+ /**
+ * Reset the unserializable types cache to default state.
+ * Clears any dynamically discovered types but keeps the built-in defaults.
+ */
+ public static void clearUnserializableTypesCache() {
+ UNSERIALIZABLE_TYPES.clear();
+ // Re-add default 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);
+ }
+}
diff --git a/codeflash-java-runtime/src/main/java/com/codeflash/profiler/LineProfilingClassVisitor.java b/codeflash-java-runtime/src/main/java/com/codeflash/profiler/LineProfilingClassVisitor.java
new file mode 100644
index 000000000..a2473ed97
--- /dev/null
+++ b/codeflash-java-runtime/src/main/java/com/codeflash/profiler/LineProfilingClassVisitor.java
@@ -0,0 +1,41 @@
+package com.codeflash.profiler;
+
+import org.objectweb.asm.ClassVisitor;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+
+/**
+ * ASM ClassVisitor that filters methods and wraps target methods with
+ * {@link LineProfilingMethodVisitor} for line-level profiling.
+ */
+public class LineProfilingClassVisitor extends ClassVisitor {
+
+ private final String internalClassName;
+ private final ProfilerConfig config;
+ private String sourceFile;
+
+ public LineProfilingClassVisitor(ClassVisitor classVisitor, String internalClassName, ProfilerConfig config) {
+ super(Opcodes.ASM9, classVisitor);
+ this.internalClassName = internalClassName;
+ this.config = config;
+ }
+
+ @Override
+ public void visitSource(String source, String debug) {
+ super.visitSource(source, debug);
+ // Resolve the absolute source file path from the config
+ this.sourceFile = config.resolveSourceFile(internalClassName);
+ }
+
+ @Override
+ public MethodVisitor visitMethod(int access, String name, String descriptor,
+ String signature, String[] exceptions) {
+ MethodVisitor mv = super.visitMethod(access, name, descriptor, signature, exceptions);
+
+ if (config.shouldInstrumentMethod(internalClassName, name)) {
+ return new LineProfilingMethodVisitor(mv, access, name, descriptor,
+ internalClassName, sourceFile);
+ }
+ return mv;
+ }
+}
diff --git a/codeflash-java-runtime/src/main/java/com/codeflash/profiler/LineProfilingMethodVisitor.java b/codeflash-java-runtime/src/main/java/com/codeflash/profiler/LineProfilingMethodVisitor.java
new file mode 100644
index 000000000..c7cd580d2
--- /dev/null
+++ b/codeflash-java-runtime/src/main/java/com/codeflash/profiler/LineProfilingMethodVisitor.java
@@ -0,0 +1,154 @@
+package com.codeflash.profiler;
+
+import org.objectweb.asm.Label;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.Type;
+import org.objectweb.asm.commons.AdviceAdapter;
+
+/**
+ * ASM MethodVisitor that injects line-level profiling probes.
+ *
+ * At each {@code LineNumber} table entry within the target method:
+ *
+ * - Registers the line with {@link ProfilerRegistry} (happens once at class-load time)
+ * - Injects bytecode: {@code LDC globalId; INVOKESTATIC ProfilerData.hit(I)V}
+ *
+ *
+ * At method entry: injects a warmup self-call loop (if warmup is configured) followed by
+ * {@code ProfilerData.enterMethod(entryLineId)}.
+ *
At method exit (every RETURN/ATHROW): injects {@code ProfilerData.exitMethod()}.
+ */
+public class LineProfilingMethodVisitor extends AdviceAdapter {
+
+ private static final String PROFILER_DATA = "com/codeflash/profiler/ProfilerData";
+
+ private final String internalClassName;
+ private final String sourceFile;
+ private final String methodName;
+ private boolean firstLineVisited = false;
+
+ protected LineProfilingMethodVisitor(
+ MethodVisitor mv, int access, String name, String descriptor,
+ String internalClassName, String sourceFile) {
+ super(Opcodes.ASM9, mv, access, name, descriptor);
+ this.internalClassName = internalClassName;
+ this.sourceFile = sourceFile;
+ this.methodName = name;
+ }
+
+ /**
+ * Inject a warmup self-call loop at method entry.
+ *
+ *
Generated bytecode equivalent:
+ *
+ * if (ProfilerData.isWarmupNeeded()) {
+ * ProfilerData.startWarmup();
+ * for (int i = 0; i < ProfilerData.getWarmupThreshold(); i++) {
+ * thisMethod(originalArgs);
+ * }
+ * ProfilerData.finishWarmup();
+ * }
+ *
+ *
+ * Recursive warmup calls re-enter this method but {@code isWarmupNeeded()} returns
+ * {@code false} (guard flag set by {@code startWarmup()}), so they execute the normal
+ * instrumented body. After the loop, {@code finishWarmup()} zeros all counters so the
+ * next real execution records clean data.
+ */
+ @Override
+ protected void onMethodEnter() {
+ Label skipWarmup = new Label();
+
+ // if (!ProfilerData.isWarmupNeeded()) goto skipWarmup
+ mv.visitMethodInsn(INVOKESTATIC, PROFILER_DATA, "isWarmupNeeded", "()Z", false);
+ mv.visitJumpInsn(IFEQ, skipWarmup);
+
+ // ProfilerData.startWarmup()
+ mv.visitMethodInsn(INVOKESTATIC, PROFILER_DATA, "startWarmup", "()V", false);
+
+ // int _warmupIdx = 0
+ int counterLocal = newLocal(Type.INT_TYPE);
+ mv.visitInsn(ICONST_0);
+ mv.visitVarInsn(ISTORE, counterLocal);
+
+ Label loopCheck = new Label();
+ Label loopBody = new Label();
+
+ mv.visitJumpInsn(GOTO, loopCheck);
+
+ // loop body: call self with original arguments
+ mv.visitLabel(loopBody);
+
+ boolean isStatic = (methodAccess & Opcodes.ACC_STATIC) != 0;
+ if (!isStatic) {
+ loadThis();
+ }
+ loadArgs();
+
+ int invokeOp;
+ if (isStatic) {
+ invokeOp = INVOKESTATIC;
+ } else if ((methodAccess & Opcodes.ACC_PRIVATE) != 0) {
+ invokeOp = INVOKESPECIAL;
+ } else {
+ invokeOp = INVOKEVIRTUAL;
+ }
+ mv.visitMethodInsn(invokeOp, internalClassName, methodName, methodDesc, false);
+
+ // Discard return value
+ Type returnType = Type.getReturnType(methodDesc);
+ switch (returnType.getSort()) {
+ case Type.VOID:
+ break;
+ case Type.LONG:
+ case Type.DOUBLE:
+ mv.visitInsn(POP2);
+ break;
+ default:
+ mv.visitInsn(POP);
+ break;
+ }
+
+ // _warmupIdx++
+ mv.visitIincInsn(counterLocal, 1);
+
+ // loop check: _warmupIdx < ProfilerData.getWarmupThreshold()
+ mv.visitLabel(loopCheck);
+ mv.visitVarInsn(ILOAD, counterLocal);
+ mv.visitMethodInsn(INVOKESTATIC, PROFILER_DATA, "getWarmupThreshold", "()I", false);
+ mv.visitJumpInsn(IF_ICMPLT, loopBody);
+
+ // ProfilerData.finishWarmup()
+ mv.visitMethodInsn(INVOKESTATIC, PROFILER_DATA, "finishWarmup", "()V", false);
+
+ mv.visitLabel(skipWarmup);
+ }
+
+ @Override
+ public void visitLineNumber(int line, Label start) {
+ super.visitLineNumber(line, start);
+
+ // Register this line and get its global ID (happens once at class-load time)
+ String dotClassName = internalClassName.replace('/', '.');
+ int globalId = ProfilerRegistry.register(sourceFile, dotClassName, methodName, line);
+
+ if (!firstLineVisited) {
+ firstLineVisited = true;
+ // Inject enterMethod call at the first line of the method
+ mv.visitLdcInsn(globalId);
+ mv.visitMethodInsn(INVOKESTATIC, PROFILER_DATA, "enterMethod", "(I)V", false);
+ }
+
+ // Inject: ProfilerData.hit(globalId)
+ mv.visitLdcInsn(globalId);
+ mv.visitMethodInsn(INVOKESTATIC, PROFILER_DATA, "hit", "(I)V", false);
+ }
+
+ @Override
+ protected void onMethodExit(int opcode) {
+ // Before every RETURN or ATHROW, flush timing for the last line
+ // This fixes the "last line always shows 0ms" bug
+ mv.visitMethodInsn(INVOKESTATIC, PROFILER_DATA, "exitMethod", "()V", false);
+ }
+}
diff --git a/codeflash-java-runtime/src/main/java/com/codeflash/profiler/LineProfilingTransformer.java b/codeflash-java-runtime/src/main/java/com/codeflash/profiler/LineProfilingTransformer.java
new file mode 100644
index 000000000..39fbe9d97
--- /dev/null
+++ b/codeflash-java-runtime/src/main/java/com/codeflash/profiler/LineProfilingTransformer.java
@@ -0,0 +1,46 @@
+package com.codeflash.profiler;
+
+import org.objectweb.asm.ClassReader;
+import org.objectweb.asm.ClassWriter;
+
+import java.lang.instrument.ClassFileTransformer;
+import java.security.ProtectionDomain;
+
+/**
+ * {@link ClassFileTransformer} that instruments target classes with line profiling.
+ *
+ *
When a class matches the profiler configuration, it is run through ASM
+ * to inject {@link ProfilerData#hit(int)} calls at each line number.
+ */
+public class LineProfilingTransformer implements ClassFileTransformer {
+
+ private final ProfilerConfig config;
+
+ public LineProfilingTransformer(ProfilerConfig config) {
+ this.config = config;
+ }
+
+ @Override
+ public byte[] transform(ClassLoader loader, String className,
+ Class classBeingRedefined, ProtectionDomain protectionDomain,
+ byte[] classfileBuffer) {
+ if (className == null || !config.shouldInstrumentClass(className)) {
+ return null; // null = don't transform
+ }
+
+ try {
+ return instrumentClass(className, classfileBuffer);
+ } catch (Exception e) {
+ System.err.println("[codeflash-profiler] Failed to instrument " + className + ": " + e.getMessage());
+ return null;
+ }
+ }
+
+ private byte[] instrumentClass(String internalClassName, byte[] bytecode) {
+ ClassReader cr = new ClassReader(bytecode);
+ ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_FRAMES | ClassWriter.COMPUTE_MAXS);
+ LineProfilingClassVisitor cv = new LineProfilingClassVisitor(cw, internalClassName, config);
+ cr.accept(cv, ClassReader.EXPAND_FRAMES);
+ return cw.toByteArray();
+ }
+}
diff --git a/codeflash-java-runtime/src/main/java/com/codeflash/profiler/ProfilerAgent.java b/codeflash-java-runtime/src/main/java/com/codeflash/profiler/ProfilerAgent.java
new file mode 100644
index 000000000..572803f78
--- /dev/null
+++ b/codeflash-java-runtime/src/main/java/com/codeflash/profiler/ProfilerAgent.java
@@ -0,0 +1,53 @@
+package com.codeflash.profiler;
+
+import java.lang.instrument.Instrumentation;
+
+/**
+ * Java agent entry point for the CodeFlash line profiler.
+ *
+ *
Loaded via {@code -javaagent:codeflash-profiler-agent.jar=config=/path/to/config.json}.
+ *
+ *
The agent:
+ *
+ * - Parses the config file specifying which classes/methods to profile
+ * - Registers a {@link LineProfilingTransformer} to instrument target classes at load time
+ * - Registers a shutdown hook to write profiling results to JSON
+ *
+ */
+public class ProfilerAgent {
+
+ /**
+ * Called by the JVM before {@code main()} when the agent is loaded.
+ *
+ * @param agentArgs comma-separated key=value pairs (e.g., {@code config=/path/to/config.json})
+ * @param inst the JVM instrumentation interface
+ */
+ public static void premain(String agentArgs, Instrumentation inst) {
+ ProfilerConfig config = ProfilerConfig.parse(agentArgs);
+
+ if (config.getTargetClasses().isEmpty()) {
+ System.err.println("[codeflash-profiler] No target classes configured, profiler inactive");
+ return;
+ }
+
+ // Pre-allocate registry with estimated capacity
+ ProfilerRegistry.initialize(config.getExpectedLineCount());
+
+ // Configure warmup phase
+ ProfilerData.setWarmupThreshold(config.getWarmupIterations());
+
+ // Register the bytecode transformer
+ inst.addTransformer(new LineProfilingTransformer(config), true);
+
+ // Register shutdown hook to write results on JVM exit
+ String outputFile = config.getOutputFile();
+ Runtime.getRuntime().addShutdownHook(new Thread(() -> {
+ ProfilerReporter.writeResults(outputFile, config);
+ }, "codeflash-profiler-shutdown"));
+
+ int warmup = config.getWarmupIterations();
+ String warmupMsg = warmup > 0 ? ", warmup=" + warmup + " calls" : "";
+ System.err.println("[codeflash-profiler] Agent loaded, profiling "
+ + config.getTargetClasses().size() + " class(es)" + warmupMsg);
+ }
+}
diff --git a/codeflash-java-runtime/src/main/java/com/codeflash/profiler/ProfilerConfig.java b/codeflash-java-runtime/src/main/java/com/codeflash/profiler/ProfilerConfig.java
new file mode 100644
index 000000000..6846b7945
--- /dev/null
+++ b/codeflash-java-runtime/src/main/java/com/codeflash/profiler/ProfilerConfig.java
@@ -0,0 +1,424 @@
+package com.codeflash.profiler;
+
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * Configuration for the profiler agent, parsed from a JSON file.
+ *
+ * The JSON is generated by Python ({@code JavaLineProfiler.generate_agent_config()}).
+ * Uses a hand-rolled JSON parser to avoid external dependencies (keeps the agent JAR small).
+ */
+public final class ProfilerConfig {
+
+ private String outputFile = "";
+ private int warmupIterations = 10;
+ private final Map> targets = new HashMap<>();
+ private final Map lineContents = new HashMap<>();
+ private final Set targetClassNames = new HashSet<>();
+
+ public static class MethodTarget {
+ public final String name;
+ public final int startLine;
+ public final int endLine;
+ public final String sourceFile;
+
+ public MethodTarget(String name, int startLine, int endLine, String sourceFile) {
+ this.name = name;
+ this.startLine = startLine;
+ this.endLine = endLine;
+ this.sourceFile = sourceFile;
+ }
+ }
+
+ /**
+ * Parse agent arguments and load the config file.
+ *
+ * Expected format: {@code config=/path/to/config.json}
+ */
+ public static ProfilerConfig parse(String agentArgs) {
+ ProfilerConfig config = new ProfilerConfig();
+ if (agentArgs == null || agentArgs.isEmpty()) {
+ return config;
+ }
+
+ String configPath = null;
+ for (String part : agentArgs.split(",")) {
+ String trimmed = part.trim();
+ if (trimmed.startsWith("config=")) {
+ configPath = trimmed.substring("config=".length());
+ }
+ }
+
+ if (configPath == null) {
+ System.err.println("[codeflash-profiler] No config= in agent args: " + agentArgs);
+ return config;
+ }
+
+ try {
+ String json = new String(Files.readAllBytes(Paths.get(configPath)), StandardCharsets.UTF_8);
+ config.parseJson(json);
+ } catch (IOException e) {
+ System.err.println("[codeflash-profiler] Failed to read config: " + e.getMessage());
+ }
+
+ return config;
+ }
+
+ public String getOutputFile() {
+ return outputFile;
+ }
+
+ public int getWarmupIterations() {
+ return warmupIterations;
+ }
+
+ public Set getTargetClasses() {
+ return Collections.unmodifiableSet(targetClassNames);
+ }
+
+ public List getMethodsForClass(String internalClassName) {
+ return targets.getOrDefault(internalClassName, Collections.emptyList());
+ }
+
+ public Map getLineContents() {
+ return Collections.unmodifiableMap(lineContents);
+ }
+
+ public int getExpectedLineCount() {
+ int count = 0;
+ for (List methods : targets.values()) {
+ for (MethodTarget m : methods) {
+ count += Math.max(m.endLine - m.startLine + 1, 1);
+ }
+ }
+ return Math.max(count, 256);
+ }
+
+ /**
+ * Check if a class should be instrumented. Uses JVM internal names (slash-separated).
+ */
+ public boolean shouldInstrumentClass(String internalClassName) {
+ return targetClassNames.contains(internalClassName);
+ }
+
+ /**
+ * Check if a specific method in a class should be instrumented.
+ */
+ public boolean shouldInstrumentMethod(String internalClassName, String methodName) {
+ List methods = targets.get(internalClassName);
+ if (methods == null) return false;
+ for (MethodTarget m : methods) {
+ if (m.name.equals(methodName)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ /**
+ * Resolve the absolute source file path for a given class and its source file attribute.
+ */
+ public String resolveSourceFile(String internalClassName) {
+ List methods = targets.get(internalClassName);
+ if (methods != null && !methods.isEmpty()) {
+ return methods.get(0).sourceFile;
+ }
+ return internalClassName.replace('/', '.') + ".java";
+ }
+
+ // ---- Minimal JSON parser ----
+
+ private void parseJson(String json) {
+ json = json.trim();
+ if (!json.startsWith("{") || !json.endsWith("}")) return;
+
+ int[] pos = {1}; // mutable position cursor
+ skipWhitespace(json, pos);
+
+ while (pos[0] < json.length() - 1) {
+ String key = readString(json, pos);
+ skipWhitespace(json, pos);
+ expect(json, pos, ':');
+ skipWhitespace(json, pos);
+
+ switch (key) {
+ case "outputFile":
+ this.outputFile = readString(json, pos);
+ break;
+ case "warmupIterations":
+ this.warmupIterations = readInt(json, pos);
+ break;
+ case "targets":
+ parseTargets(json, pos);
+ break;
+ case "lineContents":
+ parseLineContents(json, pos);
+ break;
+ default:
+ skipValue(json, pos);
+ break;
+ }
+
+ skipWhitespace(json, pos);
+ if (pos[0] < json.length() && json.charAt(pos[0]) == ',') {
+ pos[0]++;
+ skipWhitespace(json, pos);
+ }
+ }
+ }
+
+ private void parseTargets(String json, int[] pos) {
+ expect(json, pos, '[');
+ skipWhitespace(json, pos);
+
+ while (pos[0] < json.length() && json.charAt(pos[0]) != ']') {
+ parseTargetObject(json, pos);
+ skipWhitespace(json, pos);
+ if (pos[0] < json.length() && json.charAt(pos[0]) == ',') {
+ pos[0]++;
+ skipWhitespace(json, pos);
+ }
+ }
+ pos[0]++; // skip ']'
+ }
+
+ private void parseTargetObject(String json, int[] pos) {
+ expect(json, pos, '{');
+ skipWhitespace(json, pos);
+
+ String className = "";
+ List methods = new ArrayList<>();
+
+ while (pos[0] < json.length() && json.charAt(pos[0]) != '}') {
+ String key = readString(json, pos);
+ skipWhitespace(json, pos);
+ expect(json, pos, ':');
+ skipWhitespace(json, pos);
+
+ switch (key) {
+ case "className":
+ className = readString(json, pos);
+ break;
+ case "methods":
+ methods = parseMethodsArray(json, pos);
+ break;
+ default:
+ skipValue(json, pos);
+ break;
+ }
+
+ skipWhitespace(json, pos);
+ if (pos[0] < json.length() && json.charAt(pos[0]) == ',') {
+ pos[0]++;
+ skipWhitespace(json, pos);
+ }
+ }
+ pos[0]++; // skip '}'
+
+ if (!className.isEmpty()) {
+ targets.put(className, methods);
+ targetClassNames.add(className);
+ }
+ }
+
+ private List parseMethodsArray(String json, int[] pos) {
+ List methods = new ArrayList<>();
+ expect(json, pos, '[');
+ skipWhitespace(json, pos);
+
+ while (pos[0] < json.length() && json.charAt(pos[0]) != ']') {
+ methods.add(parseMethodTarget(json, pos));
+ skipWhitespace(json, pos);
+ if (pos[0] < json.length() && json.charAt(pos[0]) == ',') {
+ pos[0]++;
+ skipWhitespace(json, pos);
+ }
+ }
+ pos[0]++; // skip ']'
+ return methods;
+ }
+
+ private MethodTarget parseMethodTarget(String json, int[] pos) {
+ expect(json, pos, '{');
+ skipWhitespace(json, pos);
+
+ String name = "";
+ int startLine = 0;
+ int endLine = 0;
+ String sourceFile = "";
+
+ while (pos[0] < json.length() && json.charAt(pos[0]) != '}') {
+ String key = readString(json, pos);
+ skipWhitespace(json, pos);
+ expect(json, pos, ':');
+ skipWhitespace(json, pos);
+
+ switch (key) {
+ case "name":
+ name = readString(json, pos);
+ break;
+ case "startLine":
+ startLine = readInt(json, pos);
+ break;
+ case "endLine":
+ endLine = readInt(json, pos);
+ break;
+ case "sourceFile":
+ sourceFile = readString(json, pos);
+ break;
+ default:
+ skipValue(json, pos);
+ break;
+ }
+
+ skipWhitespace(json, pos);
+ if (pos[0] < json.length() && json.charAt(pos[0]) == ',') {
+ pos[0]++;
+ skipWhitespace(json, pos);
+ }
+ }
+ pos[0]++; // skip '}'
+
+ return new MethodTarget(name, startLine, endLine, sourceFile);
+ }
+
+ private void parseLineContents(String json, int[] pos) {
+ expect(json, pos, '{');
+ skipWhitespace(json, pos);
+
+ while (pos[0] < json.length() && json.charAt(pos[0]) != '}') {
+ String key = readString(json, pos);
+ skipWhitespace(json, pos);
+ expect(json, pos, ':');
+ skipWhitespace(json, pos);
+ String value = readString(json, pos);
+ lineContents.put(key, value);
+
+ skipWhitespace(json, pos);
+ if (pos[0] < json.length() && json.charAt(pos[0]) == ',') {
+ pos[0]++;
+ skipWhitespace(json, pos);
+ }
+ }
+ pos[0]++; // skip '}'
+ }
+
+ private static String readString(String json, int[] pos) {
+ if (pos[0] >= json.length() || json.charAt(pos[0]) != '"') return "";
+ pos[0]++; // skip opening quote
+
+ StringBuilder sb = new StringBuilder();
+ while (pos[0] < json.length()) {
+ char c = json.charAt(pos[0]);
+ if (c == '\\' && pos[0] + 1 < json.length()) {
+ pos[0]++;
+ char escaped = json.charAt(pos[0]);
+ switch (escaped) {
+ case '"': sb.append('"'); break;
+ case '\\': sb.append('\\'); break;
+ case '/': sb.append('/'); break;
+ case 'n': sb.append('\n'); break;
+ case 't': sb.append('\t'); break;
+ case 'r': sb.append('\r'); break;
+ default: sb.append('\\').append(escaped); break;
+ }
+ } else if (c == '"') {
+ pos[0]++; // skip closing quote
+ return sb.toString();
+ } else {
+ sb.append(c);
+ }
+ pos[0]++;
+ }
+ return sb.toString();
+ }
+
+ private static int readInt(String json, int[] pos) {
+ int start = pos[0];
+ boolean negative = false;
+ if (pos[0] < json.length() && json.charAt(pos[0]) == '-') {
+ negative = true;
+ pos[0]++;
+ }
+ while (pos[0] < json.length() && Character.isDigit(json.charAt(pos[0]))) {
+ pos[0]++;
+ }
+ String numStr = json.substring(start, pos[0]);
+ try {
+ return Integer.parseInt(numStr);
+ } catch (NumberFormatException e) {
+ return 0;
+ }
+ }
+
+ private static void skipValue(String json, int[] pos) {
+ if (pos[0] >= json.length()) return;
+ char c = json.charAt(pos[0]);
+ if (c == '"') {
+ readString(json, pos);
+ } else if (c == '{') {
+ skipBraced(json, pos, '{', '}');
+ } else if (c == '[') {
+ skipBraced(json, pos, '[', ']');
+ } else if (c == 'n' && json.startsWith("null", pos[0])) {
+ pos[0] += 4;
+ } else if (c == 't' && json.startsWith("true", pos[0])) {
+ pos[0] += 4;
+ } else if (c == 'f' && json.startsWith("false", pos[0])) {
+ pos[0] += 5;
+ } else {
+ // number
+ while (pos[0] < json.length() && "0123456789.eE+-".indexOf(json.charAt(pos[0])) >= 0) {
+ pos[0]++;
+ }
+ }
+ }
+
+ private static void skipBraced(String json, int[] pos, char open, char close) {
+ int depth = 0;
+ boolean inString = false;
+ while (pos[0] < json.length()) {
+ char c = json.charAt(pos[0]);
+ if (inString) {
+ if (c == '\\') {
+ pos[0]++; // skip escaped char
+ } else if (c == '"') {
+ inString = false;
+ }
+ } else {
+ if (c == '"') inString = true;
+ else if (c == open) depth++;
+ else if (c == close) {
+ depth--;
+ if (depth == 0) {
+ pos[0]++;
+ return;
+ }
+ }
+ }
+ pos[0]++;
+ }
+ }
+
+ private static void skipWhitespace(String json, int[] pos) {
+ while (pos[0] < json.length() && Character.isWhitespace(json.charAt(pos[0]))) {
+ pos[0]++;
+ }
+ }
+
+ private static void expect(String json, int[] pos, char expected) {
+ if (pos[0] < json.length() && json.charAt(pos[0]) == expected) {
+ pos[0]++;
+ }
+ }
+}
diff --git a/codeflash-java-runtime/src/main/java/com/codeflash/profiler/ProfilerData.java b/codeflash-java-runtime/src/main/java/com/codeflash/profiler/ProfilerData.java
new file mode 100644
index 000000000..1964d22a2
--- /dev/null
+++ b/codeflash-java-runtime/src/main/java/com/codeflash/profiler/ProfilerData.java
@@ -0,0 +1,274 @@
+package com.codeflash.profiler;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+/**
+ * Zero-allocation, zero-contention per-line profiling data storage.
+ *
+ * Each thread gets its own primitive {@code long[]} arrays for hit counts and self-time.
+ * The hot path ({@link #hit(int)}) performs only an array-index increment and a single
+ * {@link System#nanoTime()} call — no object allocations, no locks, no shared-state contention.
+ * Method entry/exit use a fresh {@code nanoTime()} after bookkeeping to exclude overhead.
+ *
+ *
A per-thread call stack tracks method entry/exit to:
+ *
+ * - Attribute time to the last line of a function (fixes the "last line 0ms" bug)
+ * - Pause parent-line timing during callee execution (fixes cross-function timing)
+ * - Handle recursion correctly (each stack frame is independent)
+ *
+ */
+public final class ProfilerData {
+
+ private static final int INITIAL_CAPACITY = 4096;
+ private static final int MAX_CALL_DEPTH = 256;
+
+ // Thread-local arrays — each thread gets its own, no contention
+ private static final ThreadLocal hitCounts =
+ ThreadLocal.withInitial(() -> registerArray(new long[INITIAL_CAPACITY]));
+ private static final ThreadLocal selfTimeNs =
+ ThreadLocal.withInitial(() -> registerTimeArray(new long[INITIAL_CAPACITY]));
+
+ // Per-thread "last line" tracking for time attribution
+ // Using int[1] and long[1] to avoid boxing
+ private static final ThreadLocal lastLineId =
+ ThreadLocal.withInitial(() -> new int[]{-1});
+ private static final ThreadLocal lastLineTime =
+ ThreadLocal.withInitial(() -> new long[]{0L});
+
+ // Per-thread call stack for method entry/exit
+ private static final ThreadLocal callStackLineIds =
+ ThreadLocal.withInitial(() -> new int[MAX_CALL_DEPTH]);
+ private static final ThreadLocal callStackDepth =
+ ThreadLocal.withInitial(() -> new int[]{0});
+
+ // Global references to all thread-local arrays for harvesting at shutdown
+ private static final List allHitArrays = new CopyOnWriteArrayList<>();
+ private static final List allTimeArrays = new CopyOnWriteArrayList<>();
+
+ // Warmup state: the method visitor injects a self-calling warmup loop,
+ // warmupInProgress guards against recursive re-entry into the warmup block.
+ private static volatile int warmupThreshold = 0;
+ private static volatile boolean warmupComplete = false;
+ private static volatile boolean warmupInProgress = false;
+
+ private ProfilerData() {}
+
+ private static long[] registerArray(long[] arr) {
+ allHitArrays.add(arr);
+ return arr;
+ }
+
+ private static long[] registerTimeArray(long[] arr) {
+ allTimeArrays.add(arr);
+ return arr;
+ }
+
+ /**
+ * Set the number of self-call warmup iterations before measurement begins.
+ * Called once from {@link ProfilerAgent#premain} before any classes are loaded.
+ *
+ * @param threshold number of warmup iterations (0 = no warmup)
+ */
+ public static void setWarmupThreshold(int threshold) {
+ warmupThreshold = threshold;
+ warmupComplete = (threshold <= 0);
+ }
+
+ /**
+ * Check whether warmup is still needed. Called by injected bytecode at target method entry.
+ * Returns {@code true} only on the very first call — subsequent calls (including recursive
+ * warmup calls) return {@code false}.
+ */
+ public static boolean isWarmupNeeded() {
+ return !warmupComplete && !warmupInProgress && warmupThreshold > 0;
+ }
+
+ /**
+ * Enter warmup phase. Sets a guard flag so recursive warmup calls skip the warmup block.
+ */
+ public static void startWarmup() {
+ warmupInProgress = true;
+ }
+
+ /**
+ * Return the configured warmup iteration count.
+ */
+ public static int getWarmupThreshold() {
+ return warmupThreshold;
+ }
+
+ /**
+ * End warmup: zero all profiling counters, mark warmup complete, clear the guard flag.
+ * The next execution of the method body is the clean measurement.
+ */
+ public static void finishWarmup() {
+ resetAll();
+ warmupComplete = true;
+ warmupInProgress = false;
+ System.err.println("[codeflash-profiler] Warmup complete after " + warmupThreshold
+ + " iterations, measurement started");
+ }
+
+ /**
+ * Reset all profiling counters across all threads.
+ * Called once when warmup phase completes to discard warmup data.
+ */
+ private static void resetAll() {
+ for (long[] arr : allHitArrays) {
+ Arrays.fill(arr, 0L);
+ }
+ for (long[] arr : allTimeArrays) {
+ Arrays.fill(arr, 0L);
+ }
+ }
+
+ /**
+ * Record a hit on a profiled line. This is the HOT PATH.
+ *
+ * Called at every instrumented line number. Must not allocate after the initial
+ * thread-local array expansion.
+ *
+ * @param globalId the line's registered ID from {@link ProfilerRegistry}
+ */
+ public static void hit(int globalId) {
+ long now = System.nanoTime();
+
+ long[] hits = hitCounts.get();
+ if (globalId >= hits.length) {
+ hits = ensureCapacity(hitCounts, allHitArrays, globalId);
+ }
+ hits[globalId]++;
+
+ // Attribute elapsed time to the PREVIOUS line
+ int[] lastId = lastLineId.get();
+ long[] lastTime = lastLineTime.get();
+ if (lastId[0] >= 0) {
+ long[] times = selfTimeNs.get();
+ if (lastId[0] >= times.length) {
+ times = ensureCapacity(selfTimeNs, allTimeArrays, lastId[0]);
+ }
+ times[lastId[0]] += now - lastTime[0];
+ }
+
+ lastId[0] = globalId;
+ lastTime[0] = now;
+ }
+
+ /**
+ * Called at method entry to push a call-stack frame.
+ *
+ *
Attributes any pending time to the previous line (the call site), then
+ * saves the caller's line state onto the stack so it can be restored in
+ * {@link #exitMethod()}.
+ *
+ * @param entryLineId the globalId of the first line in the entering method (unused for stack,
+ * but may be used for future total-time tracking)
+ */
+ public static void enterMethod(int entryLineId) {
+ long now = System.nanoTime();
+
+ // Flush pending time to the caller's line (stop its clock ASAP)
+ int[] lastId = lastLineId.get();
+ long[] lastTime = lastLineTime.get();
+ if (lastId[0] >= 0) {
+ long[] times = selfTimeNs.get();
+ if (lastId[0] >= times.length) {
+ times = ensureCapacity(selfTimeNs, allTimeArrays, lastId[0]);
+ }
+ times[lastId[0]] += now - lastTime[0];
+ }
+
+ // Push caller's line ID onto the stack
+ int[] depth = callStackDepth.get();
+ int[] stack = callStackLineIds.get();
+ if (depth[0] < stack.length) {
+ stack[depth[0]] = lastId[0];
+ }
+ depth[0]++;
+
+ // Start fresh for the callee — timestamp taken after all overhead
+ lastId[0] = -1;
+ lastTime[0] = System.nanoTime();
+ }
+
+ /**
+ * Called at method exit (before RETURN or ATHROW) to pop the call stack.
+ *
+ *
Attributes remaining time to the last line of the exiting method (fixes the
+ * "last line always 0ms" bug), then restores the caller's timing state.
+ */
+ public static void exitMethod() {
+ long now = System.nanoTime();
+
+ // Attribute remaining time to the last line of the exiting method (stop its clock ASAP)
+ int[] lastId = lastLineId.get();
+ long[] lastTime = lastLineTime.get();
+ if (lastId[0] >= 0) {
+ long[] times = selfTimeNs.get();
+ if (lastId[0] >= times.length) {
+ times = ensureCapacity(selfTimeNs, allTimeArrays, lastId[0]);
+ }
+ times[lastId[0]] += now - lastTime[0];
+ }
+
+ // Pop the call stack and restore parent's timing state — timestamp taken after all overhead
+ int[] depth = callStackDepth.get();
+ if (depth[0] > 0) {
+ depth[0]--;
+ int[] stack = callStackLineIds.get();
+ int parentLineId = stack[depth[0]];
+
+ lastId[0] = parentLineId;
+ lastTime[0] = System.nanoTime();
+ } else {
+ lastId[0] = -1;
+ lastTime[0] = 0L;
+ }
+ }
+
+ /**
+ * Sum hit counts across all threads. Called once at shutdown for reporting.
+ */
+ public static long[] getGlobalHitCounts() {
+ int maxId = ProfilerRegistry.getMaxId();
+ long[] global = new long[maxId];
+ for (long[] threadHits : allHitArrays) {
+ int limit = Math.min(threadHits.length, maxId);
+ for (int i = 0; i < limit; i++) {
+ global[i] += threadHits[i];
+ }
+ }
+ return global;
+ }
+
+ /**
+ * Sum self-time across all threads. Called once at shutdown for reporting.
+ */
+ public static long[] getGlobalSelfTimeNs() {
+ int maxId = ProfilerRegistry.getMaxId();
+ long[] global = new long[maxId];
+ for (long[] threadTimes : allTimeArrays) {
+ int limit = Math.min(threadTimes.length, maxId);
+ for (int i = 0; i < limit; i++) {
+ global[i] += threadTimes[i];
+ }
+ }
+ return global;
+ }
+
+ private static long[] ensureCapacity(ThreadLocal tl, List registry, int minIndex) {
+ long[] old = tl.get();
+ int newSize = Math.max((minIndex + 1) * 2, INITIAL_CAPACITY);
+ long[] expanded = new long[newSize];
+ System.arraycopy(old, 0, expanded, 0, old.length);
+
+ // Update the registry: remove old, add new
+ registry.remove(old);
+ registry.add(expanded);
+
+ tl.set(expanded);
+ return expanded;
+ }
+}
diff --git a/codeflash-java-runtime/src/main/java/com/codeflash/profiler/ProfilerRegistry.java b/codeflash-java-runtime/src/main/java/com/codeflash/profiler/ProfilerRegistry.java
new file mode 100644
index 000000000..f4e4f3b22
--- /dev/null
+++ b/codeflash-java-runtime/src/main/java/com/codeflash/profiler/ProfilerRegistry.java
@@ -0,0 +1,120 @@
+package com.codeflash.profiler;
+
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * Maps (sourceFile, lineNumber) pairs to compact integer IDs at class-load time.
+ *
+ * Registration happens once per unique line during class transformation (not on the hot path).
+ * The integer IDs are used as direct array indices in {@link ProfilerData} for zero-allocation
+ * hit recording at runtime.
+ */
+public final class ProfilerRegistry {
+
+ private static final AtomicInteger nextId = new AtomicInteger(0);
+ private static final ConcurrentHashMap lineToId = new ConcurrentHashMap<>();
+
+ private static volatile String[] idToFile;
+ private static volatile int[] idToLine;
+ private static volatile String[] idToClassName;
+ private static volatile String[] idToMethodName;
+
+ private static int capacity;
+ private static final Object growLock = new Object();
+
+ private ProfilerRegistry() {}
+
+ /**
+ * Pre-allocate reverse-lookup arrays with the given capacity.
+ * Called once from {@link ProfilerAgent#premain} before any classes are loaded.
+ */
+ public static void initialize(int expectedLines) {
+ capacity = Math.max(expectedLines * 2, 4096);
+ idToFile = new String[capacity];
+ idToLine = new int[capacity];
+ idToClassName = new String[capacity];
+ idToMethodName = new String[capacity];
+ }
+
+ /**
+ * Register a source line and return its global ID.
+ *
+ * Thread-safe. Called during class loading by the ASM visitor. If the same
+ * (className, lineNumber) pair has already been registered, returns the existing ID.
+ *
+ * @param sourceFile absolute path of the source file
+ * @param className dot-separated class name (e.g. "com.example.Calculator")
+ * @param methodName method name
+ * @param lineNumber 1-indexed line number in the source file
+ * @return compact integer ID usable as an array index
+ */
+ public static int register(String sourceFile, String className, String methodName, int lineNumber) {
+ // Pack className hash + lineNumber into a 64-bit key for fast lookup
+ long key = ((long) className.hashCode() << 32) | (lineNumber & 0xFFFFFFFFL);
+ Integer existing = lineToId.get(key);
+ if (existing != null) {
+ return existing;
+ }
+
+ int id = nextId.getAndIncrement();
+ if (id >= capacity) {
+ grow(id + 1);
+ }
+
+ Integer winner = lineToId.putIfAbsent(key, id);
+ if (winner != null) {
+ // Another thread registered first — use its ID
+ return winner;
+ }
+
+ idToFile[id] = sourceFile;
+ idToLine[id] = lineNumber;
+ idToClassName[id] = className;
+ idToMethodName[id] = methodName;
+ return id;
+ }
+
+ private static void grow(int minCapacity) {
+ synchronized (growLock) {
+ if (minCapacity <= capacity) return;
+
+ int newCapacity = Math.max(minCapacity * 2, capacity * 2);
+ String[] newFiles = new String[newCapacity];
+ int[] newLines = new int[newCapacity];
+ String[] newClasses = new String[newCapacity];
+ String[] newMethods = new String[newCapacity];
+
+ System.arraycopy(idToFile, 0, newFiles, 0, capacity);
+ System.arraycopy(idToLine, 0, newLines, 0, capacity);
+ System.arraycopy(idToClassName, 0, newClasses, 0, capacity);
+ System.arraycopy(idToMethodName, 0, newMethods, 0, capacity);
+
+ idToFile = newFiles;
+ idToLine = newLines;
+ idToClassName = newClasses;
+ idToMethodName = newMethods;
+ capacity = newCapacity;
+ }
+ }
+
+ public static int getMaxId() {
+ return nextId.get();
+ }
+
+ public static String getFile(int id) {
+ return idToFile[id];
+ }
+
+ public static int getLine(int id) {
+ return idToLine[id];
+ }
+
+ public static String getClassName(int id) {
+ return idToClassName[id];
+ }
+
+ public static String getMethodName(int id) {
+ return idToMethodName[id];
+ }
+}
diff --git a/codeflash-java-runtime/src/main/java/com/codeflash/profiler/ProfilerReporter.java b/codeflash-java-runtime/src/main/java/com/codeflash/profiler/ProfilerReporter.java
new file mode 100644
index 000000000..71f05c34c
--- /dev/null
+++ b/codeflash-java-runtime/src/main/java/com/codeflash/profiler/ProfilerReporter.java
@@ -0,0 +1,92 @@
+package com.codeflash.profiler;
+
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Map;
+
+/**
+ * Writes profiling results to a JSON file in the same format as the old source-injected profiler.
+ *
+ *
Output format (consumed by {@code JavaLineProfiler.parse_results()} in Python):
+ *
+ * {
+ * "/path/to/File.java:10": {
+ * "hits": 100,
+ * "time": 5000000,
+ * "file": "/path/to/File.java",
+ * "line": 10,
+ * "content": "int x = compute();"
+ * },
+ * ...
+ * }
+ *
+ */
+public final class ProfilerReporter {
+
+ private ProfilerReporter() {}
+
+ /**
+ * Write profiling results to the output file. Called once from a JVM shutdown hook.
+ */
+ public static void writeResults(String outputFile, ProfilerConfig config) {
+ if (outputFile == null || outputFile.isEmpty()) return;
+
+ long[] globalHits = ProfilerData.getGlobalHitCounts();
+ long[] globalTimes = ProfilerData.getGlobalSelfTimeNs();
+ int maxId = ProfilerRegistry.getMaxId();
+ Map lineContents = config.getLineContents();
+
+ StringBuilder json = new StringBuilder(Math.max(maxId * 128, 256));
+ json.append("{\n");
+
+ boolean first = true;
+ for (int id = 0; id < maxId; id++) {
+ long hits = (id < globalHits.length) ? globalHits[id] : 0;
+ long timeNs = (id < globalTimes.length) ? globalTimes[id] : 0;
+ if (hits == 0 && timeNs == 0) continue;
+
+ String file = ProfilerRegistry.getFile(id);
+ int line = ProfilerRegistry.getLine(id);
+ if (file == null) continue;
+
+ String key = file + ":" + line;
+ String content = lineContents.getOrDefault(key, "");
+
+ if (!first) json.append(",\n");
+ first = false;
+
+ json.append(" \"").append(escapeJson(key)).append("\": {\n");
+ json.append(" \"hits\": ").append(hits).append(",\n");
+ json.append(" \"time\": ").append(timeNs).append(",\n");
+ json.append(" \"file\": \"").append(escapeJson(file)).append("\",\n");
+ json.append(" \"line\": ").append(line).append(",\n");
+ json.append(" \"content\": \"").append(escapeJson(content)).append("\"\n");
+ json.append(" }");
+ }
+
+ json.append("\n}");
+
+ try {
+ Path path = Paths.get(outputFile);
+ Path parent = path.getParent();
+ if (parent != null) {
+ Files.createDirectories(parent);
+ }
+ Files.write(path, json.toString().getBytes(StandardCharsets.UTF_8));
+ } catch (IOException e) {
+ System.err.println("[codeflash-profiler] Failed to write results: " + e.getMessage());
+ }
+ }
+
+ private static String escapeJson(String s) {
+ if (s == null) return "";
+ return s.replace("\\", "\\\\")
+ .replace("\"", "\\\"")
+ .replace("\n", "\\n")
+ .replace("\r", "\\r")
+ .replace("\t", "\\t");
+ }
+}
diff --git a/codeflash-java-runtime/src/test/java/com/codeflash/AgentDispatcherTest.java b/codeflash-java-runtime/src/test/java/com/codeflash/AgentDispatcherTest.java
new file mode 100644
index 000000000..e6fb640bc
--- /dev/null
+++ b/codeflash-java-runtime/src/test/java/com/codeflash/AgentDispatcherTest.java
@@ -0,0 +1,38 @@
+package com.codeflash;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import org.junit.jupiter.api.Test;
+
+class AgentDispatcherTest {
+
+ @Test
+ void profilerModeWhenConfigPresent() {
+ assertTrue(AgentDispatcher.isProfilerMode("config=/tmp/config.json"));
+ }
+
+ @Test
+ void profilerModeWithMultipleArgs() {
+ assertTrue(AgentDispatcher.isProfilerMode("output=results,config=/tmp/config.json"));
+ }
+
+ @Test
+ void jacocoModeWhenDestfilePresent() {
+ assertFalse(AgentDispatcher.isProfilerMode("destfile=/tmp/jacoco.exec"));
+ }
+
+ @Test
+ void jacocoModeWhenPathContainsConfigSubstring() {
+ assertFalse(AgentDispatcher.isProfilerMode("destfile=/home/config=/jacoco.exec"));
+ }
+
+ @Test
+ void jacocoModeWhenNullArgs() {
+ assertFalse(AgentDispatcher.isProfilerMode(null));
+ }
+
+ @Test
+ void jacocoModeWhenEmptyArgs() {
+ assertFalse(AgentDispatcher.isProfilerMode(""));
+ }
+}
diff --git a/codeflash-java-runtime/src/test/java/com/codeflash/BenchmarkResultTest.java b/codeflash-java-runtime/src/test/java/com/codeflash/BenchmarkResultTest.java
new file mode 100644
index 000000000..63f840b6b
--- /dev/null
+++ b/codeflash-java-runtime/src/test/java/com/codeflash/BenchmarkResultTest.java
@@ -0,0 +1,126 @@
+package com.codeflash;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+/**
+ * Tests for the BenchmarkResult class.
+ */
+@DisplayName("BenchmarkResult Tests")
+class BenchmarkResultTest {
+
+ @Test
+ @DisplayName("should calculate mean correctly")
+ void testMean() {
+ long[] measurements = {100, 200, 300, 400, 500};
+ BenchmarkResult result = new BenchmarkResult("test", measurements);
+
+ assertEquals(300, result.getMean());
+ }
+
+ @Test
+ @DisplayName("should calculate min and max")
+ void testMinMax() {
+ long[] measurements = {100, 50, 200, 150, 75};
+ BenchmarkResult result = new BenchmarkResult("test", measurements);
+
+ assertEquals(50, result.getMin());
+ assertEquals(200, result.getMax());
+ }
+
+ @Test
+ @DisplayName("should calculate percentiles")
+ void testPercentiles() {
+ long[] measurements = new long[100];
+ for (int i = 0; i < 100; i++) {
+ measurements[i] = i + 1; // 1 to 100
+ }
+ BenchmarkResult result = new BenchmarkResult("test", measurements);
+
+ assertEquals(50, result.getP50());
+ assertEquals(90, result.getP90());
+ assertEquals(99, result.getP99());
+ }
+
+ @Test
+ @DisplayName("should calculate standard deviation")
+ void testStdDev() {
+ // All same values should have 0 std dev
+ long[] sameValues = {100, 100, 100, 100, 100};
+ BenchmarkResult sameResult = new BenchmarkResult("test", sameValues);
+ assertEquals(0, sameResult.getStdDev());
+
+ // Different values should have non-zero std dev
+ long[] differentValues = {100, 200, 300, 400, 500};
+ BenchmarkResult diffResult = new BenchmarkResult("test", differentValues);
+ assertTrue(diffResult.getStdDev() > 0);
+ }
+
+ @Test
+ @DisplayName("should calculate coefficient of variation")
+ void testCoefficientOfVariation() {
+ long[] measurements = {100, 100, 100, 100, 100};
+ BenchmarkResult result = new BenchmarkResult("test", measurements);
+
+ assertEquals(0.0, result.getCoefficientOfVariation(), 0.001);
+ }
+
+ @Test
+ @DisplayName("should detect stable measurements")
+ void testIsStable() {
+ // Low variance - stable
+ long[] stableMeasurements = {100, 101, 99, 100, 102};
+ BenchmarkResult stableResult = new BenchmarkResult("test", stableMeasurements);
+ assertTrue(stableResult.isStable());
+
+ // High variance - unstable
+ long[] unstableMeasurements = {100, 200, 50, 300, 25};
+ BenchmarkResult unstableResult = new BenchmarkResult("test", unstableMeasurements);
+ assertFalse(unstableResult.isStable());
+ }
+
+ @Test
+ @DisplayName("should convert to milliseconds")
+ void testMillisecondConversion() {
+ long[] measurements = {1_000_000, 2_000_000, 3_000_000}; // 1ms, 2ms, 3ms
+ BenchmarkResult result = new BenchmarkResult("test", measurements);
+
+ assertEquals(2.0, result.getMeanMs(), 0.001);
+ }
+
+ @Test
+ @DisplayName("should clone measurements array")
+ void testMeasurementsCloned() {
+ long[] original = {100, 200, 300};
+ BenchmarkResult result = new BenchmarkResult("test", original);
+
+ long[] retrieved = result.getMeasurements();
+ retrieved[0] = 999;
+
+ // Original should not be affected
+ assertEquals(100, result.getMeasurements()[0]);
+ }
+
+ @Test
+ @DisplayName("should return correct iteration count")
+ void testIterationCount() {
+ long[] measurements = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+ BenchmarkResult result = new BenchmarkResult("test", measurements);
+
+ assertEquals(10, result.getIterationCount());
+ }
+
+ @Test
+ @DisplayName("should have meaningful toString")
+ void testToString() {
+ long[] measurements = {1_000_000, 2_000_000};
+ BenchmarkResult result = new BenchmarkResult("Calculator.add", measurements);
+
+ String str = result.toString();
+ assertTrue(str.contains("Calculator.add"));
+ assertTrue(str.contains("mean="));
+ assertTrue(str.contains("ms"));
+ }
+}
diff --git a/codeflash-java-runtime/src/test/java/com/codeflash/BlackholeTest.java b/codeflash-java-runtime/src/test/java/com/codeflash/BlackholeTest.java
new file mode 100644
index 000000000..ec1b45509
--- /dev/null
+++ b/codeflash-java-runtime/src/test/java/com/codeflash/BlackholeTest.java
@@ -0,0 +1,108 @@
+package com.codeflash;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import java.util.Arrays;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+/**
+ * Tests for the Blackhole class.
+ */
+@DisplayName("Blackhole Tests")
+class BlackholeTest {
+
+ @Test
+ @DisplayName("should consume int without throwing")
+ void testConsumeInt() {
+ assertDoesNotThrow(() -> Blackhole.consume(42));
+ }
+
+ @Test
+ @DisplayName("should consume long without throwing")
+ void testConsumeLong() {
+ assertDoesNotThrow(() -> Blackhole.consume(Long.MAX_VALUE));
+ }
+
+ @Test
+ @DisplayName("should consume double without throwing")
+ void testConsumeDouble() {
+ assertDoesNotThrow(() -> Blackhole.consume(3.14159));
+ }
+
+ @Test
+ @DisplayName("should consume float without throwing")
+ void testConsumeFloat() {
+ assertDoesNotThrow(() -> Blackhole.consume(3.14f));
+ }
+
+ @Test
+ @DisplayName("should consume boolean without throwing")
+ void testConsumeBoolean() {
+ assertDoesNotThrow(() -> Blackhole.consume(true));
+ assertDoesNotThrow(() -> Blackhole.consume(false));
+ }
+
+ @Test
+ @DisplayName("should consume byte without throwing")
+ void testConsumeByte() {
+ assertDoesNotThrow(() -> Blackhole.consume((byte) 127));
+ }
+
+ @Test
+ @DisplayName("should consume short without throwing")
+ void testConsumeShort() {
+ assertDoesNotThrow(() -> Blackhole.consume((short) 32000));
+ }
+
+ @Test
+ @DisplayName("should consume char without throwing")
+ void testConsumeChar() {
+ assertDoesNotThrow(() -> Blackhole.consume('x'));
+ }
+
+ @Test
+ @DisplayName("should consume Object without throwing")
+ void testConsumeObject() {
+ assertDoesNotThrow(() -> Blackhole.consume("hello"));
+ assertDoesNotThrow(() -> Blackhole.consume(Arrays.asList(1, 2, 3)));
+ assertDoesNotThrow(() -> Blackhole.consume((Object) null));
+ }
+
+ @Test
+ @DisplayName("should consume int array without throwing")
+ void testConsumeIntArray() {
+ assertDoesNotThrow(() -> Blackhole.consume(new int[]{1, 2, 3}));
+ assertDoesNotThrow(() -> Blackhole.consume((int[]) null));
+ assertDoesNotThrow(() -> Blackhole.consume(new int[]{}));
+ }
+
+ @Test
+ @DisplayName("should consume long array without throwing")
+ void testConsumeLongArray() {
+ assertDoesNotThrow(() -> Blackhole.consume(new long[]{1L, 2L, 3L}));
+ assertDoesNotThrow(() -> Blackhole.consume((long[]) null));
+ }
+
+ @Test
+ @DisplayName("should consume double array without throwing")
+ void testConsumeDoubleArray() {
+ assertDoesNotThrow(() -> Blackhole.consume(new double[]{1.0, 2.0, 3.0}));
+ assertDoesNotThrow(() -> Blackhole.consume((double[]) null));
+ }
+
+ @Test
+ @DisplayName("should prevent dead code elimination in loop")
+ void testPreventDeadCodeInLoop() {
+ // This test verifies that consuming values allows the loop to run
+ // without the JIT potentially eliminating it
+ int sum = 0;
+ for (int i = 0; i < 1000; i++) {
+ sum += i;
+ Blackhole.consume(sum);
+ }
+ // The loop should have run - this is more of a smoke test
+ assertTrue(sum > 0);
+ }
+}
diff --git a/codeflash-java-runtime/src/test/java/com/codeflash/ComparatorCorrectnessTest.java b/codeflash-java-runtime/src/test/java/com/codeflash/ComparatorCorrectnessTest.java
new file mode 100644
index 000000000..39a7b434d
--- /dev/null
+++ b/codeflash-java-runtime/src/test/java/com/codeflash/ComparatorCorrectnessTest.java
@@ -0,0 +1,284 @@
+package com.codeflash;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+import java.nio.file.Path;
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.PreparedStatement;
+import java.sql.Statement;
+import java.util.HashMap;
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+@DisplayName("Comparator Correctness Tests")
+class ComparatorCorrectnessTest {
+
+ @TempDir
+ Path tempDir;
+
+ private Path originalDb;
+ private Path candidateDb;
+
+ @BeforeEach
+ void setUp() {
+ originalDb = tempDir.resolve("original.db");
+ candidateDb = tempDir.resolve("candidate.db");
+ }
+
+ @Test
+ @DisplayName("empty databases → not equivalent (vacuous equivalence guard)")
+ void testEmptyDatabases() throws Exception {
+ createTestDb(originalDb);
+ createTestDb(candidateDb);
+
+ String json = Comparator.compareDatabases(originalDb.toString(), candidateDb.toString());
+ Map result = parseJson(json);
+
+ assertFalse((Boolean) result.get("equivalent"));
+ assertEquals(0, ((Number) result.get("actualComparisons")).intValue());
+ assertEquals(0, ((Number) result.get("totalInvocations")).intValue());
+ }
+
+ @Test
+ @DisplayName("all placeholder skips → not equivalent")
+ void testAllPlaceholderSkips() throws Exception {
+ createTestDb(originalDb);
+ createTestDb(candidateDb);
+
+ byte[] placeholderBytes = Serializer.serialize(
+ KryoPlaceholder.create(new Object(), "unserializable", "root")
+ );
+
+ insertRow(originalDb, "iter_1_0", 1, placeholderBytes);
+ insertRow(candidateDb, "iter_1_1", 1, placeholderBytes);
+
+ String json = Comparator.compareDatabases(originalDb.toString(), candidateDb.toString());
+ Map result = parseJson(json);
+
+ assertFalse((Boolean) result.get("equivalent"));
+ assertEquals(0, ((Number) result.get("actualComparisons")).intValue());
+ assertTrue(((Number) result.get("skippedPlaceholders")).intValue() > 0);
+ }
+
+ @Test
+ @DisplayName("deserialization errors on both sides → skipped, not equivalent")
+ void testDeserializationErrorSkipped() throws Exception {
+ createTestDb(originalDb);
+ createTestDb(candidateDb);
+
+ // Insert corrupted byte data that will fail Kryo deserialization
+ byte[] corruptedBytes = new byte[]{0x01, 0x02, 0x03, (byte) 0xFF, (byte) 0xFE};
+
+ insertRow(originalDb, "iter_1_0", 1, corruptedBytes);
+ insertRow(candidateDb, "iter_1_1", 1, corruptedBytes);
+
+ String json = Comparator.compareDatabases(originalDb.toString(), candidateDb.toString());
+ Map result = parseJson(json);
+
+ assertFalse((Boolean) result.get("equivalent"));
+ assertEquals(0, ((Number) result.get("actualComparisons")).intValue());
+ assertTrue(((Number) result.get("skippedDeserializationErrors")).intValue() > 0);
+ }
+
+ @Test
+ @DisplayName("mix of real comparisons and placeholder skips → equivalent if real ones match")
+ void testMixedRealAndPlaceholder() throws Exception {
+ createTestDb(originalDb);
+ createTestDb(candidateDb);
+
+ byte[] realBytes1 = Serializer.serialize(42);
+ byte[] realBytes2 = Serializer.serialize("hello");
+ byte[] placeholderBytes = Serializer.serialize(
+ KryoPlaceholder.create(new Object(), "unserializable", "root")
+ );
+
+ insertRow(originalDb, "iter_1_0", 1, realBytes1);
+ insertRow(candidateDb, "iter_1_1", 1, realBytes1);
+ insertRow(originalDb, "iter_2_0", 1, realBytes2);
+ insertRow(candidateDb, "iter_2_1", 1, realBytes2);
+ insertRow(originalDb, "iter_3_0", 1, placeholderBytes);
+ insertRow(candidateDb, "iter_3_1", 1, placeholderBytes);
+
+ String json = Comparator.compareDatabases(originalDb.toString(), candidateDb.toString());
+ Map result = parseJson(json);
+
+ assertTrue((Boolean) result.get("equivalent"));
+ assertEquals(2, ((Number) result.get("actualComparisons")).intValue());
+ assertEquals(1, ((Number) result.get("skippedPlaceholders")).intValue());
+ }
+
+ @Test
+ @DisplayName("normal happy path — matching results → equivalent")
+ void testNormalHappyPath() throws Exception {
+ createTestDb(originalDb);
+ createTestDb(candidateDb);
+
+ byte[] bytes1 = Serializer.serialize(100);
+ byte[] bytes2 = Serializer.serialize("world");
+
+ insertRow(originalDb, "iter_1_0", 1, bytes1);
+ insertRow(candidateDb, "iter_1_1", 1, bytes1);
+ insertRow(originalDb, "iter_2_0", 1, bytes2);
+ insertRow(candidateDb, "iter_2_1", 1, bytes2);
+
+ String json = Comparator.compareDatabases(originalDb.toString(), candidateDb.toString());
+ Map result = parseJson(json);
+
+ assertTrue((Boolean) result.get("equivalent"));
+ assertEquals(2, ((Number) result.get("actualComparisons")).intValue());
+ assertEquals(0, ((Number) result.get("skippedPlaceholders")).intValue());
+ assertEquals(0, ((Number) result.get("skippedDeserializationErrors")).intValue());
+ }
+
+ @Test
+ @DisplayName("normal mismatch — different results → not equivalent with diffs")
+ void testNormalMismatch() throws Exception {
+ createTestDb(originalDb);
+ createTestDb(candidateDb);
+
+ byte[] origBytes = Serializer.serialize(42);
+ byte[] candBytes = Serializer.serialize(99);
+
+ insertRow(originalDb, "iter_1_0", 1, origBytes);
+ insertRow(candidateDb, "iter_1_1", 1, candBytes);
+
+ String json = Comparator.compareDatabases(originalDb.toString(), candidateDb.toString());
+ Map result = parseJson(json);
+
+ assertFalse((Boolean) result.get("equivalent"));
+ assertTrue(((Number) result.get("actualComparisons")).intValue() > 0);
+ }
+
+ @Test
+ @DisplayName("void methods (both null) → equivalent with actual comparison counted")
+ void testVoidMethodsBothNull() throws Exception {
+ createTestDb(originalDb);
+ createTestDb(candidateDb);
+
+ // Insert rows with NULL return_value (void methods)
+ insertRow(originalDb, "iter_1_0", 1, null);
+ insertRow(candidateDb, "iter_1_1", 1, null);
+
+ String json = Comparator.compareDatabases(originalDb.toString(), candidateDb.toString());
+ Map result = parseJson(json);
+
+ assertTrue((Boolean) result.get("equivalent"));
+ assertEquals(1, ((Number) result.get("actualComparisons")).intValue());
+ }
+
+ @Test
+ @DisplayName("one side empty — original has rows, candidate empty → not equivalent")
+ void testOneSideEmpty() throws Exception {
+ createTestDb(originalDb);
+ createTestDb(candidateDb);
+
+ byte[] bytes = Serializer.serialize(42);
+ insertRow(originalDb, "iter_1_0", 1, bytes);
+ // candidateDb has no rows
+
+ String json = Comparator.compareDatabases(originalDb.toString(), candidateDb.toString());
+ Map result = parseJson(json);
+
+ assertFalse((Boolean) result.get("equivalent"));
+ // The missing invocation counts as an actual comparison (it produces a diff)
+ assertEquals(1, ((Number) result.get("actualComparisons")).intValue());
+ }
+
+ @Test
+ @DisplayName("isDeserializationError correctly identifies error maps")
+ void testIsDeserializationError() {
+ Map errorMap = new HashMap<>();
+ errorMap.put("__type", "DeserializationError");
+ errorMap.put("error", "some error");
+ assertTrue(Comparator.isDeserializationError(errorMap));
+
+ Map normalMap = new HashMap<>();
+ normalMap.put("__type", "SomethingElse");
+ assertFalse(Comparator.isDeserializationError(normalMap));
+
+ Map emptyMap = new HashMap<>();
+ assertFalse(Comparator.isDeserializationError(emptyMap));
+
+ assertFalse(Comparator.isDeserializationError("not a map"));
+ assertFalse(Comparator.isDeserializationError(null));
+ assertFalse(Comparator.isDeserializationError(42));
+ }
+
+ // --- Helpers ---
+
+ private void createTestDb(Path dbPath) throws Exception {
+ String url = "jdbc:sqlite:" + dbPath;
+ try (Connection conn = DriverManager.getConnection(url);
+ Statement stmt = conn.createStatement()) {
+ stmt.execute("CREATE TABLE IF NOT EXISTS test_results ("
+ + "test_module_path TEXT NOT NULL, "
+ + "test_class_name TEXT NOT NULL, "
+ + "test_function_name TEXT NOT NULL, "
+ + "iteration_id TEXT NOT NULL, "
+ + "loop_index INTEGER NOT NULL, "
+ + "return_value BLOB, "
+ + "PRIMARY KEY (iteration_id, loop_index))");
+ }
+ }
+
+ private void insertRow(Path dbPath, String iterationId, int loopIndex, byte[] returnValue) throws Exception {
+ String url = "jdbc:sqlite:" + dbPath;
+ try (Connection conn = DriverManager.getConnection(url);
+ PreparedStatement ps = conn.prepareStatement(
+ "INSERT INTO test_results (test_module_path, test_class_name, test_function_name, iteration_id, loop_index, return_value) VALUES (?, ?, ?, ?, ?, ?)")) {
+ ps.setString(1, "src/test/java/com/example/TestClass.java");
+ ps.setString(2, "TestClass");
+ ps.setString(3, "testMethod");
+ ps.setString(4, iterationId);
+ ps.setInt(5, loopIndex);
+ ps.setBytes(6, returnValue);
+ ps.executeUpdate();
+ }
+ }
+
+ @SuppressWarnings("unchecked")
+ private Map parseJson(String json) {
+ // Minimal JSON parsing for test assertions — handles the flat structure from compareDatabases
+ Map result = new HashMap<>();
+
+ // Remove outer braces
+ json = json.trim();
+ if (json.startsWith("{")) json = json.substring(1);
+ if (json.endsWith("}")) json = json.substring(0, json.length() - 1);
+
+ // Extract known fields
+ result.put("equivalent", extractBoolean(json, "equivalent"));
+ result.put("totalInvocations", extractInt(json, "totalInvocations"));
+ result.put("actualComparisons", extractInt(json, "actualComparisons"));
+ result.put("skippedPlaceholders", extractInt(json, "skippedPlaceholders"));
+ result.put("skippedDeserializationErrors", extractInt(json, "skippedDeserializationErrors"));
+
+ return result;
+ }
+
+ private Boolean extractBoolean(String json, String key) {
+ String pattern = "\"" + key + "\":";
+ int idx = json.indexOf(pattern);
+ if (idx < 0) return null;
+ String after = json.substring(idx + pattern.length()).trim();
+ return after.startsWith("true");
+ }
+
+ private Integer extractInt(String json, String key) {
+ String pattern = "\"" + key + "\":";
+ int idx = json.indexOf(pattern);
+ if (idx < 0) return null;
+ String after = json.substring(idx + pattern.length()).trim();
+ StringBuilder sb = new StringBuilder();
+ for (char c : after.toCharArray()) {
+ if (Character.isDigit(c) || c == '-') sb.append(c);
+ else break;
+ }
+ return sb.length() > 0 ? Integer.parseInt(sb.toString()) : null;
+ }
+}
diff --git a/codeflash-java-runtime/src/test/java/com/codeflash/ComparatorEdgeCaseTest.java b/codeflash-java-runtime/src/test/java/com/codeflash/ComparatorEdgeCaseTest.java
new file mode 100644
index 000000000..2bfc904bd
--- /dev/null
+++ b/codeflash-java-runtime/src/test/java/com/codeflash/ComparatorEdgeCaseTest.java
@@ -0,0 +1,842 @@
+package com.codeflash;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.net.URI;
+import java.net.URL;
+import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+/**
+ * Edge case tests for Comparator to catch subtle bugs.
+ */
+@DisplayName("Comparator Edge Case Tests")
+class ComparatorEdgeCaseTest {
+
+ // ============================================================
+ // NUMBER EDGE CASES
+ // ============================================================
+
+ @Nested
+ @DisplayName("Number Edge Cases")
+ class NumberEdgeCases {
+
+ @Test
+ @DisplayName("BigDecimal comparison should work correctly")
+ void testBigDecimalComparison() {
+ BigDecimal bd1 = new BigDecimal("123456789.123456789");
+ BigDecimal bd2 = new BigDecimal("123456789.123456789");
+ BigDecimal bd3 = new BigDecimal("123456789.123456788");
+
+ assertTrue(Comparator.compare(bd1, bd2), "Same BigDecimals should be equal");
+ assertFalse(Comparator.compare(bd1, bd3), "Different BigDecimals should not be equal");
+ }
+
+ @Test
+ @DisplayName("BigDecimal with different scale should compare by value")
+ void testBigDecimalDifferentScale() {
+ BigDecimal bd1 = new BigDecimal("1.0");
+ BigDecimal bd2 = new BigDecimal("1.00");
+
+ // Note: BigDecimal.equals considers scale, but compareTo doesn't
+ // Our comparator should handle this
+ assertTrue(Comparator.compare(bd1, bd2), "1.0 and 1.00 should be equal");
+ }
+
+ @Test
+ @DisplayName("BigInteger comparison should work correctly")
+ void testBigIntegerComparison() {
+ BigInteger bi1 = new BigInteger("123456789012345678901234567890");
+ BigInteger bi2 = new BigInteger("123456789012345678901234567890");
+ BigInteger bi3 = new BigInteger("123456789012345678901234567891");
+
+ assertTrue(Comparator.compare(bi1, bi2), "Same BigIntegers should be equal");
+ assertFalse(Comparator.compare(bi1, bi3), "Different BigIntegers should not be equal");
+ }
+
+ @Test
+ @DisplayName("BigInteger larger than Long.MAX_VALUE")
+ void testBigIntegerLargerThanLong() {
+ BigInteger bi1 = BigInteger.valueOf(Long.MAX_VALUE).add(BigInteger.ONE);
+ BigInteger bi2 = BigInteger.valueOf(Long.MAX_VALUE).add(BigInteger.ONE);
+ BigInteger bi3 = BigInteger.valueOf(Long.MAX_VALUE).add(BigInteger.TWO);
+
+ assertTrue(Comparator.compare(bi1, bi2), "Same large BigIntegers should be equal");
+ assertFalse(Comparator.compare(bi1, bi3), "Different large BigIntegers should not be equal");
+ }
+
+ @Test
+ @DisplayName("Byte comparison")
+ void testByteComparison() {
+ Byte b1 = (byte) 127;
+ Byte b2 = (byte) 127;
+ Byte b3 = (byte) -128;
+
+ assertTrue(Comparator.compare(b1, b2));
+ assertFalse(Comparator.compare(b1, b3));
+ }
+
+ @Test
+ @DisplayName("Short comparison")
+ void testShortComparison() {
+ Short s1 = (short) 32767;
+ Short s2 = (short) 32767;
+ Short s3 = (short) -32768;
+
+ assertTrue(Comparator.compare(s1, s2));
+ assertFalse(Comparator.compare(s1, s3));
+ }
+
+ @Test
+ @DisplayName("Large double comparison with relative tolerance")
+ void testLargeDoubleComparison() {
+ // For large numbers, absolute epsilon may be too small
+ double large1 = 1e15;
+ double large2 = 1e15 + 1; // Difference of 1 in 1e15
+
+ // With relative tolerance, these should be equal (difference is 1e-15 relative)
+ assertTrue(Comparator.compare(large1, large2),
+ "Large numbers with tiny relative difference should be equal");
+ }
+
+ @Test
+ @DisplayName("Large doubles that are actually different")
+ void testLargeDoublesActuallyDifferent() {
+ double large1 = 1e15;
+ double large2 = 1.001e15; // 0.1% difference
+
+ assertFalse(Comparator.compare(large1, large2),
+ "Large numbers with significant relative difference should NOT be equal");
+ }
+
+ @Test
+ @DisplayName("Float vs Double comparison")
+ void testFloatVsDouble() {
+ Float f = 3.14f;
+ Double d = 3.14;
+
+ // These may differ slightly due to precision
+ // Testing current behavior
+ boolean result = Comparator.compare(f, d);
+ // Document: Float 3.14f != Double 3.14 due to precision differences
+ }
+
+ @Test
+ @DisplayName("Integer overflow edge case")
+ void testIntegerOverflow() {
+ Integer maxInt = Integer.MAX_VALUE;
+ Long maxIntAsLong = (long) Integer.MAX_VALUE;
+
+ assertTrue(Comparator.compare(maxInt, maxIntAsLong),
+ "Integer.MAX_VALUE should equal same value as Long");
+ }
+
+ @Test
+ @DisplayName("Long overflow to BigInteger")
+ void testLongOverflowToBigInteger() {
+ Long maxLong = Long.MAX_VALUE;
+ BigInteger maxLongAsBigInt = BigInteger.valueOf(Long.MAX_VALUE);
+
+ assertTrue(Comparator.compare(maxLong, maxLongAsBigInt),
+ "Long.MAX_VALUE should equal same value as BigInteger");
+ }
+
+ @Test
+ @DisplayName("Very small double comparison")
+ void testVerySmallDoubleComparison() {
+ double small1 = 1e-15;
+ double small2 = 1e-15 + 1e-25;
+
+ assertTrue(Comparator.compare(small1, small2),
+ "Very close small numbers should be equal");
+ }
+
+ @Test
+ @DisplayName("Negative zero equals positive zero")
+ void testNegativeZero() {
+ double negZero = -0.0;
+ double posZero = 0.0;
+
+ assertTrue(Comparator.compare(negZero, posZero),
+ "-0.0 should equal 0.0");
+ }
+
+ @Test
+ @DisplayName("Mixed integer types comparison")
+ void testMixedIntegerTypes() {
+ Integer i = 42;
+ Long l = 42L;
+
+ assertTrue(Comparator.compare(i, l), "Integer 42 should equal Long 42");
+ }
+ }
+
+ // ============================================================
+ // ARRAY EDGE CASES
+ // ============================================================
+
+ @Nested
+ @DisplayName("Array Edge Cases")
+ class ArrayEdgeCases {
+
+ @Test
+ @DisplayName("Empty arrays of same type")
+ void testEmptyArrays() {
+ int[] arr1 = new int[0];
+ int[] arr2 = new int[0];
+
+ assertTrue(Comparator.compare(arr1, arr2));
+ }
+
+ @Test
+ @DisplayName("Empty arrays of different types")
+ void testEmptyArraysDifferentTypes() {
+ int[] intArr = new int[0];
+ long[] longArr = new long[0];
+
+ // Different array types should not be equal even if empty
+ assertFalse(Comparator.compare(intArr, longArr));
+ }
+
+ @Test
+ @DisplayName("Primitive array vs wrapper array")
+ void testPrimitiveVsWrapperArray() {
+ int[] primitiveArr = {1, 2, 3};
+ Integer[] wrapperArr = {1, 2, 3};
+
+ // These are different types
+ assertFalse(Comparator.compare(primitiveArr, wrapperArr));
+ }
+
+ @Test
+ @DisplayName("Nested arrays")
+ void testNestedArrays() {
+ int[][] arr1 = {{1, 2}, {3, 4}};
+ int[][] arr2 = {{1, 2}, {3, 4}};
+ int[][] arr3 = {{1, 2}, {3, 5}};
+
+ assertTrue(Comparator.compare(arr1, arr2));
+ assertFalse(Comparator.compare(arr1, arr3));
+ }
+
+ @Test
+ @DisplayName("Array with null elements")
+ void testArrayWithNulls() {
+ String[] arr1 = {"a", null, "c"};
+ String[] arr2 = {"a", null, "c"};
+ String[] arr3 = {"a", "b", "c"};
+
+ assertTrue(Comparator.compare(arr1, arr2));
+ assertFalse(Comparator.compare(arr1, arr3));
+ }
+ }
+
+ // ============================================================
+ // LIST VS SET ORDER BEHAVIOR
+ // ============================================================
+
+ @Nested
+ @DisplayName("List vs Set Order Behavior")
+ class ListVsSetOrderBehavior {
+
+ @Test
+ @DisplayName("List comparison is ORDER SENSITIVE - [1,2,3] vs [2,3,1] should be FALSE")
+ void testListOrderMatters() {
+ List list1 = Arrays.asList(1, 2, 3);
+ List list2 = Arrays.asList(2, 3, 1);
+
+ assertFalse(Comparator.compare(list1, list2),
+ "Lists with same elements but different order should NOT be equal");
+ }
+
+ @Test
+ @DisplayName("List comparison with same order should be TRUE")
+ void testListSameOrder() {
+ List list1 = Arrays.asList(1, 2, 3);
+ List list2 = Arrays.asList(1, 2, 3);
+
+ assertTrue(Comparator.compare(list1, list2),
+ "Lists with same elements in same order should be equal");
+ }
+
+ @Test
+ @DisplayName("Set comparison is ORDER INDEPENDENT - {1,2,3} vs {3,2,1} should be TRUE")
+ void testSetOrderDoesNotMatter() {
+ Set set1 = new LinkedHashSet<>(Arrays.asList(1, 2, 3));
+ Set set2 = new LinkedHashSet<>(Arrays.asList(3, 2, 1));
+
+ assertTrue(Comparator.compare(set1, set2),
+ "Sets with same elements in different order should be equal");
+ }
+
+ @Test
+ @DisplayName("Set comparison with different elements should be FALSE")
+ void testSetDifferentElements() {
+ Set set1 = new HashSet<>(Arrays.asList(1, 2, 3));
+ Set set2 = new HashSet<>(Arrays.asList(1, 2, 4));
+
+ assertFalse(Comparator.compare(set1, set2),
+ "Sets with different elements should NOT be equal");
+ }
+
+ @Test
+ @DisplayName("ArrayList vs LinkedList with same elements same order should be TRUE")
+ void testDifferentListImplementationsSameOrder() {
+ List arrayList = new ArrayList<>(Arrays.asList(1, 2, 3));
+ List linkedList = new LinkedList<>(Arrays.asList(1, 2, 3));
+
+ assertTrue(Comparator.compare(arrayList, linkedList),
+ "Different List implementations with same elements in same order should be equal");
+ }
+
+ @Test
+ @DisplayName("ArrayList vs LinkedList with different order should be FALSE")
+ void testDifferentListImplementationsDifferentOrder() {
+ List arrayList = new ArrayList<>(Arrays.asList(1, 2, 3));
+ List linkedList = new LinkedList<>(Arrays.asList(3, 2, 1));
+
+ assertFalse(Comparator.compare(arrayList, linkedList),
+ "Different List implementations with different order should NOT be equal");
+ }
+
+ @Test
+ @DisplayName("HashSet vs TreeSet with same elements should be TRUE")
+ void testDifferentSetImplementations() {
+ Set hashSet = new HashSet<>(Arrays.asList(3, 1, 2));
+ Set treeSet = new TreeSet<>(Arrays.asList(1, 2, 3));
+
+ assertTrue(Comparator.compare(hashSet, treeSet),
+ "Different Set implementations with same elements should be equal");
+ }
+
+ @Test
+ @DisplayName("List with nested lists - order matters at all levels")
+ void testNestedListOrder() {
+ List> list1 = Arrays.asList(
+ Arrays.asList(1, 2),
+ Arrays.asList(3, 4)
+ );
+ List> list2 = Arrays.asList(
+ Arrays.asList(3, 4),
+ Arrays.asList(1, 2)
+ );
+ List> list3 = Arrays.asList(
+ Arrays.asList(1, 2),
+ Arrays.asList(3, 4)
+ );
+
+ assertFalse(Comparator.compare(list1, list2),
+ "Nested lists with different outer order should NOT be equal");
+ assertTrue(Comparator.compare(list1, list3),
+ "Nested lists with same order should be equal");
+ }
+
+ @Test
+ @DisplayName("Set with nested sets - order independent")
+ void testNestedSetOrder() {
+ Set> set1 = new HashSet<>();
+ set1.add(new HashSet<>(Arrays.asList(1, 2)));
+ set1.add(new HashSet<>(Arrays.asList(3, 4)));
+
+ Set> set2 = new HashSet<>();
+ set2.add(new HashSet<>(Arrays.asList(4, 3))); // Different internal order
+ set2.add(new HashSet<>(Arrays.asList(2, 1))); // Different internal order
+
+ assertTrue(Comparator.compare(set1, set2),
+ "Nested sets should be equal regardless of order at any level");
+ }
+ }
+
+ // ============================================================
+ // COLLECTION EDGE CASES
+ // ============================================================
+
+ @Nested
+ @DisplayName("Collection Edge Cases")
+ class CollectionEdgeCases {
+
+ @Test
+ @DisplayName("Set with custom objects without equals")
+ void testSetWithCustomObjectsNoEquals() {
+ Set set1 = new HashSet<>();
+ set1.add(new CustomNoEquals("a"));
+
+ Set set2 = new HashSet<>();
+ set2.add(new CustomNoEquals("a"));
+
+ // Should use deep comparison, not equals()
+ assertTrue(Comparator.compare(set1, set2),
+ "Sets with equivalent custom objects should be equal");
+ }
+
+ @Test
+ @DisplayName("Empty Set equals empty Set")
+ void testEmptySets() {
+ Set set1 = new HashSet<>();
+ Set set2 = new TreeSet<>();
+
+ assertTrue(Comparator.compare(set1, set2));
+ }
+
+ @Test
+ @DisplayName("List vs Set with same elements")
+ void testListVsSet() {
+ List list = Arrays.asList(1, 2, 3);
+ Set set = new LinkedHashSet<>(Arrays.asList(1, 2, 3));
+
+ // Different collection types should not be equal
+ // Actually, our comparator allows this - testing current behavior
+ boolean result = Comparator.compare(list, set);
+ // Document: List and Set comparison depends on areTypesCompatible
+ }
+
+ @Test
+ @DisplayName("List with duplicates vs Set")
+ void testListWithDuplicatesVsSet() {
+ List list = Arrays.asList(1, 1, 2);
+ Set set = new LinkedHashSet<>(Arrays.asList(1, 2));
+
+ assertFalse(Comparator.compare(list, set), "Different sizes should not be equal");
+ }
+
+ @Test
+ @DisplayName("ConcurrentHashMap comparison")
+ void testConcurrentHashMap() {
+ ConcurrentHashMap map1 = new ConcurrentHashMap<>();
+ map1.put("a", 1);
+ map1.put("b", 2);
+
+ ConcurrentHashMap map2 = new ConcurrentHashMap<>();
+ map2.put("a", 1);
+ map2.put("b", 2);
+
+ assertTrue(Comparator.compare(map1, map2));
+ }
+ }
+
+ // ============================================================
+ // MAP EDGE CASES
+ // ============================================================
+
+ @Nested
+ @DisplayName("Map Edge Cases")
+ class MapEdgeCases {
+
+ @Test
+ @DisplayName("Map with null key")
+ void testMapWithNullKey() {
+ Map map1 = new HashMap<>();
+ map1.put(null, 1);
+ map1.put("b", 2);
+
+ Map map2 = new HashMap<>();
+ map2.put(null, 1);
+ map2.put("b", 2);
+
+ assertTrue(Comparator.compare(map1, map2));
+ }
+
+ @Test
+ @DisplayName("Map with null value")
+ void testMapWithNullValue() {
+ Map map1 = new HashMap<>();
+ map1.put("a", null);
+ map1.put("b", 2);
+
+ Map map2 = new HashMap<>();
+ map2.put("a", null);
+ map2.put("b", 2);
+
+ assertTrue(Comparator.compare(map1, map2));
+ }
+
+ @Test
+ @DisplayName("Map with complex keys")
+ void testMapWithComplexKeys() {
+ Map, String> map1 = new HashMap<>();
+ map1.put(Arrays.asList(1, 2, 3), "value1");
+
+ Map, String> map2 = new HashMap<>();
+ map2.put(Arrays.asList(1, 2, 3), "value1");
+
+ assertTrue(Comparator.compare(map1, map2),
+ "Maps with complex keys should compare using deep key comparison");
+ }
+
+ @Test
+ @DisplayName("Map comparison should not double-match entries")
+ void testMapNoDoubleMatching() {
+ // This tests that we don't match the same entry twice
+ Map map1 = new HashMap<>();
+ map1.put("a", 1);
+ map1.put("b", 1); // Same value as "a"
+
+ Map map2 = new HashMap<>();
+ map2.put("a", 1);
+ map2.put("c", 1); // Different key but same value
+
+ assertFalse(Comparator.compare(map1, map2),
+ "Maps with different keys should not be equal");
+ }
+ }
+
+ // ============================================================
+ // OBJECT EDGE CASES
+ // ============================================================
+
+ @Nested
+ @DisplayName("Object Edge Cases")
+ class ObjectEdgeCases {
+
+ @Test
+ @DisplayName("Objects with inherited fields")
+ void testInheritedFields() {
+ Child child1 = new Child("parent", "child");
+ Child child2 = new Child("parent", "child");
+ Child child3 = new Child("different", "child");
+
+ assertTrue(Comparator.compare(child1, child2));
+ assertFalse(Comparator.compare(child1, child3));
+ }
+
+ @Test
+ @DisplayName("Different classes with same fields should not be equal")
+ void testDifferentClassesSameFields() {
+ ClassA objA = new ClassA("value");
+ ClassB objB = new ClassB("value");
+
+ assertFalse(Comparator.compare(objA, objB),
+ "Different classes should not be equal even with same field values");
+ }
+
+ @Test
+ @DisplayName("Object with transient field")
+ void testTransientField() {
+ ObjectWithTransient obj1 = new ObjectWithTransient("name", "transientValue1");
+ ObjectWithTransient obj2 = new ObjectWithTransient("name", "transientValue2");
+
+ // Transient fields should be skipped
+ assertTrue(Comparator.compare(obj1, obj2),
+ "Objects differing only in transient fields should be equal");
+ }
+
+ @Test
+ @DisplayName("Object with static field")
+ void testStaticField() {
+ ObjectWithStatic.staticField = "static1";
+ ObjectWithStatic obj1 = new ObjectWithStatic("instance1");
+
+ ObjectWithStatic.staticField = "static2";
+ ObjectWithStatic obj2 = new ObjectWithStatic("instance1");
+
+ // Static fields should be skipped
+ assertTrue(Comparator.compare(obj1, obj2),
+ "Static fields should not affect comparison");
+ }
+
+ @Test
+ @DisplayName("Circular reference in object")
+ void testCircularReferenceInObject() {
+ CircularRef ref1 = new CircularRef("a");
+ CircularRef ref2 = new CircularRef("b");
+ ref1.other = ref2;
+ ref2.other = ref1;
+
+ CircularRef ref3 = new CircularRef("a");
+ CircularRef ref4 = new CircularRef("b");
+ ref3.other = ref4;
+ ref4.other = ref3;
+
+ assertTrue(Comparator.compare(ref1, ref3),
+ "Equivalent circular structures should be equal");
+ }
+ }
+
+ // ============================================================
+ // SPECIAL TYPES
+ // ============================================================
+
+ @Nested
+ @DisplayName("Special Types")
+ class SpecialTypes {
+
+ @Test
+ @DisplayName("UUID comparison")
+ void testUUIDComparison() {
+ UUID uuid1 = UUID.fromString("550e8400-e29b-41d4-a716-446655440000");
+ UUID uuid2 = UUID.fromString("550e8400-e29b-41d4-a716-446655440000");
+ UUID uuid3 = UUID.fromString("550e8400-e29b-41d4-a716-446655440001");
+
+ assertTrue(Comparator.compare(uuid1, uuid2));
+ assertFalse(Comparator.compare(uuid1, uuid3));
+ }
+
+ @Test
+ @DisplayName("URI comparison")
+ void testURIComparison() throws Exception {
+ URI uri1 = new URI("https://example.com/path");
+ URI uri2 = new URI("https://example.com/path");
+ URI uri3 = new URI("https://example.com/other");
+
+ assertTrue(Comparator.compare(uri1, uri2));
+ assertFalse(Comparator.compare(uri1, uri3));
+ }
+
+ @Test
+ @DisplayName("URL comparison")
+ void testURLComparison() throws Exception {
+ URL url1 = new URL("https://example.com/path");
+ URL url2 = new URL("https://example.com/path");
+
+ assertTrue(Comparator.compare(url1, url2));
+ }
+
+ @Test
+ @DisplayName("Class object comparison")
+ void testClassObjectComparison() {
+ Class class1 = String.class;
+ Class class2 = String.class;
+ Class class3 = Integer.class;
+
+ assertTrue(Comparator.compare(class1, class2));
+ assertFalse(Comparator.compare(class1, class3));
+ }
+ }
+
+ // ============================================================
+ // CUSTOM OBJECT (PERSON) EDGE CASES
+ // ============================================================
+
+ @Nested
+ @DisplayName("Custom Object (Person) Edge Cases")
+ class PersonObjectEdgeCases {
+
+ @Test
+ @DisplayName("Person with same name, age, date should be equal")
+ void testPersonSameFields() {
+ Person p1 = new Person("John", 25, java.time.LocalDate.of(2000, 1, 15));
+ Person p2 = new Person("John", 25, java.time.LocalDate.of(2000, 1, 15));
+
+ assertTrue(Comparator.compare(p1, p2),
+ "Persons with same fields should be equal");
+ }
+
+ @Test
+ @DisplayName("Person with different name should NOT be equal")
+ void testPersonDifferentName() {
+ Person p1 = new Person("John", 25, java.time.LocalDate.of(2000, 1, 15));
+ Person p2 = new Person("Jane", 25, java.time.LocalDate.of(2000, 1, 15));
+
+ assertFalse(Comparator.compare(p1, p2),
+ "Persons with different names should NOT be equal");
+ }
+
+ @Test
+ @DisplayName("Person with different age should NOT be equal")
+ void testPersonDifferentAge() {
+ Person p1 = new Person("John", 25, java.time.LocalDate.of(2000, 1, 15));
+ Person p2 = new Person("John", 26, java.time.LocalDate.of(2000, 1, 15));
+
+ assertFalse(Comparator.compare(p1, p2),
+ "Persons with different ages should NOT be equal");
+ }
+
+ @Test
+ @DisplayName("Person with different date should NOT be equal")
+ void testPersonDifferentDate() {
+ Person p1 = new Person("John", 25, java.time.LocalDate.of(2000, 1, 15));
+ Person p2 = new Person("John", 25, java.time.LocalDate.of(2000, 1, 16));
+
+ assertFalse(Comparator.compare(p1, p2),
+ "Persons with different dates should NOT be equal");
+ }
+
+ @Test
+ @DisplayName("Person with null name vs non-null name")
+ void testPersonNullVsNonNullName() {
+ Person p1 = new Person(null, 25, java.time.LocalDate.of(2000, 1, 15));
+ Person p2 = new Person("John", 25, java.time.LocalDate.of(2000, 1, 15));
+
+ assertFalse(Comparator.compare(p1, p2),
+ "Person with null name vs non-null name should NOT be equal");
+ }
+
+ @Test
+ @DisplayName("Person with both null names should be equal")
+ void testPersonBothNullNames() {
+ Person p1 = new Person(null, 25, java.time.LocalDate.of(2000, 1, 15));
+ Person p2 = new Person(null, 25, java.time.LocalDate.of(2000, 1, 15));
+
+ assertTrue(Comparator.compare(p1, p2),
+ "Persons with both null names and same other fields should be equal");
+ }
+
+ @Test
+ @DisplayName("Person with null date vs non-null date")
+ void testPersonNullVsNonNullDate() {
+ Person p1 = new Person("John", 25, null);
+ Person p2 = new Person("John", 25, java.time.LocalDate.of(2000, 1, 15));
+
+ assertFalse(Comparator.compare(p1, p2),
+ "Person with null date vs non-null date should NOT be equal");
+ }
+
+ @Test
+ @DisplayName("List of Persons with same content same order")
+ void testListOfPersonsSameOrder() {
+ List list1 = Arrays.asList(
+ new Person("John", 25, java.time.LocalDate.of(2000, 1, 15)),
+ new Person("Jane", 30, java.time.LocalDate.of(1995, 6, 20))
+ );
+ List list2 = Arrays.asList(
+ new Person("John", 25, java.time.LocalDate.of(2000, 1, 15)),
+ new Person("Jane", 30, java.time.LocalDate.of(1995, 6, 20))
+ );
+
+ assertTrue(Comparator.compare(list1, list2),
+ "Lists of Persons with same content in same order should be equal");
+ }
+
+ @Test
+ @DisplayName("List of Persons with same content different order should NOT be equal")
+ void testListOfPersonsDifferentOrder() {
+ List list1 = Arrays.asList(
+ new Person("John", 25, java.time.LocalDate.of(2000, 1, 15)),
+ new Person("Jane", 30, java.time.LocalDate.of(1995, 6, 20))
+ );
+ List list2 = Arrays.asList(
+ new Person("Jane", 30, java.time.LocalDate.of(1995, 6, 20)),
+ new Person("John", 25, java.time.LocalDate.of(2000, 1, 15))
+ );
+
+ assertFalse(Comparator.compare(list1, list2),
+ "Lists of Persons with different order should NOT be equal");
+ }
+
+ @Test
+ @DisplayName("Map with Person values")
+ void testMapWithPersonValues() {
+ Map map1 = new HashMap<>();
+ map1.put("employee1", new Person("John", 25, java.time.LocalDate.of(2000, 1, 15)));
+
+ Map map2 = new HashMap<>();
+ map2.put("employee1", new Person("John", 25, java.time.LocalDate.of(2000, 1, 15)));
+
+ assertTrue(Comparator.compare(map1, map2),
+ "Maps with same Person values should be equal");
+ }
+
+ @Test
+ @DisplayName("Person with floating point age (simulated)")
+ void testPersonWithFloatingPointField() {
+ PersonWithDouble p1 = new PersonWithDouble("John", 25.0000000001);
+ PersonWithDouble p2 = new PersonWithDouble("John", 25.0);
+
+ assertTrue(Comparator.compare(p1, p2),
+ "Persons with nearly equal floating point ages should be equal");
+ }
+ }
+
+ // ============================================================
+ // HELPER CLASSES
+ // ============================================================
+
+ static class Person {
+ String name;
+ int age;
+ java.time.LocalDate birthDate;
+
+ Person(String name, int age, java.time.LocalDate birthDate) {
+ this.name = name;
+ this.age = age;
+ this.birthDate = birthDate;
+ }
+ // Intentionally NO equals/hashCode - uses reflection comparison
+ }
+
+ static class PersonWithDouble {
+ String name;
+ double age;
+
+ PersonWithDouble(String name, double age) {
+ this.name = name;
+ this.age = age;
+ }
+ }
+
+ static class CustomNoEquals {
+ String value;
+
+ CustomNoEquals(String value) {
+ this.value = value;
+ }
+ // No equals/hashCode override
+ }
+
+ static class Parent {
+ String parentField;
+
+ Parent(String parentField) {
+ this.parentField = parentField;
+ }
+ }
+
+ static class Child extends Parent {
+ String childField;
+
+ Child(String parentField, String childField) {
+ super(parentField);
+ this.childField = childField;
+ }
+ }
+
+ static class ClassA {
+ String field;
+
+ ClassA(String field) {
+ this.field = field;
+ }
+ }
+
+ static class ClassB {
+ String field;
+
+ ClassB(String field) {
+ this.field = field;
+ }
+ }
+
+ static class ObjectWithTransient {
+ String name;
+ transient String transientField;
+
+ ObjectWithTransient(String name, String transientField) {
+ this.name = name;
+ this.transientField = transientField;
+ }
+ }
+
+ static class ObjectWithStatic {
+ static String staticField;
+ String instanceField;
+
+ ObjectWithStatic(String instanceField) {
+ this.instanceField = instanceField;
+ }
+ }
+
+ static class CircularRef {
+ String name;
+ CircularRef other;
+
+ CircularRef(String name) {
+ this.name = name;
+ }
+ }
+}
diff --git a/codeflash-java-runtime/src/test/java/com/codeflash/ComparatorTest.java b/codeflash-java-runtime/src/test/java/com/codeflash/ComparatorTest.java
new file mode 100644
index 000000000..9b3e5462f
--- /dev/null
+++ b/codeflash-java-runtime/src/test/java/com/codeflash/ComparatorTest.java
@@ -0,0 +1,506 @@
+package com.codeflash;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import java.util.*;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+/**
+ * Tests for Comparator.
+ */
+@DisplayName("Comparator Tests")
+class ComparatorTest {
+
+ @Nested
+ @DisplayName("Primitive Comparison")
+ class PrimitiveTests {
+
+ @Test
+ @DisplayName("integers: exact match")
+ void testIntegers() {
+ assertTrue(Comparator.compare(42, 42));
+ assertFalse(Comparator.compare(42, 43));
+ }
+
+ @Test
+ @DisplayName("longs: exact match")
+ void testLongs() {
+ assertTrue(Comparator.compare(Long.MAX_VALUE, Long.MAX_VALUE));
+ assertFalse(Comparator.compare(1L, 2L));
+ }
+
+ @Test
+ @DisplayName("doubles: epsilon tolerance")
+ void testDoubleEpsilon() {
+ // Within epsilon - should be equal
+ assertTrue(Comparator.compare(1.0, 1.0 + 1e-10));
+ assertTrue(Comparator.compare(3.14159, 3.14159 + 1e-12));
+
+ // Outside epsilon - should not be equal
+ assertFalse(Comparator.compare(1.0, 1.1));
+ assertFalse(Comparator.compare(1.0, 1.0 + 1e-8));
+ }
+
+ @Test
+ @DisplayName("floats: epsilon tolerance")
+ void testFloatEpsilon() {
+ assertTrue(Comparator.compare(1.0f, 1.0f + 1e-10f));
+ assertFalse(Comparator.compare(1.0f, 1.1f));
+ }
+
+ @Test
+ @DisplayName("NaN: should equal NaN")
+ void testNaN() {
+ assertTrue(Comparator.compare(Double.NaN, Double.NaN));
+ assertTrue(Comparator.compare(Float.NaN, Float.NaN));
+ }
+
+ @Test
+ @DisplayName("Infinity: same sign should be equal")
+ void testInfinity() {
+ assertTrue(Comparator.compare(Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY));
+ assertTrue(Comparator.compare(Double.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY));
+ assertFalse(Comparator.compare(Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY));
+ }
+
+ @Test
+ @DisplayName("booleans: exact match")
+ void testBooleans() {
+ assertTrue(Comparator.compare(true, true));
+ assertTrue(Comparator.compare(false, false));
+ assertFalse(Comparator.compare(true, false));
+ }
+
+ @Test
+ @DisplayName("strings: exact match")
+ void testStrings() {
+ assertTrue(Comparator.compare("hello", "hello"));
+ assertTrue(Comparator.compare("", ""));
+ assertFalse(Comparator.compare("hello", "world"));
+ }
+
+ @Test
+ @DisplayName("characters: exact match")
+ void testCharacters() {
+ assertTrue(Comparator.compare('a', 'a'));
+ assertFalse(Comparator.compare('a', 'b'));
+ }
+ }
+
+ @Nested
+ @DisplayName("Null Handling")
+ class NullTests {
+
+ @Test
+ @DisplayName("both null: should be equal")
+ void testBothNull() {
+ assertTrue(Comparator.compare(null, null));
+ }
+
+ @Test
+ @DisplayName("one null: should not be equal")
+ void testOneNull() {
+ assertFalse(Comparator.compare(null, "value"));
+ assertFalse(Comparator.compare("value", null));
+ }
+ }
+
+ @Nested
+ @DisplayName("Collection Comparison")
+ class CollectionTests {
+
+ @Test
+ @DisplayName("lists: order matters")
+ void testLists() {
+ List list1 = Arrays.asList(1, 2, 3);
+ List list2 = Arrays.asList(1, 2, 3);
+ List list3 = Arrays.asList(3, 2, 1);
+
+ assertTrue(Comparator.compare(list1, list2));
+ assertFalse(Comparator.compare(list1, list3));
+ }
+
+ @Test
+ @DisplayName("lists: different sizes")
+ void testListsDifferentSizes() {
+ List list1 = Arrays.asList(1, 2, 3);
+ List list2 = Arrays.asList(1, 2);
+
+ assertFalse(Comparator.compare(list1, list2));
+ }
+
+ @Test
+ @DisplayName("sets: order doesn't matter")
+ void testSets() {
+ Set set1 = new HashSet<>(Arrays.asList(1, 2, 3));
+ Set set2 = new HashSet<>(Arrays.asList(3, 2, 1));
+
+ assertTrue(Comparator.compare(set1, set2));
+ }
+
+ @Test
+ @DisplayName("sets: different contents")
+ void testSetsDifferentContents() {
+ Set set1 = new HashSet<>(Arrays.asList(1, 2, 3));
+ Set set2 = new HashSet<>(Arrays.asList(1, 2, 4));
+
+ assertFalse(Comparator.compare(set1, set2));
+ }
+
+ @Test
+ @DisplayName("empty collections: should be equal")
+ void testEmptyCollections() {
+ assertTrue(Comparator.compare(new ArrayList<>(), new ArrayList<>()));
+ assertTrue(Comparator.compare(new HashSet<>(), new HashSet<>()));
+ }
+
+ @Test
+ @DisplayName("nested collections")
+ void testNestedCollections() {
+ List> nested1 = Arrays.asList(
+ Arrays.asList(1, 2),
+ Arrays.asList(3, 4)
+ );
+ List> nested2 = Arrays.asList(
+ Arrays.asList(1, 2),
+ Arrays.asList(3, 4)
+ );
+
+ assertTrue(Comparator.compare(nested1, nested2));
+ }
+ }
+
+ @Nested
+ @DisplayName("Map Comparison")
+ class MapTests {
+
+ @Test
+ @DisplayName("maps: same contents")
+ void testMaps() {
+ Map map1 = new HashMap<>();
+ map1.put("one", 1);
+ map1.put("two", 2);
+
+ Map map2 = new HashMap<>();
+ map2.put("two", 2);
+ map2.put("one", 1);
+
+ assertTrue(Comparator.compare(map1, map2));
+ }
+
+ @Test
+ @DisplayName("maps: different values")
+ void testMapsDifferentValues() {
+ Map map1 = Map.of("key", 1);
+ Map map2 = Map.of("key", 2);
+
+ assertFalse(Comparator.compare(map1, map2));
+ }
+
+ @Test
+ @DisplayName("maps: different keys")
+ void testMapsDifferentKeys() {
+ Map map1 = Map.of("key1", 1);
+ Map map2 = Map.of("key2", 1);
+
+ assertFalse(Comparator.compare(map1, map2));
+ }
+
+ @Test
+ @DisplayName("maps: different sizes")
+ void testMapsDifferentSizes() {
+ Map map1 = Map.of("one", 1, "two", 2);
+ Map map2 = Map.of("one", 1);
+
+ assertFalse(Comparator.compare(map1, map2));
+ }
+
+ @Test
+ @DisplayName("nested maps")
+ void testNestedMaps() {
+ Map map1 = new HashMap<>();
+ map1.put("inner", Map.of("key", "value"));
+
+ Map map2 = new HashMap<>();
+ map2.put("inner", Map.of("key", "value"));
+
+ assertTrue(Comparator.compare(map1, map2));
+ }
+ }
+
+ @Nested
+ @DisplayName("Array Comparison")
+ class ArrayTests {
+
+ @Test
+ @DisplayName("int arrays: element-wise comparison")
+ void testIntArrays() {
+ int[] arr1 = {1, 2, 3};
+ int[] arr2 = {1, 2, 3};
+ int[] arr3 = {1, 2, 4};
+
+ assertTrue(Comparator.compare(arr1, arr2));
+ assertFalse(Comparator.compare(arr1, arr3));
+ }
+
+ @Test
+ @DisplayName("object arrays: element-wise comparison")
+ void testObjectArrays() {
+ String[] arr1 = {"a", "b", "c"};
+ String[] arr2 = {"a", "b", "c"};
+
+ assertTrue(Comparator.compare(arr1, arr2));
+ }
+
+ @Test
+ @DisplayName("arrays: different lengths")
+ void testArraysDifferentLengths() {
+ int[] arr1 = {1, 2, 3};
+ int[] arr2 = {1, 2};
+
+ assertFalse(Comparator.compare(arr1, arr2));
+ }
+ }
+
+ @Nested
+ @DisplayName("Exception Comparison")
+ class ExceptionTests {
+
+ @Test
+ @DisplayName("same exception type and message: equal")
+ void testSameException() {
+ Exception e1 = new IllegalArgumentException("test");
+ Exception e2 = new IllegalArgumentException("test");
+
+ assertTrue(Comparator.compare(e1, e2));
+ }
+
+ @Test
+ @DisplayName("different exception types: not equal")
+ void testDifferentExceptionTypes() {
+ Exception e1 = new IllegalArgumentException("test");
+ Exception e2 = new IllegalStateException("test");
+
+ assertFalse(Comparator.compare(e1, e2));
+ }
+
+ @Test
+ @DisplayName("different messages: not equal")
+ void testDifferentMessages() {
+ Exception e1 = new RuntimeException("message 1");
+ Exception e2 = new RuntimeException("message 2");
+
+ assertFalse(Comparator.compare(e1, e2));
+ }
+
+ @Test
+ @DisplayName("both null messages: equal")
+ void testBothNullMessages() {
+ Exception e1 = new RuntimeException((String) null);
+ Exception e2 = new RuntimeException((String) null);
+
+ assertTrue(Comparator.compare(e1, e2));
+ }
+ }
+
+ @Nested
+ @DisplayName("Placeholder Rejection")
+ class PlaceholderTests {
+
+ @Test
+ @DisplayName("original contains placeholder: throws exception")
+ void testOriginalPlaceholder() {
+ KryoPlaceholder placeholder = new KryoPlaceholder(
+ "java.net.Socket", "", "error", "path"
+ );
+
+ assertThrows(KryoPlaceholderAccessException.class, () -> {
+ Comparator.compare(placeholder, "anything");
+ });
+ }
+
+ @Test
+ @DisplayName("new contains placeholder: throws exception")
+ void testNewPlaceholder() {
+ KryoPlaceholder placeholder = new KryoPlaceholder(
+ "java.net.Socket", "", "error", "path"
+ );
+
+ assertThrows(KryoPlaceholderAccessException.class, () -> {
+ Comparator.compare("anything", placeholder);
+ });
+ }
+
+ @Test
+ @DisplayName("placeholder in nested structure: throws exception")
+ void testNestedPlaceholder() {
+ KryoPlaceholder placeholder = new KryoPlaceholder(
+ "java.net.Socket", "", "error", "data.socket"
+ );
+
+ Map map1 = new HashMap<>();
+ map1.put("socket", placeholder);
+
+ Map map2 = new HashMap<>();
+ map2.put("socket", "different");
+
+ assertThrows(KryoPlaceholderAccessException.class, () -> {
+ Comparator.compare(map1, map2);
+ });
+ }
+
+ @Test
+ @DisplayName("compareWithDetails captures error message")
+ void testCompareWithDetails() {
+ KryoPlaceholder placeholder = new KryoPlaceholder(
+ "java.net.Socket", "", "error", "path"
+ );
+
+ Comparator.ComparisonResult result =
+ Comparator.compareWithDetails(placeholder, "anything");
+
+ assertFalse(result.isEqual());
+ assertTrue(result.hasError());
+ assertNotNull(result.getErrorMessage());
+ }
+ }
+
+ @Nested
+ @DisplayName("Custom Objects")
+ class CustomObjectTests {
+
+ @Test
+ @DisplayName("objects with same field values: equal")
+ void testSameFields() {
+ TestObj obj1 = new TestObj("name", 42);
+ TestObj obj2 = new TestObj("name", 42);
+
+ assertTrue(Comparator.compare(obj1, obj2));
+ }
+
+ @Test
+ @DisplayName("objects with different field values: not equal")
+ void testDifferentFields() {
+ TestObj obj1 = new TestObj("name", 42);
+ TestObj obj2 = new TestObj("name", 43);
+
+ assertFalse(Comparator.compare(obj1, obj2));
+ }
+
+ @Test
+ @DisplayName("nested objects")
+ void testNestedObjects() {
+ TestNested nested1 = new TestNested(new TestObj("inner", 1));
+ TestNested nested2 = new TestNested(new TestObj("inner", 1));
+
+ assertTrue(Comparator.compare(nested1, nested2));
+ }
+ }
+
+ @Nested
+ @DisplayName("Type Compatibility")
+ class TypeCompatibilityTests {
+
+ @Test
+ @DisplayName("different list implementations: compatible")
+ void testDifferentListTypes() {
+ List arrayList = new ArrayList<>(Arrays.asList(1, 2, 3));
+ List linkedList = new LinkedList<>(Arrays.asList(1, 2, 3));
+
+ assertTrue(Comparator.compare(arrayList, linkedList));
+ }
+
+ @Test
+ @DisplayName("different map implementations: compatible")
+ void testDifferentMapTypes() {
+ Map hashMap = new HashMap<>();
+ hashMap.put("key", 1);
+
+ Map linkedHashMap = new LinkedHashMap<>();
+ linkedHashMap.put("key", 1);
+
+ assertTrue(Comparator.compare(hashMap, linkedHashMap));
+ }
+
+ @Test
+ @DisplayName("incompatible types: not equal")
+ void testIncompatibleTypes() {
+ assertFalse(Comparator.compare("string", 42));
+ assertFalse(Comparator.compare(new ArrayList<>(), new HashMap<>()));
+ }
+ }
+
+ @Nested
+ @DisplayName("Optional Comparison")
+ class OptionalTests {
+
+ @Test
+ @DisplayName("both empty: equal")
+ void testBothEmpty() {
+ assertTrue(Comparator.compare(Optional.empty(), Optional.empty()));
+ }
+
+ @Test
+ @DisplayName("both present with same value: equal")
+ void testBothPresentSame() {
+ assertTrue(Comparator.compare(Optional.of("value"), Optional.of("value")));
+ }
+
+ @Test
+ @DisplayName("one empty, one present: not equal")
+ void testOneEmpty() {
+ assertFalse(Comparator.compare(Optional.empty(), Optional.of("value")));
+ assertFalse(Comparator.compare(Optional.of("value"), Optional.empty()));
+ }
+
+ @Test
+ @DisplayName("both present with different values: not equal")
+ void testDifferentValues() {
+ assertFalse(Comparator.compare(Optional.of("a"), Optional.of("b")));
+ }
+ }
+
+ @Nested
+ @DisplayName("Enum Comparison")
+ class EnumTests {
+
+ @Test
+ @DisplayName("same enum values: equal")
+ void testSameEnum() {
+ assertTrue(Comparator.compare(TestEnum.A, TestEnum.A));
+ }
+
+ @Test
+ @DisplayName("different enum values: not equal")
+ void testDifferentEnum() {
+ assertFalse(Comparator.compare(TestEnum.A, TestEnum.B));
+ }
+ }
+
+ // Test helper classes
+
+ static class TestObj {
+ String name;
+ int value;
+
+ TestObj(String name, int value) {
+ this.name = name;
+ this.value = value;
+ }
+ }
+
+ static class TestNested {
+ TestObj inner;
+
+ TestNested(TestObj inner) {
+ this.inner = inner;
+ }
+ }
+
+ enum TestEnum {
+ A, B, C
+ }
+}
diff --git a/codeflash-java-runtime/src/test/java/com/codeflash/KryoPlaceholderTest.java b/codeflash-java-runtime/src/test/java/com/codeflash/KryoPlaceholderTest.java
new file mode 100644
index 000000000..f874356e2
--- /dev/null
+++ b/codeflash-java-runtime/src/test/java/com/codeflash/KryoPlaceholderTest.java
@@ -0,0 +1,179 @@
+package com.codeflash;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+/**
+ * Tests for KryoPlaceholder class.
+ */
+@DisplayName("KryoPlaceholder Tests")
+class KryoPlaceholderTest {
+
+ @Nested
+ @DisplayName("Metadata Storage")
+ class MetadataTests {
+
+ @Test
+ @DisplayName("should store all metadata correctly")
+ void testMetadataStorage() {
+ KryoPlaceholder placeholder = new KryoPlaceholder(
+ "java.net.Socket",
+ "",
+ "Cannot serialize socket",
+ "data.connection.socket"
+ );
+
+ assertEquals("java.net.Socket", placeholder.getObjType());
+ assertEquals("", placeholder.getObjStr());
+ assertEquals("Cannot serialize socket", placeholder.getErrorMsg());
+ assertEquals("data.connection.socket", placeholder.getPath());
+ }
+
+ @Test
+ @DisplayName("should truncate long string representations")
+ void testStringTruncation() {
+ String longStr = "x".repeat(200);
+ KryoPlaceholder placeholder = new KryoPlaceholder(
+ "SomeType", longStr, "error", "path"
+ );
+
+ assertTrue(placeholder.getObjStr().length() <= 103); // 100 + "..."
+ assertTrue(placeholder.getObjStr().endsWith("..."));
+ }
+
+ @Test
+ @DisplayName("should handle null string representation")
+ void testNullStringRepresentation() {
+ KryoPlaceholder placeholder = new KryoPlaceholder(
+ "SomeType", null, "error", "path"
+ );
+
+ assertNull(placeholder.getObjStr());
+ }
+ }
+
+ @Nested
+ @DisplayName("Factory Method")
+ class FactoryTests {
+
+ @Test
+ @DisplayName("should create placeholder from object")
+ void testCreateFromObject() {
+ Object obj = new StringBuilder("test");
+ KryoPlaceholder placeholder = KryoPlaceholder.create(
+ obj, "Cannot serialize", "root"
+ );
+
+ assertEquals("java.lang.StringBuilder", placeholder.getObjType());
+ assertEquals("test", placeholder.getObjStr());
+ assertEquals("Cannot serialize", placeholder.getErrorMsg());
+ assertEquals("root", placeholder.getPath());
+ }
+
+ @Test
+ @DisplayName("should handle null object")
+ void testCreateFromNull() {
+ KryoPlaceholder placeholder = KryoPlaceholder.create(
+ null, "Null object", "path"
+ );
+
+ assertEquals("null", placeholder.getObjType());
+ assertEquals("null", placeholder.getObjStr());
+ }
+
+ @Test
+ @DisplayName("should handle object with failing toString")
+ void testCreateFromObjectWithBadToString() {
+ Object badObj = new Object() {
+ @Override
+ public String toString() {
+ throw new RuntimeException("toString failed!");
+ }
+ };
+
+ KryoPlaceholder placeholder = KryoPlaceholder.create(
+ badObj, "error", "path"
+ );
+
+ assertTrue(placeholder.getObjStr().contains("toString failed"));
+ }
+ }
+
+ @Nested
+ @DisplayName("Serialization")
+ class SerializationTests {
+
+ @Test
+ @DisplayName("placeholder should be serializable itself")
+ void testPlaceholderSerializable() {
+ KryoPlaceholder original = new KryoPlaceholder(
+ "java.net.Socket",
+ "",
+ "Cannot serialize socket",
+ "data.socket"
+ );
+
+ // Serialize and deserialize the placeholder
+ byte[] serialized = Serializer.serialize(original);
+ assertNotNull(serialized);
+ assertTrue(serialized.length > 0);
+
+ Object deserialized = Serializer.deserialize(serialized);
+ assertInstanceOf(KryoPlaceholder.class, deserialized);
+
+ KryoPlaceholder restored = (KryoPlaceholder) deserialized;
+ assertEquals(original.getObjType(), restored.getObjType());
+ assertEquals(original.getObjStr(), restored.getObjStr());
+ assertEquals(original.getErrorMsg(), restored.getErrorMsg());
+ assertEquals(original.getPath(), restored.getPath());
+ }
+ }
+
+ @Nested
+ @DisplayName("toString")
+ class ToStringTests {
+
+ @Test
+ @DisplayName("should produce readable toString")
+ void testToString() {
+ KryoPlaceholder placeholder = new KryoPlaceholder(
+ "java.net.Socket",
+ "",
+ "error",
+ "data.socket"
+ );
+
+ String str = placeholder.toString();
+ assertTrue(str.contains("KryoPlaceholder"));
+ assertTrue(str.contains("java.net.Socket"));
+ assertTrue(str.contains("data.socket"));
+ }
+ }
+
+ @Nested
+ @DisplayName("Equality")
+ class EqualityTests {
+
+ @Test
+ @DisplayName("placeholders with same type and path should be equal")
+ void testEquality() {
+ KryoPlaceholder p1 = new KryoPlaceholder("Type", "str1", "error1", "path");
+ KryoPlaceholder p2 = new KryoPlaceholder("Type", "str2", "error2", "path");
+
+ assertEquals(p1, p2);
+ assertEquals(p1.hashCode(), p2.hashCode());
+ }
+
+ @Test
+ @DisplayName("placeholders with different paths should not be equal")
+ void testInequality() {
+ KryoPlaceholder p1 = new KryoPlaceholder("Type", "str", "error", "path1");
+ KryoPlaceholder p2 = new KryoPlaceholder("Type", "str", "error", "path2");
+
+ assertNotEquals(p1, p2);
+ }
+ }
+}
diff --git a/codeflash-java-runtime/src/test/java/com/codeflash/SerializerEdgeCaseTest.java b/codeflash-java-runtime/src/test/java/com/codeflash/SerializerEdgeCaseTest.java
new file mode 100644
index 000000000..86411e7c2
--- /dev/null
+++ b/codeflash-java-runtime/src/test/java/com/codeflash/SerializerEdgeCaseTest.java
@@ -0,0 +1,804 @@
+package com.codeflash;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.time.*;
+import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+/**
+ * Edge case tests for Serializer to ensure robust serialization.
+ */
+@DisplayName("Serializer Edge Case Tests")
+class SerializerEdgeCaseTest {
+
+ @BeforeEach
+ void setUp() {
+ Serializer.clearUnserializableTypesCache();
+ }
+
+ // ============================================================
+ // NUMBER EDGE CASES
+ // ============================================================
+
+ @Nested
+ @DisplayName("Number Serialization")
+ class NumberSerialization {
+
+ @Test
+ @DisplayName("BigDecimal roundtrip")
+ void testBigDecimalRoundtrip() {
+ BigDecimal original = new BigDecimal("123456789.123456789012345678901234567890");
+
+ byte[] serialized = Serializer.serialize(original);
+ Object deserialized = Serializer.deserialize(serialized);
+
+ assertTrue(Comparator.compare(original, deserialized),
+ "BigDecimal should survive roundtrip");
+ }
+
+ @Test
+ @DisplayName("BigInteger roundtrip")
+ void testBigIntegerRoundtrip() {
+ BigInteger original = new BigInteger("123456789012345678901234567890123456789012345678901234567890");
+
+ byte[] serialized = Serializer.serialize(original);
+ Object deserialized = Serializer.deserialize(serialized);
+
+ assertTrue(Comparator.compare(original, deserialized),
+ "BigInteger should survive roundtrip");
+ }
+
+ @Test
+ @DisplayName("AtomicInteger - known limitation, becomes Map")
+ void testAtomicIntegerLimitation() {
+ // AtomicInteger uses Unsafe internally, which causes issues with reflection-based serialization
+ // This documents the limitation - atomic types may not roundtrip perfectly
+ AtomicInteger original = new AtomicInteger(42);
+
+ byte[] serialized = Serializer.serialize(original);
+ Object deserialized = Serializer.deserialize(serialized);
+
+ // Currently becomes a Map due to internal Unsafe usage
+ // This is a known limitation for JDK atomic types
+ assertNotNull(deserialized);
+ }
+
+ @Test
+ @DisplayName("Special double values")
+ void testSpecialDoubleValues() {
+ double[] values = {Double.NaN, Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY, -0.0, Double.MIN_VALUE, Double.MAX_VALUE};
+
+ for (double value : values) {
+ byte[] serialized = Serializer.serialize(value);
+ Object deserialized = Serializer.deserialize(serialized);
+
+ assertTrue(Comparator.compare(value, deserialized),
+ "Failed for value: " + value);
+ }
+ }
+ }
+
+ // ============================================================
+ // DATE/TIME EDGE CASES
+ // ============================================================
+
+ @Nested
+ @DisplayName("Date/Time Serialization")
+ class DateTimeSerialization {
+
+ @Test
+ @DisplayName("All Java 8 time types")
+ void testJava8TimeTypes() {
+ Object[] timeObjects = {
+ LocalDate.of(2024, 1, 15),
+ LocalTime.of(10, 30, 45),
+ LocalDateTime.of(2024, 1, 15, 10, 30, 45),
+ Instant.now(),
+ Duration.ofHours(5),
+ Period.ofMonths(3),
+ ZonedDateTime.now(),
+ OffsetDateTime.now(),
+ OffsetTime.now(),
+ Year.of(2024),
+ YearMonth.of(2024, 1),
+ MonthDay.of(1, 15)
+ };
+
+ for (Object original : timeObjects) {
+ byte[] serialized = Serializer.serialize(original);
+ Object deserialized = Serializer.deserialize(serialized);
+
+ assertTrue(Comparator.compare(original, deserialized),
+ "Failed for type: " + original.getClass().getSimpleName());
+ }
+ }
+
+ @Test
+ @DisplayName("Legacy Date types")
+ void testLegacyDateTypes() {
+ Date date = new Date();
+ Calendar calendar = Calendar.getInstance();
+
+ byte[] serializedDate = Serializer.serialize(date);
+ Object deserializedDate = Serializer.deserialize(serializedDate);
+ assertTrue(Comparator.compare(date, deserializedDate));
+
+ byte[] serializedCal = Serializer.serialize(calendar);
+ Object deserializedCal = Serializer.deserialize(serializedCal);
+ assertInstanceOf(Calendar.class, deserializedCal);
+ }
+ }
+
+ // ============================================================
+ // COLLECTION EDGE CASES
+ // ============================================================
+
+ @Nested
+ @DisplayName("Collection Edge Cases")
+ class CollectionEdgeCases {
+
+ @Test
+ @DisplayName("Empty collections")
+ void testEmptyCollections() {
+ Collection[] empties = {
+ new ArrayList<>(),
+ new LinkedList<>(),
+ new HashSet<>(),
+ new TreeSet<>(),
+ new LinkedHashSet<>()
+ };
+
+ for (Collection original : empties) {
+ byte[] serialized = Serializer.serialize(original);
+ Object deserialized = Serializer.deserialize(serialized);
+
+ assertEquals(original.getClass(), deserialized.getClass(),
+ "Type should be preserved for: " + original.getClass().getSimpleName());
+ assertTrue(((Collection) deserialized).isEmpty());
+ }
+ }
+
+ @Test
+ @DisplayName("Empty maps")
+ void testEmptyMaps() {
+ Map[] empties = {
+ new HashMap<>(),
+ new LinkedHashMap<>(),
+ new TreeMap<>()
+ };
+
+ for (Map original : empties) {
+ byte[] serialized = Serializer.serialize(original);
+ Object deserialized = Serializer.deserialize(serialized);
+
+ assertEquals(original.getClass(), deserialized.getClass());
+ assertTrue(((Map) deserialized).isEmpty());
+ }
+ }
+
+ @Test
+ @DisplayName("Collections with null elements")
+ void testCollectionsWithNulls() {
+ List list = new ArrayList<>();
+ list.add("a");
+ list.add(null);
+ list.add("c");
+
+ byte[] serialized = Serializer.serialize(list);
+ List deserialized = (List) Serializer.deserialize(serialized);
+
+ assertEquals(3, deserialized.size());
+ assertEquals("a", deserialized.get(0));
+ assertNull(deserialized.get(1));
+ assertEquals("c", deserialized.get(2));
+ }
+
+ @Test
+ @DisplayName("Map with null key and value")
+ void testMapWithNulls() {
+ Map map = new HashMap<>();
+ map.put(null, "nullKey");
+ map.put("nullValue", null);
+ map.put("normal", "value");
+
+ byte[] serialized = Serializer.serialize(map);
+ Map deserialized = (Map) Serializer.deserialize(serialized);
+
+ assertEquals(3, deserialized.size());
+ assertEquals("nullKey", deserialized.get(null));
+ assertNull(deserialized.get("nullValue"));
+ assertEquals("value", deserialized.get("normal"));
+ }
+
+ @Test
+ @DisplayName("ConcurrentHashMap roundtrip")
+ void testConcurrentHashMap() {
+ ConcurrentHashMap original = new ConcurrentHashMap<>();
+ original.put("a", 1);
+ original.put("b", 2);
+
+ byte[] serialized = Serializer.serialize(original);
+ Object deserialized = Serializer.deserialize(serialized);
+
+ assertInstanceOf(ConcurrentHashMap.class, deserialized);
+ assertTrue(Comparator.compare(original, deserialized));
+ }
+
+ @Test
+ @DisplayName("EnumSet and EnumMap")
+ void testEnumCollections() {
+ EnumSet enumSet = EnumSet.of(DayOfWeek.MONDAY, DayOfWeek.FRIDAY);
+ EnumMap enumMap = new EnumMap<>(DayOfWeek.class);
+ enumMap.put(DayOfWeek.MONDAY, "Start");
+ enumMap.put(DayOfWeek.FRIDAY, "End");
+
+ byte[] serializedSet = Serializer.serialize(enumSet);
+ Object deserializedSet = Serializer.deserialize(serializedSet);
+ assertTrue(Comparator.compare(enumSet, deserializedSet));
+
+ byte[] serializedMap = Serializer.serialize(enumMap);
+ Object deserializedMap = Serializer.deserialize(serializedMap);
+ assertTrue(Comparator.compare(enumMap, deserializedMap));
+ }
+ }
+
+ // ============================================================
+ // ARRAY EDGE CASES
+ // ============================================================
+
+ @Nested
+ @DisplayName("Array Edge Cases")
+ class ArrayEdgeCases {
+
+ @Test
+ @DisplayName("Empty arrays of various types")
+ void testEmptyArrays() {
+ Object[] empties = {
+ new int[0],
+ new String[0],
+ new Object[0],
+ new double[0]
+ };
+
+ for (Object original : empties) {
+ byte[] serialized = Serializer.serialize(original);
+ Object deserialized = Serializer.deserialize(serialized);
+
+ assertEquals(original.getClass(), deserialized.getClass());
+ assertEquals(0, java.lang.reflect.Array.getLength(deserialized));
+ }
+ }
+
+ @Test
+ @DisplayName("Multi-dimensional arrays")
+ void testMultiDimensionalArrays() {
+ int[][][] original = {{{1, 2}, {3, 4}}, {{5, 6}, {7, 8}}};
+
+ byte[] serialized = Serializer.serialize(original);
+ Object deserialized = Serializer.deserialize(serialized);
+
+ assertTrue(Comparator.compare(original, deserialized));
+ }
+
+ @Test
+ @DisplayName("Array with all nulls")
+ void testArrayWithAllNulls() {
+ String[] original = new String[3]; // All null
+
+ byte[] serialized = Serializer.serialize(original);
+ String[] deserialized = (String[]) Serializer.deserialize(serialized);
+
+ assertEquals(3, deserialized.length);
+ assertNull(deserialized[0]);
+ assertNull(deserialized[1]);
+ assertNull(deserialized[2]);
+ }
+ }
+
+ // ============================================================
+ // SPECIAL TYPES
+ // ============================================================
+
+ @Nested
+ @DisplayName("Special Types")
+ class SpecialTypes {
+
+ @Test
+ @DisplayName("UUID roundtrip")
+ void testUUIDRoundtrip() {
+ UUID original = UUID.randomUUID();
+
+ byte[] serialized = Serializer.serialize(original);
+ Object deserialized = Serializer.deserialize(serialized);
+
+ assertEquals(original, deserialized);
+ }
+
+ @Test
+ @DisplayName("Currency roundtrip")
+ void testCurrencyRoundtrip() {
+ Currency original = Currency.getInstance("USD");
+
+ byte[] serialized = Serializer.serialize(original);
+ Object deserialized = Serializer.deserialize(serialized);
+
+ assertEquals(original, deserialized);
+ }
+
+ @Test
+ @DisplayName("Locale roundtrip")
+ void testLocaleRoundtrip() {
+ Locale original = Locale.US;
+
+ byte[] serialized = Serializer.serialize(original);
+ Object deserialized = Serializer.deserialize(serialized);
+
+ assertEquals(original, deserialized);
+ }
+
+ @Test
+ @DisplayName("Optional roundtrip")
+ void testOptionalRoundtrip() {
+ Optional present = Optional.of("value");
+ Optional empty = Optional.empty();
+
+ byte[] serializedPresent = Serializer.serialize(present);
+ Object deserializedPresent = Serializer.deserialize(serializedPresent);
+ assertTrue(Comparator.compare(present, deserializedPresent));
+
+ byte[] serializedEmpty = Serializer.serialize(empty);
+ Object deserializedEmpty = Serializer.deserialize(serializedEmpty);
+ assertTrue(Comparator.compare(empty, deserializedEmpty));
+ }
+ }
+
+ // ============================================================
+ // COMPLEX NESTED STRUCTURES
+ // ============================================================
+
+ @Nested
+ @DisplayName("Complex Nested Structures")
+ class ComplexNested {
+
+ @Test
+ @DisplayName("Deeply nested maps and lists")
+ void testDeeplyNestedStructure() {
+ Map root = new LinkedHashMap<>();
+ root.put("level1", createNestedStructure(8));
+
+ byte[] serialized = Serializer.serialize(root);
+ Object deserialized = Serializer.deserialize(serialized);
+
+ assertTrue(Comparator.compare(root, deserialized));
+ }
+
+ private Map createNestedStructure(int depth) {
+ if (depth == 0) {
+ Map leaf = new LinkedHashMap<>();
+ leaf.put("value", "leaf");
+ return leaf;
+ }
+ Map map = new LinkedHashMap<>();
+ map.put("nested", createNestedStructure(depth - 1));
+ map.put("list", Arrays.asList(1, 2, 3));
+ return map;
+ }
+
+ @Test
+ @DisplayName("Mixed collection types")
+ void testMixedCollectionTypes() {
+ Map mixed = new LinkedHashMap<>();
+ mixed.put("list", Arrays.asList(1, 2, 3));
+ mixed.put("set", new LinkedHashSet<>(Arrays.asList("a", "b", "c")));
+ mixed.put("map", Map.of("key", "value"));
+ mixed.put("array", new int[]{1, 2, 3});
+
+ byte[] serialized = Serializer.serialize(mixed);
+ Object deserialized = Serializer.deserialize(serialized);
+
+ assertTrue(Comparator.compare(mixed, deserialized));
+ }
+ }
+
+ // ============================================================
+ // SERIALIZER LIMITS AND BOUNDARIES
+ // ============================================================
+
+ @Nested
+ @DisplayName("Serializer Limits and Boundaries")
+ class SerializerLimitsTests {
+
+ @Test
+ @DisplayName("Collection with exactly MAX_COLLECTION_SIZE (1000) elements")
+ void testCollectionAtMaxSize() {
+ List list = new ArrayList<>();
+ for (int i = 0; i < 1000; i++) {
+ list.add(i);
+ }
+
+ byte[] serialized = Serializer.serialize(list);
+ List deserialized = (List) Serializer.deserialize(serialized);
+
+ assertEquals(1000, deserialized.size(),
+ "Collection at exactly MAX_COLLECTION_SIZE should not be truncated");
+ assertTrue(Comparator.compare(list, deserialized));
+ }
+
+ @Test
+ @DisplayName("Collection exceeding MAX_COLLECTION_SIZE gets truncated with placeholder")
+ void testCollectionExceedsMaxSize() {
+ // Create list with unserializable object to trigger recursive processing
+ List