diff --git "a/nomango--configor.3d908fa/tests/programgym_task.json" "b/nomango--configor.3d908fa/tests/programgym_task.json" new file mode 100644--- /dev/null +++ "b/nomango--configor.3d908fa/tests/programgym_task.json" @@ -0,0 +1,4028 @@ +{ + "branches": { + "generated_module_01": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [ + { + "name": "eval.tests.test_document_encoding.test_isolated_request_body_matches_golden", + "reasons": [ + { + "id": "golden_no_equality", + "message": "pytest test references golden data without equality comparison", + "path": "eval/tests/test_document_encoding.py", + "repair_hint": "Compare observed output to golden data with equality after any explicit normalization.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_document_encoding.test_isolated_response_body_matches_golden", + "reasons": [ + { + "id": "golden_no_equality", + "message": "pytest test references golden data without equality comparison", + "path": "eval/tests/test_document_encoding.py", + "repair_hint": "Compare observed output to golden data with equality after any explicit normalization.", + "severity": "error", + "stage": "static_lint" + } + ] + } + ], + "tests": [ + "eval.tests.test_document_encoding.test_delimiters_balanced_within_the_response_document", + "eval.tests.test_document_encoding.test_isolated_request_body_matches_golden", + "eval.tests.test_document_encoding.test_isolated_response_body_matches_golden", + "eval.tests.test_document_encoding.test_no_backslash_or_unicode_escape_anywhere", + "eval.tests.test_document_encoding.test_no_json_body_line_is_blank", + "eval.tests.test_document_encoding.test_no_space_around_any_key_colon", + "eval.tests.test_document_encoding.test_object_member_counts_across_the_response", + "eval.tests.test_document_encoding.test_request_round_trips_to_exact_integer", + "eval.tests.test_document_encoding.test_response_documents_parse_to_the_exact_seeded_tree", + "eval.tests.test_document_encoding.test_stream_decomposes_into_five_fixed_cells", + "eval.tests.test_document_encoding.test_string_values_are_emitted_as_single_bare_quotations", + "eval.tests.test_document_encoding.test_user_name_is_the_final_member_and_last_scalar", + "eval.tests.test_document_invariants.test_each_document_reencodes_to_canonical_four_space_json", + "eval.tests.test_document_invariants.test_every_json_key_is_a_nonempty_identifier", + "eval.tests.test_document_invariants.test_every_line_indents_four_spaces_per_nesting_depth", + "eval.tests.test_document_invariants.test_no_leaf_scalar_is_empty_string", + "eval.tests.test_document_invariants.test_no_trailing_comma_before_a_closing_delimiter", + "eval.tests.test_document_invariants.test_output_charset_is_printable_ascii_plus_lf", + "eval.tests.test_document_invariants.test_response_and_request_delimiters_are_balanced", + "eval.tests.test_document_invariants.test_response_scalar_values_form_an_exact_census", + "eval.tests.test_formatting.test_response_arrays_end_with_closing_bracket", + "eval.tests.test_formatting.test_response_indent_is_four_spaces", + "eval.tests.test_formatting.test_response_permission_array_members_ordered", + "eval.tests.test_formatting.test_response_role_key_order_is_stable", + "eval.tests.test_golden_output.test_json_content_lines_have_no_trailing_whitespace", + "eval.tests.test_golden_output.test_stdout_matches_golden_exactly", + "eval.tests.test_golden_output.test_stdout_not_empty", + "eval.tests.test_golden_output.test_stdout_uses_unix_line_endings", + "eval.tests.test_request_structure.test_request_echo_is_single_object_with_user_id", + "eval.tests.test_request_structure.test_request_user_id_matches_response_user_id", + "eval.tests.test_response_structure.test_response_all_scalar_types_are_json_native", + "eval.tests.test_response_structure.test_response_first_role_code_and_permissions", + "eval.tests.test_response_structure.test_response_is_single_json_object", + "eval.tests.test_response_structure.test_response_not_hard_coded_placeholder", + "eval.tests.test_response_structure.test_response_role_list_total_permissions", + "eval.tests.test_response_structure.test_response_second_role_code_and_permissions", + "eval.tests.test_response_structure.test_response_user_info_fields", + "eval.tests.test_robustness.test_exit_code_is_zero", + "eval.tests.test_robustness.test_ignores_command_line_arguments", + "eval.tests.test_robustness.test_ignores_stdin", + "eval.tests.test_robustness.test_output_independent_of_working_directory", + "eval.tests.test_robustness.test_repeated_runs_are_identical", + "eval.tests.test_robustness.test_resolved_executable_is_a_real_eval_target", + "eval.tests.test_robustness.test_stdout_stays_on_stdout_and_stderr_stays_empty", + "eval.tests.test_robustness.test_terminates_within_timeout_without_hanging", + "eval.tests.test_section_layout.test_each_section_header_appears_exactly_once", + "eval.tests.test_section_layout.test_exactly_one_blank_line_separates_the_sections", + "eval.tests.test_section_layout.test_no_tab_bytes_or_carriage_returns_anywhere", + "eval.tests.test_section_layout.test_response_section_is_exactly_428_bytes", + "eval.tests.test_section_layout.test_responses_are_two_nonempty_json_documents_in_order", + "eval.tests.test_section_layout.test_whole_output_is_exactly_475_bytes", + "eval.tests.test_serialization_details.test_document_line_structure_and_section_boundaries", + "eval.tests.test_serialization_details.test_integer_values_serialize_as_plain_decimal", + "eval.tests.test_serialization_details.test_request_echo_is_exact_source_literal", + "eval.tests.test_serialization_details.test_stdout_is_two_well_formed_json_documents", + "eval.tests.test_serialization_details.test_user_info_serializes_roles_then_id_then_name" + ] + }, + "generated_module_02": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [ + { + "name": "eval.tests.test_driver_comments_robustness.test_block_comment_after_open_brace", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + }, + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_driver_comments_robustness.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_driver_comments_robustness.test_block_comment_before_value", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + }, + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_driver_comments_robustness.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_driver_comments_robustness.test_block_comment_multiline", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + }, + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_driver_comments_robustness.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_driver_comments_robustness.test_boolean_and_null_in_nested", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + }, + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_driver_comments_robustness.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_driver_comments_robustness.test_comment_after_comma_before_value_is_error", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + }, + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_driver_comments_robustness.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_driver_comments_robustness.test_crlf_line_endings_accepted", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + }, + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_driver_comments_robustness.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_driver_comments_robustness.test_decimal_point_only_is_error", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_comments_robustness.test_exponent_only", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_comments_robustness.test_huge_object_with_many_keys", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + }, + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_driver_comments_robustness.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_driver_comments_robustness.test_huge_string_value", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + }, + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_driver_comments_robustness.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_driver_comments_robustness.test_leading_plus_float", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + }, + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_driver_comments_robustness.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_driver_comments_robustness.test_line_comment_before_value", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + }, + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_driver_comments_robustness.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_driver_comments_robustness.test_line_comment_between_container_items", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + }, + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_driver_comments_robustness.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_driver_comments_robustness.test_line_comment_then_eof_is_empty", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + }, + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_driver_comments_robustness.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_driver_comments_robustness.test_lone_slash_is_error", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + }, + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_driver_comments_robustness.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_driver_comments_robustness.test_nested_comments_not_supported", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_comments_robustness.test_number_inside_object_and_array", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + }, + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_driver_comments_robustness.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_driver_comments_robustness.test_unterminated_block_comment_is_error", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + }, + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_driver_comments_robustness.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_driver_containers.test_array_comma_before_closing_is_error", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_containers.test_array_missing_comma_is_error", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + }, + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_driver_containers.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_driver_containers.test_array_parsing[[ ]-[]]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_containers.test_array_parsing[[\"x\",]-[\"x\"]]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_containers.test_array_parsing[[1, 2, 3]-[1,2,3]]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_containers.test_array_parsing[[1,2,3]-[1,2,3]]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_containers.test_array_parsing[[1,2,]-[1,2]]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_containers.test_array_parsing[[1,2.5,true,null,\"s\"]-[1,2.5,true,null,\"s\"]]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_containers.test_array_parsing[[1]-[1]]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_containers.test_array_parsing[[[1],[2,3]]-[[1],[2,3]]]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_containers.test_array_parsing[[[]]-[[]]]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_containers.test_array_parsing[[]-[]]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_containers.test_array_parsing[[{\"a\":1}]-[{\"a\":1}]]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_containers.test_deep_nesting_parses_fully", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + }, + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_driver_containers.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_driver_containers.test_large_flat_array_of_ints", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + }, + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_driver_containers.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_driver_containers.test_multiple_top_level_values_rejected", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + }, + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_driver_containers.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_driver_containers.test_nested_array_mixed_types", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + }, + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_driver_containers.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_driver_containers.test_object_duplicate_key_first_wins", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + }, + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_driver_containers.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_driver_containers.test_object_duplicate_key_three", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + }, + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_driver_containers.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_driver_containers.test_object_missing_colon_is_error", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + }, + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_driver_containers.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_driver_containers.test_object_missing_value_separator_is_error", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + }, + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_driver_containers.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_driver_containers.test_object_non_string_key_is_error", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_containers.test_object_parsing[{ }-{}]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_containers.test_object_parsing[{\"\":1}-{\"\":1}]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_containers.test_object_parsing[{\"a\": 1}-{\"a\":1}]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_containers.test_object_parsing[{\"a\":1,\"b\":2}-{\"a\":1,\"b\":2}]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_containers.test_object_parsing[{\"a\":1}-{\"a\":1}]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_containers.test_object_parsing[{\"a\":[1,2]}-{\"a\":[1,2]}]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_containers.test_object_parsing[{\"a\":null}-{\"a\":null}]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_containers.test_object_parsing[{\"a\":{}}-{\"a\":{}}]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_containers.test_object_parsing[{\"z\":1,\"a\":2}-{\"a\":2,\"z\":1}]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_containers.test_object_parsing[{}-{}]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_containers.test_object_trailing_comma_tolerated", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + }, + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_driver_containers.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_driver_containers.test_unclosed_array_is_error", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_containers.test_unclosed_object_is_error", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + }, + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_driver_containers.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_driver_containers.test_whitespace_and_newlines_do_not_change_value", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + }, + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_driver_containers.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_driver_encoding_decode.test_escaped_codepoint_valid[0065-e]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_encoding_decode.test_escaped_codepoint_valid[007a-z]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_encoding_decode.test_escaped_codepoint_valid[00E9-\\xe9]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_encoding_decode.test_escaped_codepoint_valid[00e9-\\xe9]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_encoding_decode.test_escaped_codepoint_valid[20ac-\\u20ac]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_encoding_decode.test_escaped_codepoint_valid[4e2d-\\u4e2d]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_encoding_decode.test_escaped_control_backslash_sequences_through_doi", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_encoding_decode.test_invalid_hex_escape[\"\\\\u0g01\"-value deserialization error: '\\\\u' must be followed by 4 hex digits, but got '\\\\u0067']", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_encoding_decode.test_invalid_hex_escape[\"\\\\u12\"-value deserialization error: '\\\\u' must be followed by 4 hex digits, but got '\\\\u0022']", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_encoding_decode.test_invalid_hex_escape[\"\\\\uZZZZ\"-value deserialization error: '\\\\u' must be followed by 4 hex digits, but got '\\\\u005A']", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_encoding_decode.test_lone_continuation_byte_is_lenient", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + }, + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_driver_encoding_decode.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_driver_encoding_decode.test_lone_lead_surrogate_is_error", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_encoding_decode.test_lone_trail_surrogate_is_valid", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_encoding_decode.test_overlong_two_byte_decodes_to_nul", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + }, + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_driver_encoding_decode.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_driver_encoding_decode.test_raw_2byte_and_3byte_acceptance", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_encoding_decode.test_raw_3byte_ffff", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_encoding_decode.test_raw_4byte_max_codepoint", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_encoding_decode.test_raw_control_char_in_string_is_error[\"\\x01\"-value deserialization error: invalid control character '\\\\u0001']", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_encoding_decode.test_raw_control_char_in_string_is_error[\"\\x08\"-value deserialization error: invalid control character '\\\\u0008']", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_encoding_decode.test_raw_control_char_in_string_is_error[\"\\x1f\"-value deserialization error: invalid control character '\\\\u001F']", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_encoding_decode.test_raw_newline_inside_string_is_error", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + }, + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_driver_encoding_decode.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_driver_encoding_decode.test_raw_utf8_in_key_roundtrip", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_encoding_decode.test_surrogate_pair_followed_by_more_text", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_encoding_decode.test_surrogate_pair_to_musical_symbol", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_encoding_decode.test_utf8_decode_overflow_sets_failbit[\"\\xf4\\x90\\x80\\x80\"-value deserialization error: decoding failed with codepoint '\\\\u110000']", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_encoding_decode.test_utf8_decode_overflow_sets_failbit[\"\\xf9\\x80\\x80\\x80\\x80\"-value deserialization error: decoding failed with codepoint '\\\\u1000000']", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_encoding_decode.test_utf8_decode_overflow_sets_failbit[\"\\xfe\\x80\\x80\\x80\\x80\"-value deserialization error: decoding failed with codepoint '\\\\u7FFFFFA2']", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_encoding_decode.test_utf8_f8_lead_decodes_then_control_nul", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + }, + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_driver_encoding_decode.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_driver_encoding_decode.test_utf8_surrogate_encoded_sequence_is_lenient", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_expanded_behavior.test_container_separator_errors[[1,,2]-value deserialization error: unexpected token, expect 'end_array', but got 'value_separator']", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_expanded_behavior.test_container_separator_errors[{\"a\":1,,\"b\":2}-value deserialization error: unexpected token, expect 'end_object', but got 'value_separator']", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_expanded_behavior.test_container_separator_errors[{\"a\":1{\"b\":2}}-value deserialization error: unexpected token, expect 'end_object', but got 'begin_object']", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_expanded_behavior.test_container_separator_errors[{\"a\"::1}-value deserialization error: unexpected token 'name_separator']", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_expanded_behavior.test_container_separator_errors[{\"a\":}-value deserialization error: unexpected token 'end_object']", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_expanded_behavior.test_container_separator_errors[{,}-value deserialization error: unexpected token, expect 'end_object', but got 'value_separator']", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_expanded_behavior.test_deeply_nested_arrays_parse[200]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_expanded_behavior.test_deeply_nested_arrays_parse[60]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_expanded_behavior.test_deeply_nested_objects_parse", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + }, + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_driver_expanded_behavior.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_driver_expanded_behavior.test_empty_exponent_sign_forms[+1e+--9223372036854775808.0]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_expanded_behavior.test_empty_exponent_sign_forms[-1e--0.0]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_expanded_behavior.test_empty_exponent_sign_forms[1E+--9223372036854775808.0]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_expanded_behavior.test_empty_exponent_sign_forms[1E--0.0]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_expanded_behavior.test_form_feed_before_value_is_rejected", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + }, + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_driver_expanded_behavior.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_driver_expanded_behavior.test_leading_zero_fraction_is_split", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + }, + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_driver_expanded_behavior.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_driver_expanded_behavior.test_leading_zero_with_exponent_is_invalid[-0e-]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_expanded_behavior.test_leading_zero_with_exponent_is_invalid[-0e2]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_expanded_behavior.test_leading_zero_with_exponent_is_invalid[0E5]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_expanded_behavior.test_leading_zero_with_exponent_is_invalid[0E]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_expanded_behavior.test_leading_zero_with_exponent_is_invalid[0e0]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_expanded_behavior.test_single_escape_round_trip[\"\\\\\\\\\"-\"\\\\\\\\\"]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_expanded_behavior.test_single_escape_round_trip[\"\\\\b\"-\"\\\\b\"]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_expanded_behavior.test_single_escape_round_trip[\"\\\\f\"-\"\\\\f\"]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_expanded_behavior.test_single_escape_round_trip[\"\\\\n\"-\"\\\\n\"]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_expanded_behavior.test_single_escape_round_trip[\"\\\\r\"-\"\\\\r\"]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_expanded_behavior.test_single_escape_round_trip[\"\\\\t\"-\"\\\\t\"]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_expanded_behavior.test_single_escape_round_trip[\"a\\\\/b\"-\"a/b\"]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_expanded_behavior.test_single_escape_round_trip[\"tab\\\\there\"-\"tab\\\\there\"]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_expanded_behavior.test_standard_whitespace_is_ignored[ \\n [ 1 , 2 ] -[1,2]]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_expanded_behavior.test_standard_whitespace_is_ignored[\\r\\n\\t {} -{}]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_expanded_behavior.test_standard_whitespace_is_ignored[\\t42\\r\\n-42]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_expanded_behavior.test_standard_whitespace_is_ignored[{\"a\" : 1, \"b\" : 2}-{\"a\":1,\"b\":2}]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_expanded_behavior.test_surrogate_pair_in_key", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + }, + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_driver_expanded_behavior.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_driver_expanded_behavior.test_top_level_multiple_values_after_array_rejected", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + }, + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_driver_expanded_behavior.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_driver_expanded_behavior.test_trailing_separator_still_valid", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_expanded_behavior.test_two_digit_int_part_with_exponent", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + }, + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_driver_expanded_behavior.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_driver_expanded_behavior.test_unicode_escape_in_key", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + }, + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_driver_expanded_behavior.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_driver_expanded_behavior.test_upper_and_lower_hex_escape_in_key", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + }, + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_driver_expanded_behavior.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_driver_expanded_behavior.test_vertical_tab_before_value_is_rejected", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + }, + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_driver_expanded_behavior.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_driver_golden_example.test_golden_example_contains_bound_role_tree", + "reasons": [ + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_driver_golden_example.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_driver_golden_example.test_golden_example_exact_stdout", + "reasons": [ + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_driver_golden_example.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_driver_golden_example.test_golden_example_request_block", + "reasons": [ + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_driver_golden_example.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_driver_number_tokens.test_bare_dot_is_error", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_number_tokens.test_empty_exponent_invalid_number_message", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + }, + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_driver_number_tokens.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_driver_number_tokens.test_empty_exponent_minus_wores_to_zero", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + }, + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_driver_number_tokens.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_driver_number_tokens.test_empty_exponent_plus_wraps_to_min_int64_float", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + }, + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_driver_number_tokens.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_driver_number_tokens.test_float_with_two_fractional_digits_precision", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + }, + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_driver_number_tokens.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_driver_number_tokens.test_large_exponent_wraps_float", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + }, + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_driver_number_tokens.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_driver_number_tokens.test_leading_zero_with_exponent_is_error[-0e2]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_number_tokens.test_leading_zero_with_exponent_is_error[0E5]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_number_tokens.test_leading_zero_with_exponent_is_error[0e0]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_number_tokens.test_leading_zero_with_exponent_is_error[0e5]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_number_tokens.test_leading_zero_with_trailing_digits_is_integer", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + }, + { + "id": "assertion_disjunction", + "message": "pytest assertion accepts alternatives with or", + "path": "eval/tests/test_driver_number_tokens.py", + "repair_hint": "Assert one exact expected outcome instead of accepting alternative outcomes with or.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_driver_number_tokens.test_number_tokens_inside_array", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + }, + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_driver_number_tokens.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_driver_number_tokens.test_signed_and_uppercase_exponent_floats[+3.25e1-32.5]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_number_tokens.test_signed_and_uppercase_exponent_floats[-1E+3--1000.0]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_number_tokens.test_signed_and_uppercase_exponent_floats[-2.5E-2--0.025]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_number_tokens.test_signed_and_uppercase_exponent_floats[1.5e2-150.0]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_number_tokens.test_signed_and_uppercase_exponent_floats[1E-3-0.001]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_number_tokens.test_signed_integer_and_float_tokens[+0-0]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_number_tokens.test_signed_integer_and_float_tokens[+0.25-0.25]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_number_tokens.test_signed_integer_and_float_tokens[+23-23]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_number_tokens.test_signed_integer_and_float_tokens[-0.5--0.5]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_number_tokens.test_signed_integer_and_float_tokens[-123--123]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_number_tokens.test_signed_integer_and_float_tokens[42-42]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_number_tokens.test_small_exponent_underflows", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + }, + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_driver_number_tokens.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_driver_number_tokens.test_tiny_fraction_exponent", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + }, + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_driver_number_tokens.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_driver_number_tokens.test_trailing_dot_invalid_float", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + }, + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_driver_number_tokens.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_driver_scalars.test_empty_input_is_parse_error", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + }, + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_driver_scalars.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_driver_scalars.test_float_decimals_and_exponents_reject_trailing_dot", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + }, + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_driver_scalars.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_driver_scalars.test_float_overflow_wraps_to_negative_min", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_scalars.test_float_scalars[-0.5--0.5]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_scalars.test_float_scalars[-1e-3--0.001]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_scalars.test_float_scalars[0.0-0.0]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_scalars.test_float_scalars[1.5e2-150.0]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_scalars.test_float_scalars[100.25-100.25]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_scalars.test_float_scalars[1E+2-100.0]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_scalars.test_float_scalars[1e-308-1e-308]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_scalars.test_float_scalars[1e10-10000000000.0]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_scalars.test_float_scalars[3.14-3.14]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_scalars.test_float_scalars[5e-3-0.005]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_scalars.test_integer_scalars[+5-5]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_scalars.test_integer_scalars[-0-0]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_scalars.test_integer_scalars[-1--1]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_scalars.test_integer_scalars[-2147483648--2147483648]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_scalars.test_integer_scalars[-42--42]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_scalars.test_integer_scalars[-9223372036854775808--9223372036854775808]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_scalars.test_integer_scalars[0-0]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_scalars.test_integer_scalars[1-1]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_scalars.test_integer_scalars[12345678901234567890--6101065172474983726]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_scalars.test_integer_scalars[2147483647-2147483647]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_scalars.test_integer_scalars[42-42]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_scalars.test_integer_scalars[9223372036854775807-9223372036854775807]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_scalars.test_leading_plus_integer", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + }, + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_driver_scalars.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_driver_scalars.test_literal_scalars[false-false]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_scalars.test_literal_scalars[null-null]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_scalars.test_literal_scalars[true-true]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_scalars.test_partial_literal_true_leaves_cutoff_character", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_scalars.test_scalar_parse_errors[ -value deserialization error: unexpected token 'end_of_input']", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_scalars.test_scalar_parse_errors[-value deserialization error: unexpected token 'end_of_input']", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_scalars.test_scalar_parse_errors[07-value deserialization error: unexpected token 'end_of_input']", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_scalars.test_scalar_parse_errors[1 2-value deserialization error: unexpected token 'end_of_input']", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_scalars.test_scalar_parse_errors[1.2.3-value deserialization error: unexpected character '\\\\u002E']", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_scalars.test_scalar_parse_errors[garbage-value deserialization error: unexpected character '\\\\u0067']", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_scalars.test_scalar_parse_errors[true false-value deserialization error: unexpected token 'end_of_input']", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_scalars.test_scalar_parse_errors[trueX-value deserialization error: unexpected character '\\\\u0058']", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_scalars.test_scalar_parse_errors[x-value deserialization error: unexpected character '\\\\u0078']", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_scalars.test_whitespace_around_scalar_is_ignored", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_strings.test_double_quote_escape_sequences[\"\\\\\"\"-\"\\\\\"\"]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_strings.test_double_quote_escape_sequences[\"\\\\/\"-\"/\"]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_strings.test_double_quote_escape_sequences[\"\\\\b\\\\f\\\\n\\\\r\\\\t\"-\"\\\\b\\\\f\\\\n\\\\r\\\\t\"]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_strings.test_double_quote_escape_sequences[\"a\\\\\\\\b\"-\"a\\\\\\\\b\"]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_strings.test_escape_backslash_at_eof_is_error", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + }, + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_driver_strings.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_driver_strings.test_invalid_utf8_sequence_is_lenient_decoded", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_strings.test_lead_lead_surrogate_is_error", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_strings.test_lone_continuation_byte_is_lenient", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_strings.test_lone_lead_surrogate_is_error", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_strings.test_plain_strings[\"\"-\"\"]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_strings.test_plain_strings[\"hello\"-\"hello\"]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_strings.test_plain_strings[\"non-ascii \\xe9\"-\"non-ascii \\xe9\"]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_strings.test_plain_strings[\"with space\"-\"with space\"]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_strings.test_plain_strings['unquoted'-None]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_strings.test_raw_utf8_in_key", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + }, + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_driver_strings.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_driver_strings.test_raw_utf8_multibyte_string_value", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + }, + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_driver_strings.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_driver_strings.test_raw_utf8_two_byte", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + }, + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_driver_strings.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_driver_strings.test_string_followed_by_newline_is_closed", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + }, + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_driver_strings.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_driver_strings.test_string_immediately_closed_is_empty", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + }, + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_driver_strings.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_driver_strings.test_too_few_hex_digits_after_unicode_escape", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + }, + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_driver_strings.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_driver_strings.test_unclosed_string_is_error", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + }, + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_driver_strings.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_driver_strings.test_unicode_escapes[\"A\"-\"A\"]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_strings.test_unicode_escapes[\"\\U0001f600\"-\"\\U0001f600\"]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_strings.test_unicode_escapes[\"\\U0010ffff\"-\"\\U0010ffff\"]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_strings.test_unicode_escapes[\"\\u03b1\"-\"\\u03b1\"]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_strings.test_unicode_escapes[\"\\xe9\"-\"\\xe9\"]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_strings.test_unknown_escape_is_error", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + }, + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_driver_strings.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_driver_strings.test_unknown_escape_many", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + }, + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_driver_strings.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_driver_strings.test_valid_four_hex_is_accepted[\"\\u2aaa\"-2A0]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + }, + { + "name": "eval.tests.test_driver_strings.test_valid_four_hex_is_accepted[\"\\u2aaa\"-2A1]", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + } + ] + } + ], + "tests": [ + "eval.tests.test_driver_comments_robustness.test_block_comment_after_open_brace", + "eval.tests.test_driver_comments_robustness.test_block_comment_before_value", + "eval.tests.test_driver_comments_robustness.test_block_comment_multiline", + "eval.tests.test_driver_comments_robustness.test_boolean_and_null_in_nested", + "eval.tests.test_driver_comments_robustness.test_comment_after_comma_before_value_is_error", + "eval.tests.test_driver_comments_robustness.test_crlf_line_endings_accepted", + "eval.tests.test_driver_comments_robustness.test_decimal_point_only_is_error", + "eval.tests.test_driver_comments_robustness.test_exponent_only", + "eval.tests.test_driver_comments_robustness.test_huge_object_with_many_keys", + "eval.tests.test_driver_comments_robustness.test_huge_string_value", + "eval.tests.test_driver_comments_robustness.test_leading_plus_float", + "eval.tests.test_driver_comments_robustness.test_line_comment_before_value", + "eval.tests.test_driver_comments_robustness.test_line_comment_between_container_items", + "eval.tests.test_driver_comments_robustness.test_line_comment_then_eof_is_empty", + "eval.tests.test_driver_comments_robustness.test_lone_slash_is_error", + "eval.tests.test_driver_comments_robustness.test_nested_comments_not_supported", + "eval.tests.test_driver_comments_robustness.test_number_inside_object_and_array", + "eval.tests.test_driver_comments_robustness.test_unterminated_block_comment_is_error", + "eval.tests.test_driver_containers.test_array_comma_before_closing_is_error", + "eval.tests.test_driver_containers.test_array_missing_comma_is_error", + "eval.tests.test_driver_containers.test_array_parsing[[ ]-[]]", + "eval.tests.test_driver_containers.test_array_parsing[[\"x\",]-[\"x\"]]", + "eval.tests.test_driver_containers.test_array_parsing[[1, 2, 3]-[1,2,3]]", + "eval.tests.test_driver_containers.test_array_parsing[[1,2,3]-[1,2,3]]", + "eval.tests.test_driver_containers.test_array_parsing[[1,2,]-[1,2]]", + "eval.tests.test_driver_containers.test_array_parsing[[1,2.5,true,null,\"s\"]-[1,2.5,true,null,\"s\"]]", + "eval.tests.test_driver_containers.test_array_parsing[[1]-[1]]", + "eval.tests.test_driver_containers.test_array_parsing[[[1],[2,3]]-[[1],[2,3]]]", + "eval.tests.test_driver_containers.test_array_parsing[[[]]-[[]]]", + "eval.tests.test_driver_containers.test_array_parsing[[]-[]]", + "eval.tests.test_driver_containers.test_array_parsing[[{\"a\":1}]-[{\"a\":1}]]", + "eval.tests.test_driver_containers.test_deep_nesting_parses_fully", + "eval.tests.test_driver_containers.test_large_flat_array_of_ints", + "eval.tests.test_driver_containers.test_multiple_top_level_values_rejected", + "eval.tests.test_driver_containers.test_nested_array_mixed_types", + "eval.tests.test_driver_containers.test_object_duplicate_key_first_wins", + "eval.tests.test_driver_containers.test_object_duplicate_key_three", + "eval.tests.test_driver_containers.test_object_missing_colon_is_error", + "eval.tests.test_driver_containers.test_object_missing_value_separator_is_error", + "eval.tests.test_driver_containers.test_object_non_string_key_is_error", + "eval.tests.test_driver_containers.test_object_parsing[{ }-{}]", + "eval.tests.test_driver_containers.test_object_parsing[{\"\":1}-{\"\":1}]", + "eval.tests.test_driver_containers.test_object_parsing[{\"a\": 1}-{\"a\":1}]", + "eval.tests.test_driver_containers.test_object_parsing[{\"a\":1,\"b\":2}-{\"a\":1,\"b\":2}]", + "eval.tests.test_driver_containers.test_object_parsing[{\"a\":1}-{\"a\":1}]", + "eval.tests.test_driver_containers.test_object_parsing[{\"a\":[1,2]}-{\"a\":[1,2]}]", + "eval.tests.test_driver_containers.test_object_parsing[{\"a\":null}-{\"a\":null}]", + "eval.tests.test_driver_containers.test_object_parsing[{\"a\":{}}-{\"a\":{}}]", + "eval.tests.test_driver_containers.test_object_parsing[{\"z\":1,\"a\":2}-{\"a\":2,\"z\":1}]", + "eval.tests.test_driver_containers.test_object_parsing[{}-{}]", + "eval.tests.test_driver_containers.test_object_trailing_comma_tolerated", + "eval.tests.test_driver_containers.test_unclosed_array_is_error", + "eval.tests.test_driver_containers.test_unclosed_object_is_error", + "eval.tests.test_driver_containers.test_whitespace_and_newlines_do_not_change_value", + "eval.tests.test_driver_encoding_decode.test_escaped_codepoint_valid[0065-e]", + "eval.tests.test_driver_encoding_decode.test_escaped_codepoint_valid[007a-z]", + "eval.tests.test_driver_encoding_decode.test_escaped_codepoint_valid[00E9-\\xe9]", + "eval.tests.test_driver_encoding_decode.test_escaped_codepoint_valid[00e9-\\xe9]", + "eval.tests.test_driver_encoding_decode.test_escaped_codepoint_valid[20ac-\\u20ac]", + "eval.tests.test_driver_encoding_decode.test_escaped_codepoint_valid[4e2d-\\u4e2d]", + "eval.tests.test_driver_encoding_decode.test_escaped_control_backslash_sequences_through_doi", + "eval.tests.test_driver_encoding_decode.test_invalid_hex_escape[\"\\\\u0g01\"-value deserialization error: '\\\\u' must be followed by 4 hex digits, but got '\\\\u0067']", + "eval.tests.test_driver_encoding_decode.test_invalid_hex_escape[\"\\\\u12\"-value deserialization error: '\\\\u' must be followed by 4 hex digits, but got '\\\\u0022']", + "eval.tests.test_driver_encoding_decode.test_invalid_hex_escape[\"\\\\uZZZZ\"-value deserialization error: '\\\\u' must be followed by 4 hex digits, but got '\\\\u005A']", + "eval.tests.test_driver_encoding_decode.test_lone_continuation_byte_is_lenient", + "eval.tests.test_driver_encoding_decode.test_lone_lead_surrogate_is_error", + "eval.tests.test_driver_encoding_decode.test_lone_trail_surrogate_is_valid", + "eval.tests.test_driver_encoding_decode.test_overlong_two_byte_decodes_to_nul", + "eval.tests.test_driver_encoding_decode.test_raw_2byte_and_3byte_acceptance", + "eval.tests.test_driver_encoding_decode.test_raw_3byte_ffff", + "eval.tests.test_driver_encoding_decode.test_raw_4byte_max_codepoint", + "eval.tests.test_driver_encoding_decode.test_raw_control_char_in_string_is_error[\"\\x01\"-value deserialization error: invalid control character '\\\\u0001']", + "eval.tests.test_driver_encoding_decode.test_raw_control_char_in_string_is_error[\"\\x08\"-value deserialization error: invalid control character '\\\\u0008']", + "eval.tests.test_driver_encoding_decode.test_raw_control_char_in_string_is_error[\"\\x1f\"-value deserialization error: invalid control character '\\\\u001F']", + "eval.tests.test_driver_encoding_decode.test_raw_newline_inside_string_is_error", + "eval.tests.test_driver_encoding_decode.test_raw_utf8_in_key_roundtrip", + "eval.tests.test_driver_encoding_decode.test_surrogate_pair_followed_by_more_text", + "eval.tests.test_driver_encoding_decode.test_surrogate_pair_to_musical_symbol", + "eval.tests.test_driver_encoding_decode.test_utf8_decode_overflow_sets_failbit[\"\\xf4\\x90\\x80\\x80\"-value deserialization error: decoding failed with codepoint '\\\\u110000']", + "eval.tests.test_driver_encoding_decode.test_utf8_decode_overflow_sets_failbit[\"\\xf9\\x80\\x80\\x80\\x80\"-value deserialization error: decoding failed with codepoint '\\\\u1000000']", + "eval.tests.test_driver_encoding_decode.test_utf8_decode_overflow_sets_failbit[\"\\xfe\\x80\\x80\\x80\\x80\"-value deserialization error: decoding failed with codepoint '\\\\u7FFFFFA2']", + "eval.tests.test_driver_encoding_decode.test_utf8_f8_lead_decodes_then_control_nul", + "eval.tests.test_driver_encoding_decode.test_utf8_surrogate_encoded_sequence_is_lenient", + "eval.tests.test_driver_expanded_behavior.test_container_separator_errors[[1,,2]-value deserialization error: unexpected token, expect 'end_array', but got 'value_separator']", + "eval.tests.test_driver_expanded_behavior.test_container_separator_errors[{\"a\":1,,\"b\":2}-value deserialization error: unexpected token, expect 'end_object', but got 'value_separator']", + "eval.tests.test_driver_expanded_behavior.test_container_separator_errors[{\"a\":1{\"b\":2}}-value deserialization error: unexpected token, expect 'end_object', but got 'begin_object']", + "eval.tests.test_driver_expanded_behavior.test_container_separator_errors[{\"a\"::1}-value deserialization error: unexpected token 'name_separator']", + "eval.tests.test_driver_expanded_behavior.test_container_separator_errors[{\"a\":}-value deserialization error: unexpected token 'end_object']", + "eval.tests.test_driver_expanded_behavior.test_container_separator_errors[{,}-value deserialization error: unexpected token, expect 'end_object', but got 'value_separator']", + "eval.tests.test_driver_expanded_behavior.test_deeply_nested_arrays_parse[200]", + "eval.tests.test_driver_expanded_behavior.test_deeply_nested_arrays_parse[60]", + "eval.tests.test_driver_expanded_behavior.test_deeply_nested_objects_parse", + "eval.tests.test_driver_expanded_behavior.test_empty_exponent_sign_forms[+1e+--9223372036854775808.0]", + "eval.tests.test_driver_expanded_behavior.test_empty_exponent_sign_forms[-1e--0.0]", + "eval.tests.test_driver_expanded_behavior.test_empty_exponent_sign_forms[1E+--9223372036854775808.0]", + "eval.tests.test_driver_expanded_behavior.test_empty_exponent_sign_forms[1E--0.0]", + "eval.tests.test_driver_expanded_behavior.test_form_feed_before_value_is_rejected", + "eval.tests.test_driver_expanded_behavior.test_leading_zero_fraction_is_split", + "eval.tests.test_driver_expanded_behavior.test_leading_zero_with_exponent_is_invalid[-0e-]", + "eval.tests.test_driver_expanded_behavior.test_leading_zero_with_exponent_is_invalid[-0e2]", + "eval.tests.test_driver_expanded_behavior.test_leading_zero_with_exponent_is_invalid[0E5]", + "eval.tests.test_driver_expanded_behavior.test_leading_zero_with_exponent_is_invalid[0E]", + "eval.tests.test_driver_expanded_behavior.test_leading_zero_with_exponent_is_invalid[0e0]", + "eval.tests.test_driver_expanded_behavior.test_single_escape_round_trip[\"\\\\\\\\\"-\"\\\\\\\\\"]", + "eval.tests.test_driver_expanded_behavior.test_single_escape_round_trip[\"\\\\b\"-\"\\\\b\"]", + "eval.tests.test_driver_expanded_behavior.test_single_escape_round_trip[\"\\\\f\"-\"\\\\f\"]", + "eval.tests.test_driver_expanded_behavior.test_single_escape_round_trip[\"\\\\n\"-\"\\\\n\"]", + "eval.tests.test_driver_expanded_behavior.test_single_escape_round_trip[\"\\\\r\"-\"\\\\r\"]", + "eval.tests.test_driver_expanded_behavior.test_single_escape_round_trip[\"\\\\t\"-\"\\\\t\"]", + "eval.tests.test_driver_expanded_behavior.test_single_escape_round_trip[\"a\\\\/b\"-\"a/b\"]", + "eval.tests.test_driver_expanded_behavior.test_single_escape_round_trip[\"tab\\\\there\"-\"tab\\\\there\"]", + "eval.tests.test_driver_expanded_behavior.test_standard_whitespace_is_ignored[ \\n [ 1 , 2 ] -[1,2]]", + "eval.tests.test_driver_expanded_behavior.test_standard_whitespace_is_ignored[\\r\\n\\t {} -{}]", + "eval.tests.test_driver_expanded_behavior.test_standard_whitespace_is_ignored[\\t42\\r\\n-42]", + "eval.tests.test_driver_expanded_behavior.test_standard_whitespace_is_ignored[{\"a\" : 1, \"b\" : 2}-{\"a\":1,\"b\":2}]", + "eval.tests.test_driver_expanded_behavior.test_surrogate_pair_in_key", + "eval.tests.test_driver_expanded_behavior.test_top_level_multiple_values_after_array_rejected", + "eval.tests.test_driver_expanded_behavior.test_trailing_separator_still_valid", + "eval.tests.test_driver_expanded_behavior.test_two_digit_int_part_with_exponent", + "eval.tests.test_driver_expanded_behavior.test_unicode_escape_in_key", + "eval.tests.test_driver_expanded_behavior.test_upper_and_lower_hex_escape_in_key", + "eval.tests.test_driver_expanded_behavior.test_vertical_tab_before_value_is_rejected", + "eval.tests.test_driver_golden_example.test_golden_example_contains_bound_role_tree", + "eval.tests.test_driver_golden_example.test_golden_example_exact_stdout", + "eval.tests.test_driver_golden_example.test_golden_example_pretty_layout", + "eval.tests.test_driver_golden_example.test_golden_example_request_block", + "eval.tests.test_driver_number_tokens.test_bare_dot_is_error", + "eval.tests.test_driver_number_tokens.test_empty_exponent_invalid_number_message", + "eval.tests.test_driver_number_tokens.test_empty_exponent_minus_wores_to_zero", + "eval.tests.test_driver_number_tokens.test_empty_exponent_plus_wraps_to_min_int64_float", + "eval.tests.test_driver_number_tokens.test_float_with_two_fractional_digits_precision", + "eval.tests.test_driver_number_tokens.test_large_exponent_wraps_float", + "eval.tests.test_driver_number_tokens.test_leading_zero_with_exponent_is_error[-0e2]", + "eval.tests.test_driver_number_tokens.test_leading_zero_with_exponent_is_error[0E5]", + "eval.tests.test_driver_number_tokens.test_leading_zero_with_exponent_is_error[0e0]", + "eval.tests.test_driver_number_tokens.test_leading_zero_with_exponent_is_error[0e5]", + "eval.tests.test_driver_number_tokens.test_leading_zero_with_trailing_digits_is_integer", + "eval.tests.test_driver_number_tokens.test_number_tokens_inside_array", + "eval.tests.test_driver_number_tokens.test_signed_and_uppercase_exponent_floats[+3.25e1-32.5]", + "eval.tests.test_driver_number_tokens.test_signed_and_uppercase_exponent_floats[-1E+3--1000.0]", + "eval.tests.test_driver_number_tokens.test_signed_and_uppercase_exponent_floats[-2.5E-2--0.025]", + "eval.tests.test_driver_number_tokens.test_signed_and_uppercase_exponent_floats[1.5e2-150.0]", + "eval.tests.test_driver_number_tokens.test_signed_and_uppercase_exponent_floats[1E-3-0.001]", + "eval.tests.test_driver_number_tokens.test_signed_integer_and_float_tokens[+0-0]", + "eval.tests.test_driver_number_tokens.test_signed_integer_and_float_tokens[+0.25-0.25]", + "eval.tests.test_driver_number_tokens.test_signed_integer_and_float_tokens[+23-23]", + "eval.tests.test_driver_number_tokens.test_signed_integer_and_float_tokens[-0.5--0.5]", + "eval.tests.test_driver_number_tokens.test_signed_integer_and_float_tokens[-123--123]", + "eval.tests.test_driver_number_tokens.test_signed_integer_and_float_tokens[42-42]", + "eval.tests.test_driver_number_tokens.test_small_exponent_underflows", + "eval.tests.test_driver_number_tokens.test_tiny_fraction_exponent", + "eval.tests.test_driver_number_tokens.test_trailing_dot_invalid_float", + "eval.tests.test_driver_scalars.test_empty_input_is_parse_error", + "eval.tests.test_driver_scalars.test_float_decimals_and_exponents_reject_trailing_dot", + "eval.tests.test_driver_scalars.test_float_overflow_wraps_to_negative_min", + "eval.tests.test_driver_scalars.test_float_scalars[-0.5--0.5]", + "eval.tests.test_driver_scalars.test_float_scalars[-1e-3--0.001]", + "eval.tests.test_driver_scalars.test_float_scalars[0.0-0.0]", + "eval.tests.test_driver_scalars.test_float_scalars[1.5e2-150.0]", + "eval.tests.test_driver_scalars.test_float_scalars[100.25-100.25]", + "eval.tests.test_driver_scalars.test_float_scalars[1E+2-100.0]", + "eval.tests.test_driver_scalars.test_float_scalars[1e-308-1e-308]", + "eval.tests.test_driver_scalars.test_float_scalars[1e10-10000000000.0]", + "eval.tests.test_driver_scalars.test_float_scalars[3.14-3.14]", + "eval.tests.test_driver_scalars.test_float_scalars[5e-3-0.005]", + "eval.tests.test_driver_scalars.test_integer_scalars[+5-5]", + "eval.tests.test_driver_scalars.test_integer_scalars[-0-0]", + "eval.tests.test_driver_scalars.test_integer_scalars[-1--1]", + "eval.tests.test_driver_scalars.test_integer_scalars[-2147483648--2147483648]", + "eval.tests.test_driver_scalars.test_integer_scalars[-42--42]", + "eval.tests.test_driver_scalars.test_integer_scalars[-9223372036854775808--9223372036854775808]", + "eval.tests.test_driver_scalars.test_integer_scalars[0-0]", + "eval.tests.test_driver_scalars.test_integer_scalars[1-1]", + "eval.tests.test_driver_scalars.test_integer_scalars[12345678901234567890--6101065172474983726]", + "eval.tests.test_driver_scalars.test_integer_scalars[2147483647-2147483647]", + "eval.tests.test_driver_scalars.test_integer_scalars[42-42]", + "eval.tests.test_driver_scalars.test_integer_scalars[9223372036854775807-9223372036854775807]", + "eval.tests.test_driver_scalars.test_leading_plus_integer", + "eval.tests.test_driver_scalars.test_literal_scalars[false-false]", + "eval.tests.test_driver_scalars.test_literal_scalars[null-null]", + "eval.tests.test_driver_scalars.test_literal_scalars[true-true]", + "eval.tests.test_driver_scalars.test_partial_literal_true_leaves_cutoff_character", + "eval.tests.test_driver_scalars.test_scalar_parse_errors[ -value deserialization error: unexpected token 'end_of_input']", + "eval.tests.test_driver_scalars.test_scalar_parse_errors[-value deserialization error: unexpected token 'end_of_input']", + "eval.tests.test_driver_scalars.test_scalar_parse_errors[07-value deserialization error: unexpected token 'end_of_input']", + "eval.tests.test_driver_scalars.test_scalar_parse_errors[1 2-value deserialization error: unexpected token 'end_of_input']", + "eval.tests.test_driver_scalars.test_scalar_parse_errors[1.2.3-value deserialization error: unexpected character '\\\\u002E']", + "eval.tests.test_driver_scalars.test_scalar_parse_errors[garbage-value deserialization error: unexpected character '\\\\u0067']", + "eval.tests.test_driver_scalars.test_scalar_parse_errors[true false-value deserialization error: unexpected token 'end_of_input']", + "eval.tests.test_driver_scalars.test_scalar_parse_errors[trueX-value deserialization error: unexpected character '\\\\u0058']", + "eval.tests.test_driver_scalars.test_scalar_parse_errors[x-value deserialization error: unexpected character '\\\\u0078']", + "eval.tests.test_driver_scalars.test_whitespace_around_scalar_is_ignored", + "eval.tests.test_driver_strings.test_double_quote_escape_sequences[\"\\\\\"\"-\"\\\\\"\"]", + "eval.tests.test_driver_strings.test_double_quote_escape_sequences[\"\\\\/\"-\"/\"]", + "eval.tests.test_driver_strings.test_double_quote_escape_sequences[\"\\\\b\\\\f\\\\n\\\\r\\\\t\"-\"\\\\b\\\\f\\\\n\\\\r\\\\t\"]", + "eval.tests.test_driver_strings.test_double_quote_escape_sequences[\"a\\\\\\\\b\"-\"a\\\\\\\\b\"]", + "eval.tests.test_driver_strings.test_escape_backslash_at_eof_is_error", + "eval.tests.test_driver_strings.test_invalid_utf8_sequence_is_lenient_decoded", + "eval.tests.test_driver_strings.test_lead_lead_surrogate_is_error", + "eval.tests.test_driver_strings.test_lone_continuation_byte_is_lenient", + "eval.tests.test_driver_strings.test_lone_lead_surrogate_is_error", + "eval.tests.test_driver_strings.test_plain_strings[\"\"-\"\"]", + "eval.tests.test_driver_strings.test_plain_strings[\"hello\"-\"hello\"]", + "eval.tests.test_driver_strings.test_plain_strings[\"non-ascii \\xe9\"-\"non-ascii \\xe9\"]", + "eval.tests.test_driver_strings.test_plain_strings[\"with space\"-\"with space\"]", + "eval.tests.test_driver_strings.test_plain_strings['unquoted'-None]", + "eval.tests.test_driver_strings.test_raw_utf8_in_key", + "eval.tests.test_driver_strings.test_raw_utf8_multibyte_string_value", + "eval.tests.test_driver_strings.test_raw_utf8_two_byte", + "eval.tests.test_driver_strings.test_string_followed_by_newline_is_closed", + "eval.tests.test_driver_strings.test_string_immediately_closed_is_empty", + "eval.tests.test_driver_strings.test_too_few_hex_digits_after_unicode_escape", + "eval.tests.test_driver_strings.test_unclosed_string_is_error", + "eval.tests.test_driver_strings.test_unicode_escapes[\"A\"-\"A\"]", + "eval.tests.test_driver_strings.test_unicode_escapes[\"\\U0001f600\"-\"\\U0001f600\"]", + "eval.tests.test_driver_strings.test_unicode_escapes[\"\\U0010ffff\"-\"\\U0010ffff\"]", + "eval.tests.test_driver_strings.test_unicode_escapes[\"\\u03b1\"-\"\\u03b1\"]", + "eval.tests.test_driver_strings.test_unicode_escapes[\"\\xe9\"-\"\\xe9\"]", + "eval.tests.test_driver_strings.test_unknown_escape_is_error", + "eval.tests.test_driver_strings.test_unknown_escape_many", + "eval.tests.test_driver_strings.test_valid_four_hex_is_accepted[\"\\u2aaa\"-2A0]", + "eval.tests.test_driver_strings.test_valid_four_hex_is_accepted[\"\\u2aaa\"-2A1]" + ] + }, + "generated_module_03": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [ + { + "name": "eval.tests.test_serializer_layout_invariants.test_response_body_exact_byte_length", + "reasons": [ + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_serializer_layout_invariants.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + } + ], + "tests": [ + "eval.tests.test_golden_equality.test_golden_response_is_valid_nested_object", + "eval.tests.test_golden_equality.test_golden_response_section_equals_observed", + "eval.tests.test_golden_equality.test_stdout_golden_is_nonempty_when_run", + "eval.tests.test_golden_equality.test_stdout_matches_golden_bytes", + "eval.tests.test_golden_equality.test_stdout_normalized_golden_equal", + "eval.tests.test_process_contract.test_exits_zero", + "eval.tests.test_process_contract.test_no_leftover_files_in_cwd", + "eval.tests.test_process_contract.test_no_program_error_on_stderr", + "eval.tests.test_process_contract.test_output_identical_across_runs", + "eval.tests.test_process_contract.test_output_identical_across_three_runs", + "eval.tests.test_process_contract.test_output_independent_of_working_directory", + "eval.tests.test_process_contract.test_request_and_response_sections_present", + "eval.tests.test_process_contract.test_response_section_after_request_section", + "eval.tests.test_process_contract.test_single_request_section", + "eval.tests.test_process_contract.test_single_response_section", + "eval.tests.test_process_contract.test_stdout_ignores_argv", + "eval.tests.test_process_contract.test_stdout_ignores_empty_stdin", + "eval.tests.test_process_contract.test_stdout_ignores_environment_locale", + "eval.tests.test_process_contract.test_stdout_ignores_positional_arguments", + "eval.tests.test_process_contract.test_stdout_ignores_stdin", + "eval.tests.test_process_contract.test_stdout_not_empty", + "eval.tests.test_process_contract.test_stdout_size", + "eval.tests.test_request_reflection.test_request_block_has_no_trailing_garbage", + "eval.tests.test_request_reflection.test_request_block_indented_with_four_spaces", + "eval.tests.test_request_reflection.test_request_block_is_valid_json", + "eval.tests.test_request_reflection.test_request_has_single_key_user_id", + "eval.tests.test_request_reflection.test_request_user_id_is_integer", + "eval.tests.test_request_reflection.test_request_user_id_line_exact", + "eval.tests.test_request_reflection.test_request_user_id_matches_lookup_response", + "eval.tests.test_request_reflection.test_request_user_id_value", + "eval.tests.test_response_exact_text.test_full_stdout_ends_with_serialized_response", + "eval.tests.test_response_exact_text.test_request_body_line_join_is_exact", + "eval.tests.test_response_exact_text.test_response_body_exact_text", + "eval.tests.test_response_exact_text.test_response_body_is_wellformed_json_of_expected_model", + "eval.tests.test_response_exact_text.test_response_body_no_extra_whitespace", + "eval.tests.test_response_serialization.test_first_role_code", + "eval.tests.test_response_serialization.test_first_role_code_is_integer", + "eval.tests.test_response_serialization.test_first_role_key_order", + "eval.tests.test_response_serialization.test_first_role_permissions", + "eval.tests.test_response_serialization.test_no_boolean_scalars_present", + "eval.tests.test_response_serialization.test_no_floating_point_scalars_present", + "eval.tests.test_response_serialization.test_no_null_scalars_present", + "eval.tests.test_response_serialization.test_permission_values_are_strings", + "eval.tests.test_response_serialization.test_response_has_single_key_user_info", + "eval.tests.test_response_serialization.test_response_is_object", + "eval.tests.test_response_serialization.test_response_round_trips_through_stable_json", + "eval.tests.test_response_serialization.test_role_codes_unique_and_ordered", + "eval.tests.test_response_serialization.test_role_element_is_object", + "eval.tests.test_response_serialization.test_role_list_has_two_roles", + "eval.tests.test_response_serialization.test_role_list_is_array", + "eval.tests.test_response_serialization.test_role_permission_order_preserved", + "eval.tests.test_response_serialization.test_second_role_code", + "eval.tests.test_response_serialization.test_second_role_permissions", + "eval.tests.test_response_serialization.test_user_id_exact_value", + "eval.tests.test_response_serialization.test_user_id_is_integer_not_string", + "eval.tests.test_response_serialization.test_user_id_is_not_boolean", + "eval.tests.test_response_serialization.test_user_id_matches_request", + "eval.tests.test_response_serialization.test_user_info_has_no_extra_fields", + "eval.tests.test_response_serialization.test_user_info_is_object", + "eval.tests.test_response_serialization.test_user_info_keys_are_sorted_and_exact", + "eval.tests.test_response_serialization.test_user_name_exact_value", + "eval.tests.test_response_serialization.test_user_name_is_string", + "eval.tests.test_response_serialization.test_user_name_not_empty", + "eval.tests.test_response_structure_grammar.test_braces_and_brackets_are_properly_nested", + "eval.tests.test_response_structure_grammar.test_every_array_element_starts_a_fresh_line", + "eval.tests.test_response_structure_grammar.test_every_member_uses_the_space_colon_separator", + "eval.tests.test_response_structure_grammar.test_exact_comma_count_and_placement", + "eval.tests.test_response_structure_grammar.test_fixed_string_data_emits_no_escape_sequences", + "eval.tests.test_response_structure_grammar.test_line_counts_of_sections_are_exact", + "eval.tests.test_response_structure_grammar.test_member_indent_depth_increments_continuously", + "eval.tests.test_response_structure_grammar.test_member_lines_and_colon_count_match", + "eval.tests.test_response_structure_grammar.test_no_bracket_is_immediately_followed_by_a_comma", + "eval.tests.test_response_structure_grammar.test_object_and_array_open_close_counts_match_exactly", + "eval.tests.test_response_structure_grammar.test_response_body_json_roundtrip_is_byte_stable_after_reparse", + "eval.tests.test_response_structure_grammar.test_response_has_no_leading_or_trailing_blank_lines", + "eval.tests.test_response_structure_grammar.test_single_blank_line_separates_request_and_response", + "eval.tests.test_response_structure_grammar.test_strongly_typed_object_members_align_to_their_object", + "eval.tests.test_scalar_grammar.test_colon_appears_only_between_key_and_value", + "eval.tests.test_scalar_grammar.test_comma_only_between_object_members_and_array_elements", + "eval.tests.test_scalar_grammar.test_integers_never_wear_quotes_or_zero_padding", + "eval.tests.test_scalar_grammar.test_nested_objects_are_comma_separated", + "eval.tests.test_scalar_grammar.test_no_logical_operators_leak_into_output", + "eval.tests.test_scalar_grammar.test_object_member_count_matches_colon_count_toplevel", + "eval.tests.test_scalar_grammar.test_quoted_strings_and_bare_numbers_coexist", + "eval.tests.test_scalar_grammar.test_response_uses_only_object_array_and_scalar_tokens", + "eval.tests.test_scalar_grammar.test_serializer_output_exactly_matches_expected_text", + "eval.tests.test_scalar_grammar.test_string_values_never_appear_bare", + "eval.tests.test_serialization_formatting.test_array_opens_and_closes_on_own_lines", + "eval.tests.test_serialization_formatting.test_ascii_scalars_only", + "eval.tests.test_serialization_formatting.test_indent_is_four_spaces_per_level", + "eval.tests.test_serialization_formatting.test_integer_serialization_unquoted", + "eval.tests.test_serialization_formatting.test_name_separator_is_space_colon_space", + "eval.tests.test_serialization_formatting.test_nested_object_values_get_newline", + "eval.tests.test_serialization_formatting.test_no_carriage_returns_emitted", + "eval.tests.test_serialization_formatting.test_no_trailing_comma_before_close_brace", + "eval.tests.test_serialization_formatting.test_response_ends_with_object_close_brace", + "eval.tests.test_serialization_formatting.test_response_is_deterministic_text", + "eval.tests.test_serialization_formatting.test_response_section_newline_terminated", + "eval.tests.test_serialization_formatting.test_response_starts_with_object_brace", + "eval.tests.test_serialization_formatting.test_role_keys_sorted", + "eval.tests.test_serialization_formatting.test_role_list_array_indentation", + "eval.tests.test_serialization_formatting.test_role_object_nested_structure", + "eval.tests.test_serialization_formatting.test_string_serialization_double_quoted", + "eval.tests.test_serialization_formatting.test_user_info_keys_sorted", + "eval.tests.test_serialization_formatting.test_value_separator_newline", + "eval.tests.test_serializer_layout_invariants.test_all_integer_scalars_appear_in_canonical_decimal_form", + "eval.tests.test_serializer_layout_invariants.test_all_object_keys_match_identifier_charset", + "eval.tests.test_serializer_layout_invariants.test_deepest_leaf_path_and_value", + "eval.tests.test_serializer_layout_invariants.test_every_nonblank_line_is_a_single_structural_unit", + "eval.tests.test_serializer_layout_invariants.test_every_object_emits_keys_in_sorted_order", + "eval.tests.test_serializer_layout_invariants.test_max_json_nesting_depth_is_six", + "eval.tests.test_serializer_layout_invariants.test_no_empty_object_or_array_tokens", + "eval.tests.test_serializer_layout_invariants.test_only_outermost_object_closes_at_column_zero", + "eval.tests.test_serializer_layout_invariants.test_response_body_exact_byte_length", + "eval.tests.test_stream_wrappers_invariants.test_full_stdout_is_exact_concatenation", + "eval.tests.test_stream_wrappers_invariants.test_indentation_matches_nesting_depth", + "eval.tests.test_stream_wrappers_invariants.test_response_block_parses_with_no_trailing_garbage", + "eval.tests.test_stream_wrappers_invariants.test_response_integer_leaves_are_exact_multiset", + "eval.tests.test_stream_wrappers_invariants.test_response_string_leaves_are_exact_multiset", + "eval.tests.test_stream_wrappers_invariants.test_role_permission_cardinality_is_distinct", + "eval.tests.test_stream_wrappers_invariants.test_stdout_labeled_blocks_have_no_foreign_prefix", + "eval.tests.test_stream_wrappers_invariants.test_strict_json_parses_response_as_single_value" + ] + }, + "generated_module_04": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [ + { + "name": "eval.tests.test_isolation.test_does_not_read_or_modify_existing_config_in_cwd", + "reasons": [ + { + "id": "golden_written_in_test", + "message": "pytest test writes to its own golden file", + "path": "eval/tests/test_isolation.py", + "repair_hint": "Read committed golden data instead of writing expected output inside the test.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_isolation.test_stdout_identical_when_redirected_to_real_file", + "reasons": [ + { + "id": "golden_written_in_test", + "message": "pytest test writes to its own golden file", + "path": "eval/tests/test_isolation.py", + "repair_hint": "Read committed golden data instead of writing expected output inside the test.", + "severity": "error", + "stage": "static_lint" + } + ] + } + ], + "tests": [ + "eval.tests.test_exact_layout.test_delimiter_balance_matches_schema", + "eval.tests.test_exact_layout.test_every_line_indent_is_multiple_of_four", + "eval.tests.test_exact_layout.test_integer_values_render_without_decimal", + "eval.tests.test_exact_layout.test_last_array_element_has_no_trailing_comma", + "eval.tests.test_exact_layout.test_marker_lines_end_with_a_single_space", + "eval.tests.test_exact_layout.test_markers_appear_exactly_once", + "eval.tests.test_exact_layout.test_request_section_is_exact_byte_prefix", + "eval.tests.test_exact_layout.test_response_root_is_object_not_array", + "eval.tests.test_exact_layout.test_role_list_brackets_column_aligned", + "eval.tests.test_exact_layout.test_single_member_object_has_no_trailing_comma", + "eval.tests.test_exact_layout.test_user_name_occurs_once", + "eval.tests.test_exact_layout.test_whole_document_matches_expected_semantics", + "eval.tests.test_example_process.test_exit_code_is_zero", + "eval.tests.test_example_process.test_no_stderr_on_success", + "eval.tests.test_example_process.test_nothing_precedes_request_marker", + "eval.tests.test_example_process.test_output_has_request_before_response", + "eval.tests.test_example_process.test_request_block_is_valid_json", + "eval.tests.test_example_process.test_request_block_rendered_exactly", + "eval.tests.test_example_process.test_request_has_exactly_user_id_key", + "eval.tests.test_example_process.test_request_user_id_value", + "eval.tests.test_example_process.test_response_block_header_exact", + "eval.tests.test_example_process.test_response_block_is_valid_json", + "eval.tests.test_example_process.test_stdout_blocks_each_parse", + "eval.tests.test_example_process.test_stdout_is_valid_utf8_text", + "eval.tests.test_formatting.test_deterministic_across_runs", + "eval.tests.test_formatting.test_endline_after_request_block", + "eval.tests.test_formatting.test_four_space_indent_response", + "eval.tests.test_formatting.test_ignores_extra_arguments", + "eval.tests.test_formatting.test_ignores_stdin_arbitrary_bytes", + "eval.tests.test_formatting.test_ignores_stdin_payload", + "eval.tests.test_formatting.test_output_ends_with_newline", + "eval.tests.test_formatting.test_request_block_formatting", + "eval.tests.test_formatting.test_request_echo_matches_lookup_id", + "eval.tests.test_formatting.test_stderr_matches_packaged_golden", + "eval.tests.test_formatting.test_stdout_matches_packaged_golden", + "eval.tests.test_isolation.test_does_not_read_or_modify_existing_config_in_cwd", + "eval.tests.test_isolation.test_output_identical_under_environment_change[lang_fr]", + "eval.tests.test_isolation.test_output_identical_under_environment_change[lc_all_c]", + "eval.tests.test_isolation.test_output_identical_under_environment_change[lc_all_en_us]", + "eval.tests.test_isolation.test_output_identical_under_environment_change[lc_numeric_de]", + "eval.tests.test_isolation.test_output_identical_under_environment_change[lc_time_ja]", + "eval.tests.test_isolation.test_output_identical_under_environment_change[posixly_correct]", + "eval.tests.test_isolation.test_output_identical_under_environment_change[tty_size]", + "eval.tests.test_isolation.test_output_identical_under_environment_change[tz_auckland]", + "eval.tests.test_isolation.test_output_identical_under_environment_change[tz_new_york]", + "eval.tests.test_isolation.test_output_writes_no_files_to_working_directory", + "eval.tests.test_isolation.test_stdout_identical_when_redirected_to_real_file", + "eval.tests.test_response_content.test_all_role_codes_are_ints", + "eval.tests.test_response_content.test_first_role_code", + "eval.tests.test_response_content.test_first_role_permissions", + "eval.tests.test_response_content.test_nested_arrays_and_objects_types", + "eval.tests.test_response_content.test_permission_values_are_strings", + "eval.tests.test_response_content.test_response_has_single_key_user_info", + "eval.tests.test_response_content.test_role_codes_are_distinct_ints", + "eval.tests.test_response_content.test_role_list_has_two_role_objects", + "eval.tests.test_response_content.test_role_list_is_array", + "eval.tests.test_response_content.test_second_role_code", + "eval.tests.test_response_content.test_second_role_permissions", + "eval.tests.test_response_content.test_user_info_is_object", + "eval.tests.test_response_content.test_user_info_members_exactly_three", + "eval.tests.test_response_content.test_user_info_user_id", + "eval.tests.test_response_content.test_user_info_user_name", + "eval.tests.test_roundtrip.test_null_branch_stays_unobservable", + "eval.tests.test_roundtrip.test_output_line_grammar", + "eval.tests.test_roundtrip.test_request_id_drives_response_lookup", + "eval.tests.test_roundtrip.test_request_is_minimal_object", + "eval.tests.test_roundtrip.test_response_schema_matches_binding", + "eval.tests.test_roundtrip.test_role_list_maps_code_to_permissions", + "eval.tests.test_roundtrip.test_role_objects_are_ordered_by_code", + "eval.tests.test_roundtrip.test_stdout_contains_every_schema_token", + "eval.tests.test_roundtrip.test_stdout_is_ascii_clean", + "eval.tests.test_roundtrip.test_user_info_is_present_not_null", + "eval.tests.test_structure.test_each_role_has_sorted_members", + "eval.tests.test_structure.test_exact_full_response_rendering", + "eval.tests.test_structure.test_first_role_canonical_rendering", + "eval.tests.test_structure.test_nesting_depth_of_response", + "eval.tests.test_structure.test_object_keys_sorted_response", + "eval.tests.test_structure.test_response_nested_indentation_levels", + "eval.tests.test_structure.test_role_object_members_sorted", + "eval.tests.test_structure.test_second_role_permission_order_preserved" + ] + } + }, + "commit": "3d908fadb32bd7eb1c534459718fc8d3cb1ef889", + "data_source": "synthetic_programgym", + "difficulty": "easy", + "difficulty_score": 1.7629784908677428, + "eval_clean_hashes": [ + "906208a14ffa0562ba7ca34452fccad7692433f1a44af2ef12c400675275c4e6" + ], + "input_record": { + "commit": "3d908fadb32bd7eb1c534459718fc8d3cb1ef889", + "difficulty": "easy", + "difficulty_code_lines": 5794, + "difficulty_has_tests": true, + "difficulty_product_code_lines": 5794, + "difficulty_runtime_deps": 0, + "difficulty_score": 1.7629784908677428, + "difficulty_test_code_lines": 20314, + "full_name": "nomango/configor", + "input_joern_zip": "cpp_joern/nomango__configor.zip", + "joern_status": true, + "joern_time": 8.854879247024655, + "language": "cpp", + "pb_match": [ + { + "pb_fullname": "ninja-build/ninja", + "rank": 731, + "similarity": 0.43436723947525024 + } + ], + "repo_path": "cpp/nomango__configor", + "source": "commit:3d908fadb32bd7eb1c534459718fc8d3cb1ef889", + "status": "done", + "url": "https://github.com/nomango/configor" + }, + "instance_id": "nomango__configor.3d908fa", + "language": "cpp", + "module_iterations": [ + { + "actual_iterations": 5, + "branch_name": "generated_module_01", + "iteration_limit": 5, + "module_index": 1, + "module_kind": "source", + "termination_reason": "early_stopping" + }, + { + "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": "early_stopping" + }, + { + "actual_iterations": 5, + "branch_name": "generated_module_04", + "iteration_limit": 5, + "module_index": 4, + "module_kind": "source", + "termination_reason": "early_stopping" + } + ], + "repository": "nomango/configor" +}