diff --git "a/erfanoabdi--imgpatchtools.1071fec/tests/programgym_task.json" "b/erfanoabdi--imgpatchtools.1071fec/tests/programgym_task.json" new file mode 100644--- /dev/null +++ "b/erfanoabdi--imgpatchtools.1071fec/tests/programgym_task.json" @@ -0,0 +1,2958 @@ +{ + "branches": { + "generated_module_01": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [ + { + "name": "eval.tests.test_diff.TestBSDiff.test_bsdiff_empty_patch_magic_error", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_diff.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_diff.TestBSDiff.test_bsdiff_implausible_magic_error", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_diff.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_diff.TestBSDiff.test_bsdiff_invalid_length_token", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_diff.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_diff.TestBSDiff.test_bsdiff_invalid_offset_token", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_diff.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_diff.TestBSDiff.test_bsdiff_missing_offset_and_length", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_diff.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_diff.TestBSDiff.test_bsdiff_single_offset_token_is_missing_length", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_diff.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_diff.TestDiffInternals.test_diff_failed_command_is_flagged", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_diff.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_diff.TestImgDiff.test_imgdiff_garbage_patch_fails", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_diff.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_diff.TestImgDiff.test_imgdiff_nonpositive_length", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_diff.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_diff.TestImgDiff.test_imgdiff_short_patch_header_error", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_diff.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_diff_success.TestBsDiffSuccess.test_bsdiff_target_reports_written_blocks_when_expected_differs", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_diff_success.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_diff_success.TestDiffRangeSinkHandling.test_bsdiff_shorter_output_reports_underrun", + "reasons": [ + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_diff_success.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_diff_success.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_diff_success.TestDiffVersion3Success.test_v3_diff_with_wrong_target_hash_fails", + "reasons": [ + { + "detail": "AssertionError: assert 'failed to verify blocks' in 'performing update\\ncreating cache dir cache\\ncache dir: cache\\nblockimg version is 3\\nmaximum stash entries 1\\ncreati...pected 2\\nstashed 0 blocks\\", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + }, + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_diff_success.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_diff_success.TestImgDiffSuccess.test_imgdiff_leaves_source_unchanged", + "reasons": [ + { + "detail": "AttributeError: 'TestImgDiffSuccess' object has no attribute '_source'", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_diff_success_v2v3.TestV3TwoHashDiff.test_v3_two_hash_diff_wrong_source_hash_fails", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_diff_success_v2v3.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_errors.TestBlockDeviceMissing.test_missing_image_file_fails_with_errno", + "reasons": [ + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_errors.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_errors.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_errors.TestCommandSequencing.test_stop_at_first_failing_command", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_errors.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_files.TestProgressFile.test_progress_file_contains_set_progress_lines", + "reasons": [ + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_files.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_files.TestProgressFile.test_progress_file_per_command", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_files.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_files.TestProgressFile.test_progress_reports_written_blocks_ratio", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_files.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_load_errors.TestInvalidSrcBlockCount.test_move_bad_src_block_count[-3-2]", + "reasons": [ + { + "detail": "assert 'invalid src_block_count \"-3\"' in '' + where '' = CompletedProcess(args=['/workspace/golden-2/executable', '/tmp/pytest-of-root/pytest-1/popen-gw1/test_move_bad_src_blo...', stderr=\"terminate c", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_load_errors.TestInvalidSrcBlockCount.test_move_bad_src_block_count[-3-3]", + "reasons": [ + { + "detail": "assert 'invalid src_block_count \"-3\"' in 'performing update\\ncreating cache dir cache\\ncache dir: cache\\nblockimg version is 3\\nmaximum stash entries 1\\ncreati...arameters\\nfailed to read blocks for m", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_load_errors.TestInvalidSrcBlockCount.test_move_bad_src_block_count[0x10-2]", + "reasons": [ + { + "detail": "assert 'invalid src_block_count \"0x10\"' in 'performing update\\ncreating cache dir cache\\ncache dir: cache\\nblockimg version is 2\\nmaximum stash entries 1\\ncreati...ected 2\\nstashed 0 blocks\\nmax alloc", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_load_errors.TestInvalidSrcBlockCount.test_move_bad_src_block_count[0x10-3]", + "reasons": [ + { + "detail": "assert 'invalid src_block_count \"0x10\"' in 'performing update\\ncreating cache dir cache\\ncache dir: cache\\nblockimg version is 3\\nmaximum stash entries 1\\ncreati...ameters\\nfailed to read blocks for m", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_load_errors.TestInvalidSrcBlockCount.test_move_bad_src_block_count[1.5-3]", + "reasons": [ + { + "detail": "assert 'invalid src_block_count \"1.5\"' in 'performing update\\ncreating cache dir cache\\ncache dir: cache\\nblockimg version is 3\\nmaximum stash entries 1\\ncreati...rameters\\nfailed to read blocks for m", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_load_errors.TestInvalidSrcBlockCount.test_move_bad_src_block_count[abc-3]", + "reasons": [ + { + "detail": "assert 'invalid src_block_count \"abc\"' in 'performing update\\ncreating cache dir cache\\ncache dir: cache\\nblockimg version is 3\\nmaximum stash entries 1\\ncreati...rameters\\nfailed to read blocks for m", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_load_errors.TestMissingSourceHash.test_v3_bsdiff_offset_len_only", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_load_errors.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_load_errors.TestMissingSourceHash.test_v3_imgdiff_offset_len_only", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_load_errors.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_load_errors.TestMissingSourceHash.test_v3_move_no_tokens", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_load_errors.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_load_errors.TestMissingTargetHash.test_v3_bsdiff_hash_but_no_target_hash", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_load_errors.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_load_errors.TestMissingTargetHash.test_v3_imgdiff_hash_but_no_target_hash", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_load_errors.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_load_errors.TestTooFewLoadTokens.test_v2_single_range_token_is_invalid_parameters[bsdiff]", + "reasons": [ + { + "detail": "AssertionError: assert 'invalid parameters' in 'performing update\\ncreating cache dir cache\\ncache dir: cache\\nblockimg version is 2\\nmaximum stash entries 1\\ncreati...84ba/\\nmissing patch offset or l", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_load_errors.TestTooFewLoadTokens.test_v2_single_range_token_is_invalid_parameters[imgdiff]", + "reasons": [ + { + "detail": "AssertionError: assert 'invalid parameters' in 'performing update\\ncreating cache dir cache\\ncache dir: cache\\nblockimg version is 2\\nmaximum stash entries 1\\ncreati...02/\\nmissing patch offset or len", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_load_errors.TestTooFewLoadTokens.test_v2_two_range_tokens_lack_count[bsdiff]", + "reasons": [ + { + "detail": "AssertionError: assert 'invalid parameters' in 'performing update\\ncreating cache dir cache\\ncache dir: cache\\nblockimg version is 2\\nmaximum stash entries 1\\ncreati...840a508e15dd30c8008/\\ninvalid pa", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_load_errors.TestTooFewLoadTokens.test_v2_two_range_tokens_lack_count[imgdiff]", + "reasons": [ + { + "detail": "AssertionError: assert 'invalid parameters' in 'performing update\\ncreating cache dir cache\\ncache dir: cache\\nblockimg version is 2\\nmaximum stash entries 1\\ncreati...60691b49e6244c8a87/\\ninvalid pat", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_load_errors.TestVersion1Free.test_v1_free_reports_missing_base_error", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_load_errors.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_move.TestMoveVersion1.test_move_missing_arguments_fails", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_move.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_move.TestMoveVersion2Stash.test_move_version2_invalid_parameter", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_move.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_move.TestMoveVersion3Hash.test_move_version3_missing_source_hash", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_move.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_move.TestMoveVersion3Hash.test_move_version3_too_few_lines_still_handled", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_move.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_move.TestMoveVersion3Hash.test_move_version3_wrong_hash_unresumable", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_move.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_new.TestNewCommand.test_new_missing_range_fails", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_new.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_parse_range_extra.TestParseRangeExtraBranches.test_lower_bound_greater_than_upper_rejected", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_parse_range_extra.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_parse_range_extra.TestParseRangeExtraBranches.test_zero_range_pair_among_several_rejected", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_parse_range_extra.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_stash.TestFreeCommand.test_free_missing_id", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_stash.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_stash.TestFreeCommand.test_free_references_stash_id", + "reasons": [ + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_stash.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_stash.TestFreeCommand.test_free_without_prior_stash_then_use_fails_log", + "reasons": [ + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_stash.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_stash.TestVersion3StashHash.test_stash_version3_missing_hash_usage", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_stash.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_stash.TestVersion3StashHash.test_stash_version3_wrong_hash_source", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_stash.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_stash_lifecycle.TestCreateStashExistingDirectory.test_partial_file_is_enumerated_and_unlinked", + "reasons": [ + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_stash_lifecycle.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_stash_lifecycle.TestCreateStashExistingDirectory.test_uses_existing_stash_dir_and_deletes_partial", + "reasons": [ + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_stash_lifecycle.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_stash_lifecycle.TestDeleteStashRmdirFailure.test_rmdir_stash_base_fails_when_subdir_remains", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_stash_lifecycle.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_stash_lifecycle.TestLoadStashDisk.test_load_stash_size_not_multiple_of_block", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_stash_lifecycle.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_stash_lifecycle.TestProgressPartitionLog.test_partition_basename_with_slash_path", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_stash_lifecycle.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_stash_lifecycle.TestV3OverlapRecovery.test_recovery_from_valid_stash_repairs_source", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_stash_lifecycle.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_stash_lifecycle.TestV3OverlapRecovery.test_recovery_skipped_when_stash_verify_fails", + "reasons": [ + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_stash_lifecycle.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_stash_lifecycle.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_usage.test_help_flag_is_treated_as_usage", + "reasons": [ + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_usage.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_usage.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_usage.test_no_arguments_prints_usage", + "reasons": [ + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_usage.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_usage.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_usage.test_one_argument_still_prints_usage", + "reasons": [ + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_usage.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_usage.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_usage.test_three_arguments_still_prints_usage", + "reasons": [ + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_usage.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_usage.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_usage.test_two_arguments_still_prints_usage", + "reasons": [ + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_usage.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_usage.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_usage.test_usage_mentions_all_four_arguments", + "reasons": [ + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_usage.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_version.TestBlockCount.test_negative_block_count_rejected", + "reasons": [ + { + "detail": "AssertionError: assert 'unexpected block count' in 'performing update\\ncreating cache dir cache\\ncache dir: cache\\nblockimg version is 1\\nDone with error code: 100\\n' + where 'performing update\\ncreat", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + }, + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_version.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_version.TestBlockCount.test_non_numeric_block_count_rejected", + "reasons": [ + { + "detail": "AssertionError: assert 'unexpected block count' in 'performing update\\ncreating cache dir cache\\ncache dir: cache\\nblockimg version is 1\\nDone with error code: 100\\n' + where 'performing update\\ncreat", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + }, + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_version.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_version.TestTooFewLines.test_empty_transfer_file", + "reasons": [ + { + "detail": "AssertionError: assert 'too few lines in the transfer list' in 'performing update\\ncreating cache dir cache\\ncache dir: cache\\nDone with error code: 100\\n' + where 'performing update\\ncreating cache d", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + }, + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_version.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_version.TestTooFewLines.test_too_few_lines_aborts[lines0]", + "reasons": [ + { + "detail": "AssertionError: assert 'too few lines in the transfer list' in 'performing update\\ncreating cache dir cache\\ncache dir: cache\\nDone with error code: 100\\n' + where 'performing update\\ncreating cache d", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_version.TestTooFewLines.test_too_few_lines_aborts[lines1]", + "reasons": [ + { + "detail": "AssertionError: assert 'too few lines in the transfer list' in 'performing update\\ncreating cache dir cache\\ncache dir: cache\\nDone with error code: 100\\n' + where 'performing update\\ncreating cache d", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_version.TestVersion2Header.test_version2_rejects_negative_stash_blocks", + "reasons": [ + { + "detail": "AssertionError: assert 'unexpected maximum stash blocks' in 'performing update\\ncreating cache dir cache\\ncache dir: cache\\nblockimg version is 2\\nmaximum stash entries 1\\nDone with error code: 100\\n'", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + }, + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_version.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_version.TestVersion2Header.test_version2_rejects_non_numeric_stash_blocks", + "reasons": [ + { + "detail": "AssertionError: assert 'unexpected maximum stash blocks' in 'performing update\\ncreating cache dir cache\\ncache dir: cache\\nblockimg version is 2\\nmaximum stash entries 1\\nDone with error code: 100\\n'", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + }, + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_version.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_version.TestVersion2Header.test_version2_rejects_stash_blocks_when_block_count_positive", + "reasons": [ + { + "detail": "AssertionError: assert 'too few lines in the transfer list' in 'performing update\\ncreating cache dir cache\\ncache dir: cache\\nblockimg version is 2\\nDone with error code: 100\\n' + where 'performing u", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + }, + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_version.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_version.TestVersion2Header.test_version2_zero_blocks_does_not_require_full_header", + "reasons": [ + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_version.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_zero_erase.TestEraseCommand.test_erase_missing_range_fails", + "reasons": [ + { + "detail": "AssertionError: assert 'missing target blocks for erase' in 'performing update\\ncreating cache dir cache\\ncache dir: cache\\nblockimg version is 1\\nmissing target blocks for zero\\nfailed to execute com", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + }, + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_zero_erase.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_zero_erase.TestEraseCommand.test_erase_reports_written_zero", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_zero_erase.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_zero_erase.TestZeroCommand.test_zero_missing_range_argument_fails", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_zero_erase.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + } + ], + "tests": [ + "eval.tests.test_diff.TestBSDiff.test_bsdiff_empty_patch_magic_error", + "eval.tests.test_diff.TestBSDiff.test_bsdiff_implausible_magic_error", + "eval.tests.test_diff.TestBSDiff.test_bsdiff_invalid_length_token", + "eval.tests.test_diff.TestBSDiff.test_bsdiff_invalid_offset_token", + "eval.tests.test_diff.TestBSDiff.test_bsdiff_missing_offset_and_length", + "eval.tests.test_diff.TestBSDiff.test_bsdiff_single_offset_token_is_missing_length", + "eval.tests.test_diff.TestDiffInternals.test_diff_failed_command_is_flagged", + "eval.tests.test_diff.TestDiffInternals.test_diff_reports_patching_header", + "eval.tests.test_diff.TestImgDiff.test_imgdiff_garbage_patch_fails", + "eval.tests.test_diff.TestImgDiff.test_imgdiff_nonpositive_length", + "eval.tests.test_diff.TestImgDiff.test_imgdiff_short_patch_header_error", + "eval.tests.test_diff_success.TestBsDiffSuccess.test_bsdiff_applies_patch_and_target_becomes_new[4-0-1]", + "eval.tests.test_diff_success.TestBsDiffSuccess.test_bsdiff_applies_patch_and_target_becomes_new[4-0-2]", + "eval.tests.test_diff_success.TestBsDiffSuccess.test_bsdiff_applies_patch_and_target_becomes_new[8-12-3]", + "eval.tests.test_diff_success.TestBsDiffSuccess.test_bsdiff_reads_patch_from_nonzero_offset[0]", + "eval.tests.test_diff_success.TestBsDiffSuccess.test_bsdiff_reads_patch_from_nonzero_offset[128]", + "eval.tests.test_diff_success.TestBsDiffSuccess.test_bsdiff_reads_patch_from_nonzero_offset[32]", + "eval.tests.test_diff_success.TestBsDiffSuccess.test_bsdiff_reports_patching_and_wrote_counts", + "eval.tests.test_diff_success.TestBsDiffSuccess.test_bsdiff_source_blocks_untouched", + "eval.tests.test_diff_success.TestBsDiffSuccess.test_bsdiff_target_reports_written_blocks_when_expected_differs", + "eval.tests.test_diff_success.TestDiffRangeSinkHandling.test_bsdiff_shorter_output_reports_underrun", + "eval.tests.test_diff_success.TestDiffVersion3Success.test_v3_diff_with_wrong_target_hash_fails", + "eval.tests.test_diff_success.TestDiffVersion3Success.test_v3_two_hash_diff_succeeds[bsdiff]", + "eval.tests.test_diff_success.TestDiffVersion3Success.test_v3_two_hash_diff_succeeds[imgdiff]", + "eval.tests.test_diff_success.TestImgDiffSuccess.test_imgdiff_leaves_source_unchanged", + "eval.tests.test_diff_success.TestImgDiffSuccess.test_imgdiff_reports_patching_count", + "eval.tests.test_diff_success.TestImgDiffSuccess.test_imgdiff_writes_raw_payload_to_target[10-6-3]", + "eval.tests.test_diff_success.TestImgDiffSuccess.test_imgdiff_writes_raw_payload_to_target[2-0-1]", + "eval.tests.test_diff_success.TestImgDiffSuccess.test_imgdiff_writes_raw_payload_to_target[2-0-2]", + "eval.tests.test_diff_success_v2v3.TestV2DiffSourceRange.test_v2_diff_from_source_range_succeeds[bsdiff]", + "eval.tests.test_diff_success_v2v3.TestV2DiffSourceRange.test_v2_diff_from_source_range_succeeds[imgdiff]", + "eval.tests.test_diff_success_v2v3.TestV2DiffSourceRange.test_v2_imgdiff_rearranges_source_before_patch", + "eval.tests.test_diff_success_v2v3.TestV2DiffStashCombine.test_v2_diff_combines_source_and_stash[bsdiff]", + "eval.tests.test_diff_success_v2v3.TestV2DiffStashCombine.test_v2_diff_combines_source_and_stash[imgdiff]", + "eval.tests.test_diff_success_v2v3.TestV3TwoHashDiff.test_v3_two_hash_diff_succeeds[bsdiff]", + "eval.tests.test_diff_success_v2v3.TestV3TwoHashDiff.test_v3_two_hash_diff_succeeds[imgdiff]", + "eval.tests.test_diff_success_v2v3.TestV3TwoHashDiff.test_v3_two_hash_diff_wrong_source_hash_fails", + "eval.tests.test_diff_success_v2v3.TestV3TwoHashDiff.test_v3_two_hash_imgdiff_rearranged_source", + "eval.tests.test_errors.TestBlockDeviceMissing.test_missing_image_file_fails_with_errno", + "eval.tests.test_errors.TestCommandSequencing.test_commands_share_state_buffer", + "eval.tests.test_errors.TestCommandSequencing.test_empty_lines_are_skipped", + "eval.tests.test_errors.TestCommandSequencing.test_multiple_commands_execute_in_order", + "eval.tests.test_errors.TestCommandSequencing.test_stop_at_first_failing_command", + "eval.tests.test_errors.TestUnknownCommands.test_known_but_unregistered_in_update_table_not_relevant", + "eval.tests.test_errors.TestUnknownCommands.test_unknown_command_rejected[abcd]", + "eval.tests.test_errors.TestUnknownCommands.test_unknown_command_rejected[bogus]", + "eval.tests.test_errors.TestUnknownCommands.test_unknown_command_rejected[boom]", + "eval.tests.test_errors.TestUnknownCommands.test_unknown_command_rejected[copy]", + "eval.tests.test_errors.TestUnknownCommands.test_unknown_command_rejected[resize]", + "eval.tests.test_errors.TestUnknownCommands.test_unknown_command_rejected[truncate]", + "eval.tests.test_errors.TestUnknownCommands.test_unknown_command_rejected[wipe]", + "eval.tests.test_files.TestCacheDirectory.test_cache_dir_created_and_removed_on_success", + "eval.tests.test_files.TestCacheDirectory.test_cache_dir_persisted_when_exists", + "eval.tests.test_files.TestCacheDirectory.test_cache_dir_within_stash_subdir", + "eval.tests.test_files.TestProgressFile.test_progress_file_contains_set_progress_lines", + "eval.tests.test_files.TestProgressFile.test_progress_file_created_in_cwd", + "eval.tests.test_files.TestProgressFile.test_progress_file_logs_bytes_written_for_image", + "eval.tests.test_files.TestProgressFile.test_progress_file_per_command", + "eval.tests.test_files.TestProgressFile.test_progress_logs_bytes_stashed", + "eval.tests.test_files.TestProgressFile.test_progress_reports_written_blocks_ratio", + "eval.tests.test_load_errors.TestInvalidSrcBlockCount.test_diff_bad_src_block_count[---bsdiff]", + "eval.tests.test_load_errors.TestInvalidSrcBlockCount.test_diff_bad_src_block_count[---imgdiff]", + "eval.tests.test_load_errors.TestInvalidSrcBlockCount.test_diff_bad_src_block_count[1b-bsdiff]", + "eval.tests.test_load_errors.TestInvalidSrcBlockCount.test_diff_bad_src_block_count[1b-imgdiff]", + "eval.tests.test_load_errors.TestInvalidSrcBlockCount.test_diff_bad_src_block_count[x-bsdiff]", + "eval.tests.test_load_errors.TestInvalidSrcBlockCount.test_diff_bad_src_block_count[x-imgdiff]", + "eval.tests.test_load_errors.TestInvalidSrcBlockCount.test_move_bad_src_block_count[-3-2]", + "eval.tests.test_load_errors.TestInvalidSrcBlockCount.test_move_bad_src_block_count[-3-3]", + "eval.tests.test_load_errors.TestInvalidSrcBlockCount.test_move_bad_src_block_count[0x10-2]", + "eval.tests.test_load_errors.TestInvalidSrcBlockCount.test_move_bad_src_block_count[0x10-3]", + "eval.tests.test_load_errors.TestInvalidSrcBlockCount.test_move_bad_src_block_count[1.5-2]", + "eval.tests.test_load_errors.TestInvalidSrcBlockCount.test_move_bad_src_block_count[1.5-3]", + "eval.tests.test_load_errors.TestInvalidSrcBlockCount.test_move_bad_src_block_count[abc-2]", + "eval.tests.test_load_errors.TestInvalidSrcBlockCount.test_move_bad_src_block_count[abc-3]", + "eval.tests.test_load_errors.TestMissingSourceHash.test_v3_bsdiff_offset_len_only", + "eval.tests.test_load_errors.TestMissingSourceHash.test_v3_imgdiff_offset_len_only", + "eval.tests.test_load_errors.TestMissingSourceHash.test_v3_move_no_tokens", + "eval.tests.test_load_errors.TestMissingTargetHash.test_v3_bsdiff_hash_but_no_target_hash", + "eval.tests.test_load_errors.TestMissingTargetHash.test_v3_imgdiff_hash_but_no_target_hash", + "eval.tests.test_load_errors.TestTooFewLoadTokens.test_v2_single_range_token_is_invalid_parameters[bsdiff]", + "eval.tests.test_load_errors.TestTooFewLoadTokens.test_v2_single_range_token_is_invalid_parameters[imgdiff]", + "eval.tests.test_load_errors.TestTooFewLoadTokens.test_v2_single_range_token_is_invalid_parameters[move]", + "eval.tests.test_load_errors.TestTooFewLoadTokens.test_v2_two_range_tokens_lack_count[bsdiff]", + "eval.tests.test_load_errors.TestTooFewLoadTokens.test_v2_two_range_tokens_lack_count[imgdiff]", + "eval.tests.test_load_errors.TestTooFewLoadTokens.test_v2_two_range_tokens_lack_count[move]", + "eval.tests.test_load_errors.TestVersion1Free.test_v1_free_reports_missing_base_error", + "eval.tests.test_move.TestMoveVersion1.test_move_copies_source_to_target[2,0,2-2,6,8-8]", + "eval.tests.test_move.TestMoveVersion1.test_move_copies_source_to_target[2,1,3-2,7,9-7]", + "eval.tests.test_move.TestMoveVersion1.test_move_copies_source_to_target[2,4,6-2,0,2-4]", + "eval.tests.test_move.TestMoveVersion1.test_move_increments_written", + "eval.tests.test_move.TestMoveVersion1.test_move_missing_arguments_fails", + "eval.tests.test_move.TestMoveVersion1.test_move_reading_source_before_we_dispatch", + "eval.tests.test_move.TestMoveVersion1.test_move_source_untouched", + "eval.tests.test_move.TestMoveVersion2Stash.test_move_from_stash_only", + "eval.tests.test_move.TestMoveVersion2Stash.test_move_using_stash_and_free", + "eval.tests.test_move.TestMoveVersion2Stash.test_move_version2_invalid_parameter", + "eval.tests.test_move.TestMoveVersion2Stash.test_move_version2_missing_stash_is_nonfatal", + "eval.tests.test_move.TestMoveVersion3Hash.test_move_version3_correct_hash", + "eval.tests.test_move.TestMoveVersion3Hash.test_move_version3_missing_source_hash", + "eval.tests.test_move.TestMoveVersion3Hash.test_move_version3_overlap_stashes_and_moves", + "eval.tests.test_move.TestMoveVersion3Hash.test_move_version3_too_few_lines_still_handled", + "eval.tests.test_move.TestMoveVersion3Hash.test_move_version3_wrong_hash_unresumable", + "eval.tests.test_new.TestNewCommand.test_new_does_not_touch_other_blocks", + "eval.tests.test_new.TestNewCommand.test_new_missing_range_fails", + "eval.tests.test_new.TestNewCommand.test_new_multi_range_portions", + "eval.tests.test_new.TestNewCommand.test_new_reports_written_blocks", + "eval.tests.test_new.TestNewCommand.test_new_reuses_payload_across_multiple_targets", + "eval.tests.test_new.TestNewCommand.test_new_with_exact_payload_length", + "eval.tests.test_new.TestNewCommand.test_new_writes_payload_to_target[2,0,2]", + "eval.tests.test_new.TestNewCommand.test_new_writes_payload_to_target[2,4,6]", + "eval.tests.test_new.TestNewCommand.test_new_writes_payload_to_target[2,6,8]", + "eval.tests.test_parse_range_extra.TestParseRangeExtraBranches.test_count_mismatch_rejected[2,0,2,4,6]", + "eval.tests.test_parse_range_extra.TestParseRangeExtraBranches.test_count_mismatch_rejected[2,0,2,4]", + "eval.tests.test_parse_range_extra.TestParseRangeExtraBranches.test_count_mismatch_rejected[4,0,2]", + "eval.tests.test_parse_range_extra.TestParseRangeExtraBranches.test_lower_bound_greater_than_upper_rejected", + "eval.tests.test_parse_range_extra.TestParseRangeExtraBranches.test_non_numeric_endpoint_rejected[2,0,x]", + "eval.tests.test_parse_range_extra.TestParseRangeExtraBranches.test_non_numeric_endpoint_rejected[2,x,4]", + "eval.tests.test_parse_range_extra.TestParseRangeExtraBranches.test_non_numeric_endpoint_rejected[4,0,2,y,4]", + "eval.tests.test_parse_range_extra.TestParseRangeExtraBranches.test_zero_range_pair_among_several_rejected", + "eval.tests.test_stash.TestFreeCommand.test_free_missing_id", + "eval.tests.test_stash.TestFreeCommand.test_free_references_stash_id", + "eval.tests.test_stash.TestFreeCommand.test_free_without_prior_stash_then_use_fails_log", + "eval.tests.test_stash.TestStashCommand.test_stash_missing_range_fields", + "eval.tests.test_stash.TestStashCommand.test_stash_source_range_parsed", + "eval.tests.test_stash.TestStashCommand.test_stash_writes_stash_file_in_cache", + "eval.tests.test_stash.TestVersion3StashHash.test_stash_version3_missing_hash_usage", + "eval.tests.test_stash.TestVersion3StashHash.test_stash_version3_uses_hash_verification", + "eval.tests.test_stash.TestVersion3StashHash.test_stash_version3_wrong_hash_source", + "eval.tests.test_stash_lifecycle.TestCreateStashExistingDirectory.test_partial_file_is_enumerated_and_unlinked", + "eval.tests.test_stash_lifecycle.TestCreateStashExistingDirectory.test_stash_dir_with_subdir_can_be_enumerated", + "eval.tests.test_stash_lifecycle.TestCreateStashExistingDirectory.test_uses_existing_stash_dir_and_deletes_partial", + "eval.tests.test_stash_lifecycle.TestDeleteStashRmdirFailure.test_final_rmdir_cache_succeeds_on_clean_update", + "eval.tests.test_stash_lifecycle.TestDeleteStashRmdirFailure.test_rmdir_stash_base_fails_when_subdir_remains", + "eval.tests.test_stash_lifecycle.TestLoadStashDisk.test_load_stash_reorders_stash_ranges", + "eval.tests.test_stash_lifecycle.TestLoadStashDisk.test_load_stash_size_not_multiple_of_block", + "eval.tests.test_stash_lifecycle.TestLoadStashDisk.test_stash_then_move_loads_from_disk", + "eval.tests.test_stash_lifecycle.TestProgressPartitionLog.test_partition_basename_with_slash_path", + "eval.tests.test_stash_lifecycle.TestV3OverlapRecovery.test_recovery_from_valid_stash_repairs_source", + "eval.tests.test_stash_lifecycle.TestV3OverlapRecovery.test_recovery_skipped_when_stash_verify_fails", + "eval.tests.test_stash_lifecycle.TestWriteStashSkipExisting.test_v3_overlap_skips_existing_stash", + "eval.tests.test_usage.test_help_flag_is_treated_as_usage", + "eval.tests.test_usage.test_no_arguments_prints_usage", + "eval.tests.test_usage.test_one_argument_still_prints_usage", + "eval.tests.test_usage.test_three_arguments_still_prints_usage", + "eval.tests.test_usage.test_two_arguments_still_prints_usage", + "eval.tests.test_usage.test_usage_flag_returns_zero_and_writes_no_files", + "eval.tests.test_usage.test_usage_mentions_all_four_arguments", + "eval.tests.test_version.TestBlockCount.test_negative_block_count_rejected", + "eval.tests.test_version.TestBlockCount.test_non_numeric_block_count_rejected", + "eval.tests.test_version.TestBlockCount.test_zero_blocks_returns_early", + "eval.tests.test_version.TestTooFewLines.test_empty_transfer_file", + "eval.tests.test_version.TestTooFewLines.test_too_few_lines_aborts[lines0]", + "eval.tests.test_version.TestTooFewLines.test_too_few_lines_aborts[lines1]", + "eval.tests.test_version.TestVersion2Header.test_version2_rejects_negative_stash_blocks", + "eval.tests.test_version.TestVersion2Header.test_version2_rejects_non_numeric_stash_blocks", + "eval.tests.test_version.TestVersion2Header.test_version2_rejects_stash_blocks_when_block_count_positive", + "eval.tests.test_version.TestVersion2Header.test_version2_zero_blocks_does_not_require_full_header", + "eval.tests.test_version.TestVersionParsing.test_non_numeric_version_rejected[1.5]", + "eval.tests.test_version.TestVersionParsing.test_non_numeric_version_rejected[]", + "eval.tests.test_version.TestVersionParsing.test_non_numeric_version_rejected[abc]", + "eval.tests.test_version.TestVersionParsing.test_non_numeric_version_rejected[one]", + "eval.tests.test_version.TestVersionParsing.test_non_numeric_version_rejected[x]", + "eval.tests.test_version.TestVersionParsing.test_out_of_range_version_rejected[-1]", + "eval.tests.test_version.TestVersionParsing.test_out_of_range_version_rejected[0]", + "eval.tests.test_version.TestVersionParsing.test_out_of_range_version_rejected[100]", + "eval.tests.test_version.TestVersionParsing.test_out_of_range_version_rejected[5]", + "eval.tests.test_version.TestVersionParsing.test_out_of_range_version_rejected[9]", + "eval.tests.test_version.TestVersionParsing.test_valid_version_runs[1]", + "eval.tests.test_version.TestVersionParsing.test_valid_version_runs[2]", + "eval.tests.test_version.TestVersionParsing.test_valid_version_runs[3]", + "eval.tests.test_version.TestVersionParsing.test_valid_version_runs[4]", + "eval.tests.test_zero_erase.TestEraseCommand.test_erase_missing_range_fails", + "eval.tests.test_zero_erase.TestEraseCommand.test_erase_reports_written_zero", + "eval.tests.test_zero_erase.TestEraseCommand.test_erase_zeros_blocks", + "eval.tests.test_zero_erase.TestZeroCommand.test_zero_clears_target_blocks[2,0,2]", + "eval.tests.test_zero_erase.TestZeroCommand.test_zero_clears_target_blocks[2,6,8]", + "eval.tests.test_zero_erase.TestZeroCommand.test_zero_clears_target_blocks[4,1,3,4,6]", + "eval.tests.test_zero_erase.TestZeroCommand.test_zero_head_of_block_cleared", + "eval.tests.test_zero_erase.TestZeroCommand.test_zero_increments_written_blocks", + "eval.tests.test_zero_erase.TestZeroCommand.test_zero_leaves_unrelated_blocks_untouched", + "eval.tests.test_zero_erase.TestZeroCommand.test_zero_missing_range_argument_fails", + "eval.tests.test_zero_erase.TestZeroCommand.test_zero_multi_noncontiguous_ranges", + "eval.tests.test_zero_erase.TestZeroCommand.test_zero_single_block", + "eval.tests.test_zero_erase.TestZeroRangeParsing.test_bad_range_causes_exit_1[0,0,2]", + "eval.tests.test_zero_erase.TestZeroRangeParsing.test_bad_range_causes_exit_1[1,0,2]", + "eval.tests.test_zero_erase.TestZeroRangeParsing.test_bad_range_causes_exit_1[2,0]", + "eval.tests.test_zero_erase.TestZeroRangeParsing.test_bad_range_causes_exit_1[2,2,2]", + "eval.tests.test_zero_erase.TestZeroRangeParsing.test_bad_range_causes_exit_1[2,5,3]", + "eval.tests.test_zero_erase.TestZeroRangeParsing.test_bad_range_causes_exit_1[3,0,2]", + "eval.tests.test_zero_erase.TestZeroRangeParsing.test_bad_range_causes_exit_1[x,0,2]" + ] + }, + "generated_module_02": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [ + { + "name": "eval.tests.test_apply_sink_short_write.test_bsdiff_short_write_golden", + "reasons": [ + { + "detail": "TypeError: not enough arguments for format string", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + }, + { + "id": "missing_fixture_assets", + "message": "pytest test references fixture assets that are not packaged", + "path": "eval/tests/test_apply_sink_short_write.py", + "repair_hint": "Package referenced fixture, resource, golden, or test data files with the eval branch.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_apply_sink_short_write.test_bsdiff_short_write_multi_block_target", + "reasons": [ + { + "detail": "TypeError: not enough arguments for format string", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_apply_sink_short_write.test_bsdiff_short_write_varied[00-ff]", + "reasons": [ + { + "detail": "TypeError: not enough arguments for format string", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_apply_sink_short_write.test_bsdiff_short_write_varied[11-22]", + "reasons": [ + { + "detail": "TypeError: not enough arguments for format string", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_apply_sink_short_write.test_bsdiff_short_write_varied[ab-cd]", + "reasons": [ + { + "detail": "TypeError: not enough arguments for format string", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_apply_sink_short_write.test_imgdiff_normal_soft_short_write", + "reasons": [ + { + "detail": "TypeError: not enough arguments for format string", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + }, + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_apply_sink_short_write.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_apply_sink_short_write.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_apply_sink_short_write.test_imgdiff_raw_short_write_two_block_target", + "reasons": [ + { + "detail": "TypeError: not enough arguments for format string", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_apply_sink_short_write.test_imgdiff_raw_sink_short_write_golden", + "reasons": [ + { + "detail": "TypeError: not enough arguments for format string", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + }, + { + "id": "missing_fixture_assets", + "message": "pytest test references fixture assets that are not packaged", + "path": "eval/tests/test_apply_sink_short_write.py", + "repair_hint": "Package referenced fixture, resource, golden, or test data files with the eval branch.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_apply_sink_short_write.test_imgdiff_raw_sink_short_write_varied[\\x00]", + "reasons": [ + { + "detail": "TypeError: not enough arguments for format string", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_apply_sink_short_write.test_imgdiff_raw_sink_short_write_varied[\\xaa]", + "reasons": [ + { + "detail": "TypeError: not enough arguments for format string", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_apply_sink_short_write.test_imgdiff_raw_sink_short_write_varied[\\xff]", + "reasons": [ + { + "detail": "TypeError: not enough arguments for format string", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_bsdiff_apply.test_bsdiff_command_parse_errors[extra-token]", + "reasons": [ + { + "detail": "AssertionError: performing update creating cache dir cache cache dir: cache blockimg version is 1 patching 1 blocks to 1 corrupt bsdiff patch file header (magic number) Failed to apply bsdiff patch. f", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_bsdiff_apply.test_bsdiff_control_stream_underrun", + "reasons": [ + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_bsdiff_apply.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_bsdiff_apply.test_bsdiff_corrupt_bz2_stream[extra]", + "reasons": [ + { + "detail": "AssertionError: performing update creating cache dir cache cache dir: cache blockimg version is 1 patching 1 blocks to 1 range sink underrun? wrote 1 blocks; expected 1 stashed 0 blocks max alloc need", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_bsdiff_apply.test_bsdiff_corrupt_magic", + "reasons": [ + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_bsdiff_apply.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_bsdiff_apply.test_bsdiff_empty_range_list", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_bsdiff_apply.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_bsdiff_apply.test_bsdiff_invalid_src_range", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_bsdiff_apply.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_bsdiff_apply.test_bsdiff_multi_triple_chain", + "reasons": [ + { + "detail": "AssertionError: performing update creating cache dir cache cache dir: cache blockimg version is 1 patching 1 blocks to 1 short write of output: 0 (Success) Failed to apply bsdiff patch. failed to exec", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_bsdiff_apply.test_bsdiff_new_file_overrun[sum-overrun]", + "reasons": [ + { + "detail": "AssertionError: missing message 'corrupt patch (new file overrun)' in: performing update creating cache dir cache cache dir: cache blockimg version is 1 patching 1 blocks to 1 bz error -1 decompressin", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_bsdiff_apply.test_bsdiff_new_size_too_big_seen_negative", + "reasons": [ + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_bsdiff_apply.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_bsdiff_apply.test_bsdiff_seek_forward_oldpos", + "reasons": [ + { + "detail": "AssertionError: assert b'\\x81\\x81\\x8...0\\x00\\x00\\x00' == b'AAAAAAAAAAA...0\\x00\\x00\\x00' At index 0 diff: b'\\x81' != b'A' Full diff: + (b'\\x81\\x81\\x81\\x81\\x81\\x81\\x81\\x81\\x81\\x81\\x81\\x81\\x00\\x00\\x00\\x0", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_bsdiff_apply.test_bsdiff_too_short_magic", + "reasons": [ + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_bsdiff_apply.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_golden_output.test_canonical_success_golden", + "reasons": [ + { + "detail": "AssertionError: stdout does not match golden: --- actual --- performing update creating cache dir cache cache dir: cache blockimg version is 1 moving 1 blocks wrote 1 blocks; expected 1 stashed 0 bloc", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + }, + { + "id": "missing_fixture_assets", + "message": "pytest test references fixture assets that are not packaged", + "path": "eval/tests/test_golden_output.py", + "repair_hint": "Package referenced fixture, resource, golden, or test data files with the eval branch.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_imgpatch.test_imgdiff_normal_src_offset[128]", + "reasons": [ + { + "detail": "AssertionError: assert b'\\x11\\x11\\x1...a\\xaa\\xaa\\xaa' == b'\\xaa\\xaa\\xa...a\\xaa\\xaa\\xaa' At index 0 diff: b'\\x11' != b'\\xaa' Full diff: - (b'\\xaa\\xaa\\xaa\\xaa\\xaa\\xaa\\xaa\\xaa\\xaa\\xaa\\xaa\\xaa\\xaa\\xaa\\xaa", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_imgpatch.test_imgdiff_normal_src_offset[2048]", + "reasons": [ + { + "detail": "AssertionError: assert b'\\x11\\x11\\x1...a\\xaa\\xaa\\xaa' == b'\\xaa\\xaa\\xa...a\\xaa\\xaa\\xaa' At index 0 diff: b'\\x11' != b'\\xaa' Full diff: - (b'\\xaa\\xaa\\xaa\\xaa\\xaa\\xaa\\xaa\\xaa\\xaa\\xaa\\xaa\\xaa\\xaa\\xaa\\xaa", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_imgpatch.test_imgdiff_normal_two_chunks", + "reasons": [ + { + "detail": "AssertionError: performing update creating cache dir cache cache dir: cache blockimg version is 1 patching 1 blocks to 1 patch chunk 1 is unknown type 1229214530 Failed to apply image patch. failed to", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_imgpatch.test_imgdiff_raw_then_normal_order", + "reasons": [ + { + "detail": "AssertionError: assert b'\\xaa\\xaa\\xa...f\\x0f\\x0f\\x0f' == b'\\xaa\\xaa\\xa...f\\x0f\\x0f\\x0f' At index 64 diff: b'\\x0f' != b'\\xbb' Full diff: (b'\\xaa\\xaa\\xaa\\xaa\\xaa\\xaa\\xaa\\xaa\\xaa\\xaa\\xaa\\xaa\\xaa\\xaa\\xaa\\", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_imgpatch.test_imgpatch_bad_deflate_params", + "reasons": [ + { + "id": "assertion_disjunction", + "message": "pytest assertion accepts alternatives with or", + "path": "eval/tests/test_imgpatch.py", + "repair_hint": "Assert one exact expected outcome instead of accepting alternative outcomes with or.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_imgpatch.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_imgpatch.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_imgpatch.test_imgpatch_bad_source_inflation", + "reasons": [ + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_imgpatch.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_imgpatch.test_imgpatch_corrupt_magic", + "reasons": [ + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_imgpatch.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_imgpatch.test_imgpatch_deflate_header_underrun", + "reasons": [ + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_imgpatch.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_imgpatch.test_imgpatch_failed_to_read_chunk_record", + "reasons": [ + { + "detail": "AssertionError: missing message 'failed to read chunk 1 record' in: performing update creating cache dir cache cache dir: cache blockimg version is 1 patching 1 blocks to 1 failed to read chunk 0 norm", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + }, + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_imgpatch.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_imgpatch.test_imgpatch_failed_to_read_deflate_record_midlist", + "reasons": [ + { + "detail": "AssertionError: missing message 'failed to read chunk 1 record' in: performing update creating cache dir cache cache dir: cache blockimg version is 1 patching 1 blocks to 1 patch chunk 1 is unknown ty", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + }, + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_imgpatch.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_imgpatch.test_imgpatch_normal_header_underrun", + "reasons": [ + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_imgpatch.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_imgpatch.test_imgpatch_raw_data_truncated", + "reasons": [ + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_imgpatch.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_imgpatch.test_imgpatch_short_source_inflation", + "reasons": [ + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_imgpatch.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_imgpatch.test_imgpatch_source_too_short_deflate", + "reasons": [ + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_imgpatch.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_imgpatch.test_imgpatch_source_too_short_normal", + "reasons": [ + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_imgpatch.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_imgpatch_header_edges.test_imgpatch_raw_header_underrun_golden", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_imgpatch_header_edges.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "missing_fixture_assets", + "message": "pytest test references fixture assets that are not packaged", + "path": "eval/tests/test_imgpatch_header_edges.py", + "repair_hint": "Package referenced fixture, resource, golden, or test data files with the eval branch.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_update_flow.test_bsdiff_multi_block_source", + "reasons": [ + { + "detail": "AssertionError: performing update creating cache dir cache cache dir: cache blockimg version is 1 failed to parse range '4,0,2'", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_update_flow.test_foundwrites_out_of_order_warning", + "reasons": [ + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_update_flow.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_update_flow.test_free_stash_unknown", + "reasons": [ + { + "id": "assertion_disjunction", + "message": "pytest assertion accepts alternatives with or", + "path": "eval/tests/test_update_flow.py", + "repair_hint": "Assert one exact expected outcome instead of accepting alternative outcomes with or.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_update_flow.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_update_flow.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_update_flow.test_skipping_already_patched", + "reasons": [ + { + "id": "assertion_disjunction", + "message": "pytest assertion accepts alternatives with or", + "path": "eval/tests/test_update_flow.py", + "repair_hint": "Assert one exact expected outcome instead of accepting alternative outcomes with or.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_update_flow.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_update_flow.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_update_flow.test_version2_stash_flow", + "reasons": [ + { + "id": "assertion_disjunction", + "message": "pytest assertion accepts alternatives with or", + "path": "eval/tests/test_update_flow.py", + "repair_hint": "Assert one exact expected outcome instead of accepting alternative outcomes with or.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_update_flow.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_update_flow.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_update_flow.test_zero_block", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_update_flow.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + } + ], + "tests": [ + "eval.tests.test_apply_sink_short_write.test_bsdiff_short_write_golden", + "eval.tests.test_apply_sink_short_write.test_bsdiff_short_write_multi_block_target", + "eval.tests.test_apply_sink_short_write.test_bsdiff_short_write_varied[00-ff]", + "eval.tests.test_apply_sink_short_write.test_bsdiff_short_write_varied[11-22]", + "eval.tests.test_apply_sink_short_write.test_bsdiff_short_write_varied[ab-cd]", + "eval.tests.test_apply_sink_short_write.test_imgdiff_normal_soft_short_write", + "eval.tests.test_apply_sink_short_write.test_imgdiff_raw_short_write_two_block_target", + "eval.tests.test_apply_sink_short_write.test_imgdiff_raw_sink_short_write_golden", + "eval.tests.test_apply_sink_short_write.test_imgdiff_raw_sink_short_write_varied[\\x00]", + "eval.tests.test_apply_sink_short_write.test_imgdiff_raw_sink_short_write_varied[\\xaa]", + "eval.tests.test_apply_sink_short_write.test_imgdiff_raw_sink_short_write_varied[\\xff]", + "eval.tests.test_bsdiff_apply.test_bsdiff_command_parse_errors[bad-len]", + "eval.tests.test_bsdiff_apply.test_bsdiff_command_parse_errors[bad-offset]", + "eval.tests.test_bsdiff_apply.test_bsdiff_command_parse_errors[extra-token]", + "eval.tests.test_bsdiff_apply.test_bsdiff_command_parse_errors[no-tgt]", + "eval.tests.test_bsdiff_apply.test_bsdiff_command_parse_errors[only-offset]", + "eval.tests.test_bsdiff_apply.test_bsdiff_control_stream_underrun", + "eval.tests.test_bsdiff_apply.test_bsdiff_corrupt_bz2_stream[ctrl]", + "eval.tests.test_bsdiff_apply.test_bsdiff_corrupt_bz2_stream[diff]", + "eval.tests.test_bsdiff_apply.test_bsdiff_corrupt_bz2_stream[extra]", + "eval.tests.test_bsdiff_apply.test_bsdiff_corrupt_magic", + "eval.tests.test_bsdiff_apply.test_bsdiff_diff_block_identity[\\x00]", + "eval.tests.test_bsdiff_apply.test_bsdiff_diff_block_identity[\\x80]", + "eval.tests.test_bsdiff_apply.test_bsdiff_diff_block_identity[\\xff]", + "eval.tests.test_bsdiff_apply.test_bsdiff_diff_extra_split_boundaries[0]", + "eval.tests.test_bsdiff_apply.test_bsdiff_diff_extra_split_boundaries[100]", + "eval.tests.test_bsdiff_apply.test_bsdiff_diff_extra_split_boundaries[1]", + "eval.tests.test_bsdiff_apply.test_bsdiff_diff_extra_split_boundaries[2048]", + "eval.tests.test_bsdiff_apply.test_bsdiff_diff_extra_split_boundaries[2]", + "eval.tests.test_bsdiff_apply.test_bsdiff_diff_extra_split_boundaries[4095]", + "eval.tests.test_bsdiff_apply.test_bsdiff_diff_extra_split_boundaries[4096]", + "eval.tests.test_bsdiff_apply.test_bsdiff_empty_range_list", + "eval.tests.test_bsdiff_apply.test_bsdiff_full_diff_transform[00-ff]", + "eval.tests.test_bsdiff_apply.test_bsdiff_full_diff_transform[41-7a]", + "eval.tests.test_bsdiff_apply.test_bsdiff_full_diff_transform[5a-a5]", + "eval.tests.test_bsdiff_apply.test_bsdiff_full_diff_transform[aa-bb]", + "eval.tests.test_bsdiff_apply.test_bsdiff_grow_output", + "eval.tests.test_bsdiff_apply.test_bsdiff_invalid_src_range", + "eval.tests.test_bsdiff_apply.test_bsdiff_multi_triple_chain", + "eval.tests.test_bsdiff_apply.test_bsdiff_negative_byte_counts[ctrl0]", + "eval.tests.test_bsdiff_apply.test_bsdiff_negative_byte_counts[ctrl1]", + "eval.tests.test_bsdiff_apply.test_bsdiff_negative_header_lengths[ctrl-neg100]", + "eval.tests.test_bsdiff_apply.test_bsdiff_negative_header_lengths[ctrl-neg1]", + "eval.tests.test_bsdiff_apply.test_bsdiff_negative_header_lengths[data-neg1]", + "eval.tests.test_bsdiff_apply.test_bsdiff_negative_header_lengths[data-neg40]", + "eval.tests.test_bsdiff_apply.test_bsdiff_negative_header_lengths[new-neg1]", + "eval.tests.test_bsdiff_apply.test_bsdiff_negative_header_lengths[new-neg999]", + "eval.tests.test_bsdiff_apply.test_bsdiff_new_file_overrun[diff-overrun]", + "eval.tests.test_bsdiff_apply.test_bsdiff_new_file_overrun[extra-overrun]", + "eval.tests.test_bsdiff_apply.test_bsdiff_new_file_overrun[sum-overrun]", + "eval.tests.test_bsdiff_apply.test_bsdiff_new_size_too_big_seen_negative", + "eval.tests.test_bsdiff_apply.test_bsdiff_seek_forward_oldpos", + "eval.tests.test_bsdiff_apply.test_bsdiff_shrink_output", + "eval.tests.test_bsdiff_apply.test_bsdiff_too_short_magic", + "eval.tests.test_bsdiff_apply.test_bsdiff_two_triple_control[1-diff]", + "eval.tests.test_bsdiff_apply.test_bsdiff_two_triple_control[100-diff]", + "eval.tests.test_bsdiff_apply.test_bsdiff_two_triple_control[4000-diff]", + "eval.tests.test_bsdiff_apply.test_bsdiff_two_triple_control[4095-diff]", + "eval.tests.test_bsdiff_apply.test_bsdiff_two_triple_control[half-half]", + "eval.tests.test_golden_output.test_canonical_success_golden", + "eval.tests.test_imgpatch.test_imgdiff_deflate_custom_profile", + "eval.tests.test_imgpatch.test_imgdiff_deflate_roundtrip[32]", + "eval.tests.test_imgpatch.test_imgdiff_deflate_roundtrip[4000]", + "eval.tests.test_imgpatch.test_imgdiff_deflate_roundtrip[512]", + "eval.tests.test_imgpatch.test_imgdiff_normal_chunk[3-\\xcc]", + "eval.tests.test_imgpatch.test_imgdiff_normal_chunk[\\x00-\\xff]", + "eval.tests.test_imgpatch.test_imgdiff_normal_chunk[\\xaa-\\xbb]", + "eval.tests.test_imgpatch.test_imgdiff_normal_src_offset[0]", + "eval.tests.test_imgpatch.test_imgdiff_normal_src_offset[128]", + "eval.tests.test_imgpatch.test_imgdiff_normal_src_offset[2048]", + "eval.tests.test_imgpatch.test_imgdiff_normal_two_chunks", + "eval.tests.test_imgpatch.test_imgdiff_normal_window_len_not_block", + "eval.tests.test_imgpatch.test_imgdiff_raw_chunk[\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00]", + "eval.tests.test_imgpatch.test_imgdiff_raw_chunk[\\x00\\x01\\x02\\x03\\x04\\x05\\x06\\x07\\x08\\t\\n\\x0b\\x0c\\r\\x0e\\x0f\\x10\\x11\\x12\\x13\\x14\\x15\\x16\\x17\\x18\\x19\\x1a\\x1b\\x1c\\x1d\\x1e\\x1f !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\\x7f\\x80\\x81\\x82\\x83\\x84\\x85\\x86\\x87\\x88\\x89\\x8a\\x8b\\x8c\\x8d\\x8e\\x8f\\x90\\x91\\x92\\x93\\x94\\x95\\x96\\x97\\x98\\x99\\x9a\\x9b\\x9c\\x9d\\x9e\\x9f\\xa0\\xa1\\xa2\\xa3\\xa4\\xa5\\xa6\\xa7\\xa8\\xa9\\xaa\\xab\\xac\\xad\\xae\\xaf\\xb0\\xb1\\xb2\\xb3\\xb4\\xb5\\xb6\\xb7\\xb8\\xb9\\xba\\xbb\\xbc\\xbd\\xbe\\xbf\\xc0\\xc1\\xc2\\xc3\\xc4\\xc5\\xc6\\xc7\\xc8\\xc9\\xca\\xcb\\xcc\\xcd\\xce\\xcf\\xd0\\xd1\\xd2\\xd3\\xd4\\xd5\\xd6\\xd7\\xd8\\xd9\\xda\\xdb\\xdc\\xdd\\xde\\xdf\\xe0\\xe1\\xe2\\xe3\\xe4\\xe5\\xe6\\xe7\\xe8\\xe9\\xea\\xeb\\xec\\xed\\xee\\xef\\xf0\\xf1\\xf2\\xf3\\xf4\\xf5\\xf6\\xf7\\xf8\\xf9\\xfa\\xfb\\xfc\\xfd\\xfe\\xff]", + "eval.tests.test_imgpatch.test_imgdiff_raw_chunk[\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff]", + "eval.tests.test_imgpatch.test_imgdiff_raw_full_block", + "eval.tests.test_imgpatch.test_imgdiff_raw_then_normal_order", + "eval.tests.test_imgpatch.test_imgpatch_bad_deflate_params", + "eval.tests.test_imgpatch.test_imgpatch_bad_source_inflation", + "eval.tests.test_imgpatch.test_imgpatch_corrupt_magic", + "eval.tests.test_imgpatch.test_imgpatch_deflate_header_underrun", + "eval.tests.test_imgpatch.test_imgpatch_failed_to_read_chunk_record", + "eval.tests.test_imgpatch.test_imgpatch_failed_to_read_deflate_record_midlist", + "eval.tests.test_imgpatch.test_imgpatch_normal_header_underrun", + "eval.tests.test_imgpatch.test_imgpatch_patch_too_short[IMGDIFF2]", + "eval.tests.test_imgpatch.test_imgpatch_patch_too_short[IMG]", + "eval.tests.test_imgpatch.test_imgpatch_patch_too_short[]", + "eval.tests.test_imgpatch.test_imgpatch_raw_data_truncated", + "eval.tests.test_imgpatch.test_imgpatch_short_source_inflation", + "eval.tests.test_imgpatch.test_imgpatch_source_too_short_deflate", + "eval.tests.test_imgpatch.test_imgpatch_source_too_short_normal", + "eval.tests.test_imgpatch.test_imgpatch_unknown_chunk_type[-1]", + "eval.tests.test_imgpatch.test_imgpatch_unknown_chunk_type[100]", + "eval.tests.test_imgpatch.test_imgpatch_unknown_chunk_type[4]", + "eval.tests.test_imgpatch.test_imgpatch_unknown_chunk_type[5]", + "eval.tests.test_imgpatch.test_imgpatch_unknown_chunk_type[99]", + "eval.tests.test_imgpatch_header_edges.test_imgpatch_chunk_count_no_records_underrun[16]", + "eval.tests.test_imgpatch_header_edges.test_imgpatch_chunk_count_no_records_underrun[1]", + "eval.tests.test_imgpatch_header_edges.test_imgpatch_chunk_count_no_records_underrun[2]", + "eval.tests.test_imgpatch_header_edges.test_imgpatch_chunk_count_no_records_underrun[4]", + "eval.tests.test_imgpatch_header_edges.test_imgpatch_nonpositive_chunk_count_noop[-100]", + "eval.tests.test_imgpatch_header_edges.test_imgpatch_nonpositive_chunk_count_noop[-1]", + "eval.tests.test_imgpatch_header_edges.test_imgpatch_nonpositive_chunk_count_noop[0]", + "eval.tests.test_imgpatch_header_edges.test_imgpatch_raw_header_underrun_golden", + "eval.tests.test_imgpatch_header_edges.test_imgpatch_raw_header_underrun_varied[0]", + "eval.tests.test_imgpatch_header_edges.test_imgpatch_raw_header_underrun_varied[1]", + "eval.tests.test_imgpatch_header_edges.test_imgpatch_raw_header_underrun_varied[2]", + "eval.tests.test_imgpatch_header_edges.test_imgpatch_raw_header_underrun_varied[3]", + "eval.tests.test_imgpatch_header_edges.test_imgpatch_raw_then_zero_count_ordering[fills0]", + "eval.tests.test_update_flow.test_bsdiff_multi_block_source", + "eval.tests.test_update_flow.test_erase_acts_as_zero", + "eval.tests.test_update_flow.test_foundwrites_out_of_order_warning", + "eval.tests.test_update_flow.test_free_stash_unknown", + "eval.tests.test_update_flow.test_imgdiff_single_block[same-block]", + "eval.tests.test_update_flow.test_move_block[\\x00]", + "eval.tests.test_update_flow.test_move_block[\\xaa]", + "eval.tests.test_update_flow.test_move_block[\\xff]", + "eval.tests.test_update_flow.test_new_block", + "eval.tests.test_update_flow.test_new_then_diff_sequence", + "eval.tests.test_update_flow.test_skipping_already_patched", + "eval.tests.test_update_flow.test_version2_erase_command", + "eval.tests.test_update_flow.test_version2_new_command", + "eval.tests.test_update_flow.test_version2_stash_flow", + "eval.tests.test_update_flow.test_zero_block" + ] + }, + "generated_module_03": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [ + { + "name": "eval.tests.test_cli_usage.test_empty_argv_variable_cases", + "reasons": [ + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_cli_usage.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_cli_usage.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_cli_usage.test_usage_mentions_transfer_list_and_dat", + "reasons": [ + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_cli_usage.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_commands.test_blank_lines_skipped", + "reasons": [ + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_commands.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_commands.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_commands.test_diff_with_only_tgt_range_passes_parsing", + "reasons": [ + { + "id": "assertion_disjunction", + "message": "pytest assertion accepts alternatives with or", + "path": "eval/tests/test_commands.py", + "repair_hint": "Assert one exact expected outcome instead of accepting alternative outcomes with or.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_commands.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_commands.test_free_recognized_in_v1", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_commands.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_commands.test_leading_double_space_before_command", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_commands.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_commands.test_multiple_spaces_break_tokenization", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_commands.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_commands.test_single_space_separates_fields", + "reasons": [ + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_commands.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_commands.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_commands.test_stash_recognized_in_v1_dispatch", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_commands.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_io_files.test_blockdev_missing_reports_errno", + "reasons": [ + { + "id": "assertion_disjunction", + "message": "pytest assertion accepts alternatives with or", + "path": "eval/tests/test_io_files.py", + "repair_hint": "Assert one exact expected outcome instead of accepting alternative outcomes with or.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_io_files.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_io_files.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_io_files.test_cache_dir_left_behind_on_header_error", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_io_files.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_io_files.test_erase_aliases_zero", + "reasons": [ + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_io_files.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_io_files.test_new_writes_new_data_stream", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_io_files.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_io_files.test_patch_stream_missing_segfaults", + "reasons": [ + { + "id": "returncode_in_list", + "message": "pytest test accepts multiple return codes", + "path": "eval/tests/test_io_files.py", + "repair_hint": "Assert the exact expected exit code and the corresponding observable output.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_io_files.test_progress_file_created_and_filled", + "reasons": [ + { + "id": "assertion_disjunction", + "message": "pytest assertion accepts alternatives with or", + "path": "eval/tests/test_io_files.py", + "repair_hint": "Assert one exact expected outcome instead of accepting alternative outcomes with or.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_io_files.test_zero_without_write_no_change", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_io_files.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_transfer_parse.test_empty_list_aborts_before_any_command_dispatch", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_transfer_parse.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_transfer_parse.test_invalid_block_count_aborts[hex]", + "reasons": [ + { + "detail": "AssertionError: assert 'Done with error code: 100' in 'performing update\\ncreating cache dir cache\\ncache dir: cache\\nblockimg version is 1\\nwrote 0 blocks; expected 16\\nstashed 0 blocks\\nmax alloc ne", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_transfer_parse.test_single_empty_line_treated_as_zero_lines", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_transfer_parse.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_transfer_parse.test_two_lines_but_empty_second_line_aborts", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_transfer_parse.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_transfer_parse.test_unexpected_transfer_list_version[alpha]", + "reasons": [ + { + "detail": "AssertionError: BlockImageUpdate timed out", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_transfer_parse.test_unexpected_transfer_list_version[decimal]", + "reasons": [ + { + "detail": "AssertionError: BlockImageUpdate timed out", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_transfer_parse.test_unexpected_transfer_list_version[hex]", + "reasons": [ + { + "detail": "AssertionError: BlockImageUpdate timed out", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_transfer_parse.test_unexpected_transfer_list_version[letter-v]", + "reasons": [ + { + "detail": "AssertionError: BlockImageUpdate timed out", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_transfer_parse.test_unexpected_transfer_list_version[nine]", + "reasons": [ + { + "detail": "AssertionError: executable segfaulted (rc=-11); stdout='performing update\\ncreating cache dir cache\\ncache dir: cache\\nunexpected transfer list version [9]\\nDone with error code: -1\\n' assert not True", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_transfer_parse.test_unexpected_transfer_list_version[trailing-space]", + "reasons": [ + { + "detail": "AssertionError: BlockImageUpdate timed out", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_transfer_parse.test_valid_version_parses[leading-space]", + "reasons": [ + { + "detail": "AssertionError: BlockImageUpdate timed out", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_transfer_parse.test_valid_version_parses[leading-zero]", + "reasons": [ + { + "detail": "AssertionError: BlockImageUpdate timed out", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_transfer_parse.test_valid_version_parses[v1]", + "reasons": [ + { + "detail": "AssertionError: BlockImageUpdate timed out", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_transfer_parse.test_valid_version_parses[v2]", + "reasons": [ + { + "detail": "AssertionError: BlockImageUpdate timed out", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_transfer_parse.test_valid_version_parses[v3]", + "reasons": [ + { + "detail": "AssertionError: BlockImageUpdate timed out", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_transfer_parse.test_valid_version_parses[v4]", + "reasons": [ + { + "detail": "AssertionError: BlockImageUpdate timed out", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_transfer_parse.test_version2_bad_stash_max_blocks[alpha]", + "reasons": [ + { + "detail": "AssertionError: BlockImageUpdate timed out", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_transfer_parse.test_version2_bad_stash_max_blocks[empty]", + "reasons": [ + { + "detail": "AssertionError: BlockImageUpdate timed out", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_transfer_parse.test_version2_bad_stash_max_blocks[float]", + "reasons": [ + { + "detail": "AssertionError: BlockImageUpdate timed out", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_transfer_parse.test_version2_bad_stash_max_blocks[negative]", + "reasons": [ + { + "detail": "AssertionError: BlockImageUpdate timed out", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_transfer_parse.test_version2_bad_stash_max_blocks[trailing-space]", + "reasons": [ + { + "detail": "AssertionError: BlockImageUpdate timed out", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_transfer_parse.test_version2_plus_too_few_lines_fails[three-lines]", + "reasons": [ + { + "detail": "AssertionError: BlockImageUpdate timed out", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_transfer_parse.test_version2_plus_too_few_lines_fails[two-lines]", + "reasons": [ + { + "detail": "AssertionError: BlockImageUpdate timed out", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_transfer_parse.test_version2_plus_too_few_lines_fails[v3-three-lines]", + "reasons": [ + { + "detail": "AssertionError: BlockImageUpdate timed out", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_transfer_parse.test_version2_plus_too_few_lines_fails[v4-two-lines]", + "reasons": [ + { + "detail": "AssertionError: BlockImageUpdate timed out", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_transfer_parse.test_version2_stash_max_parses[leading-space]", + "reasons": [ + { + "detail": "AssertionError: BlockImageUpdate timed out", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_transfer_parse.test_version2_stash_max_parses[one-block]", + "reasons": [ + { + "detail": "AssertionError: BlockImageUpdate timed out", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_transfer_parse.test_version2_stash_max_parses[zero]", + "reasons": [ + { + "detail": "AssertionError: BlockImageUpdate timed out", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_transfer_parse.test_zero_block_count_returns_early", + "reasons": [ + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_transfer_parse.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_transfer_parse.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + } + ], + "tests": [ + "eval.tests.test_cli_usage.test_empty_argv_variable_cases", + "eval.tests.test_cli_usage.test_four_args_proceeds_not_usage", + "eval.tests.test_cli_usage.test_usage_does_not_create_files", + "eval.tests.test_cli_usage.test_usage_mentions_transfer_list_and_dat", + "eval.tests.test_cli_usage.test_usage_on_insufficient_args[no-args]", + "eval.tests.test_cli_usage.test_usage_on_insufficient_args[one-arg]", + "eval.tests.test_cli_usage.test_usage_on_insufficient_args[three-args]", + "eval.tests.test_cli_usage.test_usage_on_insufficient_args[two-args]", + "eval.tests.test_commands.test_blank_lines_skipped", + "eval.tests.test_commands.test_diff_missing_offset_or_length[bsdiff-bad-offset]", + "eval.tests.test_commands.test_diff_missing_offset_or_length[bsdiff-missing-len]", + "eval.tests.test_commands.test_diff_missing_offset_or_length[bsdiff-no-args]", + "eval.tests.test_commands.test_diff_missing_offset_or_length[imgdiff-bad-len]", + "eval.tests.test_commands.test_diff_missing_offset_or_length[imgdiff-no-args]", + "eval.tests.test_commands.test_diff_with_only_tgt_range_passes_parsing", + "eval.tests.test_commands.test_free_recognized_in_v1", + "eval.tests.test_commands.test_invalid_range_aborts[count-one]", + "eval.tests.test_commands.test_invalid_range_aborts[count-zero]", + "eval.tests.test_commands.test_invalid_range_aborts[empty-range]", + "eval.tests.test_commands.test_invalid_range_aborts[extra-token]", + "eval.tests.test_commands.test_invalid_range_aborts[negative-range]", + "eval.tests.test_commands.test_invalid_range_aborts[non-numeric]", + "eval.tests.test_commands.test_invalid_range_aborts[odd-count]", + "eval.tests.test_commands.test_invalid_range_aborts[too-few]", + "eval.tests.test_commands.test_known_command_handler_rejects_bare_token[erase-no-args]", + "eval.tests.test_commands.test_known_command_handler_rejects_bare_token[free-no-args]", + "eval.tests.test_commands.test_known_command_handler_rejects_bare_token[move-no-args]", + "eval.tests.test_commands.test_known_command_handler_rejects_bare_token[new-no-args]", + "eval.tests.test_commands.test_known_command_handler_rejects_bare_token[stash-no-args]", + "eval.tests.test_commands.test_known_command_handler_rejects_bare_token[zero-no-args]", + "eval.tests.test_commands.test_known_commands_dispatch[erase]", + "eval.tests.test_commands.test_known_commands_dispatch[move]", + "eval.tests.test_commands.test_known_commands_dispatch[new]", + "eval.tests.test_commands.test_known_commands_dispatch[zero]", + "eval.tests.test_commands.test_leading_double_space_before_command", + "eval.tests.test_commands.test_multiple_spaces_break_tokenization", + "eval.tests.test_commands.test_single_space_separates_fields", + "eval.tests.test_commands.test_stash_recognized_in_v1_dispatch", + "eval.tests.test_commands.test_unexpected_command_rejected[dash-cmd]", + "eval.tests.test_commands.test_unexpected_command_rejected[numeric-cmd]", + "eval.tests.test_commands.test_unexpected_command_rejected[underscore]", + "eval.tests.test_commands.test_unexpected_command_rejected[unknownword]", + "eval.tests.test_commands.test_unexpected_command_rejected[uppercase]", + "eval.tests.test_io_files.test_blockdev_missing_reports_errno", + "eval.tests.test_io_files.test_cache_dir_created_then_removed_on_success", + "eval.tests.test_io_files.test_cache_dir_exists_previously_is_reused", + "eval.tests.test_io_files.test_cache_dir_left_behind_on_header_error", + "eval.tests.test_io_files.test_erase_aliases_zero", + "eval.tests.test_io_files.test_new_writes_new_data_stream", + "eval.tests.test_io_files.test_patch_stream_missing_segfaults", + "eval.tests.test_io_files.test_progress_file_created_and_filled", + "eval.tests.test_io_files.test_zero_multiple_ranges", + "eval.tests.test_io_files.test_zero_without_write_no_change", + "eval.tests.test_io_files.test_zero_zeroes_blocks_in_place", + "eval.tests.test_transfer_parse.test_block_count_parses_valid_uint[leading-space]", + "eval.tests.test_transfer_parse.test_block_count_parses_valid_uint[leading-zero]", + "eval.tests.test_transfer_parse.test_block_count_parses_valid_uint[million]", + "eval.tests.test_transfer_parse.test_block_count_parses_valid_uint[zero]", + "eval.tests.test_transfer_parse.test_empty_list_aborts_before_any_command_dispatch", + "eval.tests.test_transfer_parse.test_invalid_block_count_aborts[alpha]", + "eval.tests.test_transfer_parse.test_invalid_block_count_aborts[empty]", + "eval.tests.test_transfer_parse.test_invalid_block_count_aborts[float]", + "eval.tests.test_transfer_parse.test_invalid_block_count_aborts[hex]", + "eval.tests.test_transfer_parse.test_invalid_block_count_aborts[negative]", + "eval.tests.test_transfer_parse.test_invalid_block_count_aborts[trailing-space]", + "eval.tests.test_transfer_parse.test_invalid_block_count_aborts[two-nums]", + "eval.tests.test_transfer_parse.test_single_empty_line_treated_as_zero_lines", + "eval.tests.test_transfer_parse.test_too_few_lines_aborts_with_args_parsing_failure[bad-version-only]", + "eval.tests.test_transfer_parse.test_too_few_lines_aborts_with_args_parsing_failure[empty-list]", + "eval.tests.test_transfer_parse.test_too_few_lines_aborts_with_args_parsing_failure[single-blank-line]", + "eval.tests.test_transfer_parse.test_too_few_lines_aborts_with_args_parsing_failure[version-newline]", + "eval.tests.test_transfer_parse.test_too_few_lines_aborts_with_args_parsing_failure[version-only]", + "eval.tests.test_transfer_parse.test_two_lines_but_empty_second_line_aborts", + "eval.tests.test_transfer_parse.test_unexpected_transfer_list_version[alpha]", + "eval.tests.test_transfer_parse.test_unexpected_transfer_list_version[decimal]", + "eval.tests.test_transfer_parse.test_unexpected_transfer_list_version[five]", + "eval.tests.test_transfer_parse.test_unexpected_transfer_list_version[fortytwo]", + "eval.tests.test_transfer_parse.test_unexpected_transfer_list_version[hex]", + "eval.tests.test_transfer_parse.test_unexpected_transfer_list_version[letter-v]", + "eval.tests.test_transfer_parse.test_unexpected_transfer_list_version[negone]", + "eval.tests.test_transfer_parse.test_unexpected_transfer_list_version[nine]", + "eval.tests.test_transfer_parse.test_unexpected_transfer_list_version[trailing-space]", + "eval.tests.test_transfer_parse.test_unexpected_transfer_list_version[zero]", + "eval.tests.test_transfer_parse.test_valid_version_parses[leading-space]", + "eval.tests.test_transfer_parse.test_valid_version_parses[leading-zero]", + "eval.tests.test_transfer_parse.test_valid_version_parses[v1]", + "eval.tests.test_transfer_parse.test_valid_version_parses[v2]", + "eval.tests.test_transfer_parse.test_valid_version_parses[v3]", + "eval.tests.test_transfer_parse.test_valid_version_parses[v4]", + "eval.tests.test_transfer_parse.test_version2_bad_stash_max_blocks[alpha]", + "eval.tests.test_transfer_parse.test_version2_bad_stash_max_blocks[empty]", + "eval.tests.test_transfer_parse.test_version2_bad_stash_max_blocks[float]", + "eval.tests.test_transfer_parse.test_version2_bad_stash_max_blocks[negative]", + "eval.tests.test_transfer_parse.test_version2_bad_stash_max_blocks[trailing-space]", + "eval.tests.test_transfer_parse.test_version2_plus_too_few_lines_fails[three-lines]", + "eval.tests.test_transfer_parse.test_version2_plus_too_few_lines_fails[two-lines]", + "eval.tests.test_transfer_parse.test_version2_plus_too_few_lines_fails[v3-three-lines]", + "eval.tests.test_transfer_parse.test_version2_plus_too_few_lines_fails[v4-two-lines]", + "eval.tests.test_transfer_parse.test_version2_stash_max_parses[leading-space]", + "eval.tests.test_transfer_parse.test_version2_stash_max_parses[one-block]", + "eval.tests.test_transfer_parse.test_version2_stash_max_parses[zero]", + "eval.tests.test_transfer_parse.test_zero_block_count_returns_early" + ] + } + }, + "commit": "1071fecb34d2da535211d6c840c138b48ad57402", + "data_source": "synthetic_programgym", + "difficulty": "easy", + "difficulty_score": 1.8920946026904804, + "eval_clean_hashes": [ + "f6fcff4904335210790685e00f6dd1a0c6d92450be8b7003d7b83e399cec4a62" + ], + "input_record": { + "commit": "1071fecb34d2da535211d6c840c138b48ad57402", + "difficulty": "easy", + "difficulty_code_lines": 7800, + "difficulty_has_tests": false, + "difficulty_product_code_lines": 7800, + "difficulty_runtime_deps": 0, + "difficulty_score": 1.8920946026904804, + "difficulty_test_code_lines": 0, + "full_name": "erfanoabdi/imgpatchtools", + "input_joern_zip": "cpp_joern/erfanoabdi__imgpatchtools.zip", + "joern_status": true, + "joern_time": 7.414978374959901, + "language": "cpp", + "pb_match": [ + { + "pb_fullname": "ip7z/7zip", + "rank": 319, + "similarity": 0.41575074195861816 + } + ], + "repo_path": "cpp/erfanoabdi__imgpatchtools", + "source": "commit:1071fecb34d2da535211d6c840c138b48ad57402", + "status": "done", + "url": "https://github.com/erfanoabdi/imgpatchtools" + }, + "instance_id": "erfanoabdi__imgpatchtools.1071fec", + "language": "cpp", + "module_iterations": [ + { + "actual_iterations": 5, + "branch_name": "generated_module_01", + "iteration_limit": 5, + "module_index": 1, + "module_kind": "source", + "termination_reason": "max_iterations" + }, + { + "actual_iterations": 5, + "branch_name": "generated_module_02", + "iteration_limit": 5, + "module_index": 2, + "module_kind": "source", + "termination_reason": "max_iterations" + }, + { + "actual_iterations": 5, + "branch_name": "generated_module_03", + "iteration_limit": 5, + "module_index": 3, + "module_kind": "source", + "termination_reason": "max_iterations" + }, + { + "actual_iterations": 5, + "branch_name": "generated_module_04", + "iteration_limit": 5, + "module_index": 4, + "module_kind": "source", + "termination_reason": "max_iterations" + } + ], + "repository": "erfanoabdi/imgpatchtools" +}