fix: update test assertions to match simplified Workload fixture

The Workload.java fixture was trimmed to only repeatString but test
files still asserted computeSum, filterEvens, and instanceMethod.

Author: KRRT7

tests/test_languages/test_java/test_java_tracer_e2e.py

@@ -81,14 +81,11 @@ def test_agent_captures_invocations(self, compiled_workload: Path, trace_db: Pat
         conn = sqlite3.connect(str(trace_db))
         try:
             rows = conn.execute("SELECT function, classname, descriptor, length(args) FROM function_calls").fetchall()
-            assert len(rows) >= 5, f"Expected at least 5 captured invocations, got {len(rows)}"
+            assert len(rows) >= 2, f"Expected at least 2 captured invocations, got {len(rows)}"
 
             # Check that specific methods were captured
             functions = {row[0] for row in rows}
-            assert "computeSum" in functions
             assert "repeatString" in functions
-            assert "filterEvens" in functions
-            assert "instanceMethod" in functions
 
             # Verify all rows have non-empty args blobs
             for row in rows:
@@ -97,7 +94,7 @@ def test_agent_captures_invocations(self, compiled_workload: Path, trace_db: Pat
             # Verify metadata
             metadata = dict(conn.execute("SELECT key, value FROM metadata").fetchall())
             assert "totalCaptures" in metadata
-            assert int(metadata["totalCaptures"]) >= 5
+            assert int(metadata["totalCaptures"]) >= 2
         finally:
             conn.close()
 
@@ -136,11 +133,11 @@ def test_max_function_count_limit(self, compiled_workload: Path, trace_db: Path)
 
         conn = sqlite3.connect(str(trace_db))
         try:
-            # computeSum is called 4 times (2 direct + 2 from instanceMethod)
-            compute_count = conn.execute(
-                "SELECT COUNT(*) FROM function_calls WHERE function = 'computeSum'"
+            # repeatString is called 1000+ times; with maxFunctionCount=2, at most 2 should be captured
+            repeat_count = conn.execute(
+                "SELECT COUNT(*) FROM function_calls WHERE function = 'repeatString'"
             ).fetchone()[0]
-            assert compute_count <= 2, f"Expected at most 2 computeSum captures, got {compute_count}"
+            assert repeat_count <= 2, f"Expected at most 2 repeatString captures, got {repeat_count}"
         finally:
             conn.close()
 
@@ -198,7 +195,6 @@ def test_generates_test_files(self, compiled_workload: Path, trace_db: Path, tmp
         assert "package codeflash.replay;" in content
         assert "import org.junit.jupiter.api.Test;" in content
         assert "ReplayHelper" in content
-        assert "replay_computeSum_0" in content
         assert "replay_repeatString_0" in content
 
     def test_metadata_parsing(self, compiled_workload: Path, trace_db: Path, tmp_path: Path) -> None:
@@ -243,7 +239,7 @@ def test_metadata_parsing(self, compiled_workload: Path, trace_db: Path, tmp_pat
         assert "functions" in metadata
         assert "trace_file" in metadata
         assert "classname" in metadata
-        assert "computeSum" in metadata["functions"]
+        assert "repeatString" in metadata["functions"]
         assert metadata["classname"] == "com.example.Workload"
         assert metadata["trace_file"] == trace_db.as_posix()
 
@@ -267,7 +263,7 @@ def test_two_stage_trace(self, compiled_workload: Path, tmp_path: Path) -> None:
         conn = sqlite3.connect(str(trace_db))
         try:
             count = conn.execute("SELECT COUNT(*) FROM function_calls").fetchone()[0]
-            assert count >= 5, f"Expected at least 5 captured invocations, got {count}"
+            assert count >= 2, f"Expected at least 2 captured invocations, got {count}"
         finally:
             conn.close()
 
@@ -295,8 +291,7 @@ def test_full_trace_and_replay_generation(self, compiled_workload: Path, tmp_pat
         workload_files = [f for f in test_files if "Workload" in f.name and "ConstructorAccess" not in f.name]
         assert len(workload_files) == 1
         content = workload_files[0].read_text(encoding="utf-8")
-        assert "replay_computeSum" in content
-        assert "replay_instanceMethod" in content
+        assert "replay_repeatString" in content
 
     def test_package_detection(self) -> None:
         """Test that package detection finds Java packages from source files."""

tests/test_languages/test_java/test_java_tracer_integration.py

@@ -87,7 +87,6 @@ def test_discover_functions_from_replay_tests(self, traced_workload: tuple) -> N
                 assert func.language == "java", f"Expected language='java', got '{func.language}'"
                 assert func.file_path == file_path
 
-        assert "computeSum" in all_func_names
         assert "repeatString" in all_func_names
 
     def test_discover_tests_for_replay_tests(self, traced_workload: tuple) -> None:
@@ -111,7 +110,6 @@ def test_discover_tests_for_replay_tests(self, traced_workload: tuple) -> None:
             func_name = qualified_name.split(".")[-1] if "." in qualified_name else qualified_name
             matched_func_names.add(func_name)
 
-        assert "computeSum" in matched_func_names, f"computeSum not found in: {result.keys()}"
         assert "repeatString" in matched_func_names, f"repeatString not found in: {result.keys()}"
 
         # Each function should have at least one test
@@ -222,8 +220,8 @@ def test_full_pipeline(self, compiled_workload: Path, tmp_path: Path) -> None:
             assert len(function_to_tests) > 0, "No function-to-test mappings"
 
             # Verify function_to_tests has entries for our traced functions
-            has_compute_sum = any("computeSum" in key for key in function_to_tests)
-            assert has_compute_sum, f"computeSum not in function_to_tests keys: {list(function_to_tests.keys())}"
+            has_repeat_string = any("repeatString" in key for key in function_to_tests)
+            assert has_repeat_string, f"repeatString not in function_to_tests keys: {list(function_to_tests.keys())}"
 
             # Step 4: Rank functions (like optimizer.rank_all_functions_globally)
             if jfr_file.exists():
@@ -280,7 +278,7 @@ def test_instrument_and_compile_replay_tests(self, compiled_workload: Path, tmp_
             source_code = WORKLOAD_SOURCE.read_text(encoding="utf-8")
             source_functions = discover_functions_from_source(source_code, file_path=WORKLOAD_SOURCE)
             # Pick the first function with a return type for instrumentation
-            target_func = next(f for f in source_functions if f.function_name == "computeSum")
+            target_func = next(f for f in source_functions if f.function_name == "repeatString")
 
             replay_test_file = replay_test_paths[0]
             test_source = replay_test_file.read_text(encoding="utf-8")