diff --git "a/datafusion-contrib--bdt.5c6730a/tests/programgym_task.json" "b/datafusion-contrib--bdt.5c6730a/tests/programgym_task.json" new file mode 100644--- /dev/null +++ "b/datafusion-contrib--bdt.5c6730a/tests/programgym_task.json" @@ -0,0 +1,4030 @@ +{ + "branches": { + "generated_module_01": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_compare.test_compare_default_treats_first_row_as_header", + "eval.tests.test_compare.test_compare_empty_vs_nonempty_row_count", + "eval.tests.test_compare.test_compare_epsilon_covers_float_roundtrip", + "eval.tests.test_compare.test_compare_epsilon_covers_small_diff", + "eval.tests.test_compare.test_compare_epsilon_does_not_cover_when_left_larger", + "eval.tests.test_compare.test_compare_epsilon_ignored_for_int64_columns", + "eval.tests.test_compare.test_compare_epsilon_short_flag", + "eval.tests.test_compare.test_compare_identical_content_different_paths", + "eval.tests.test_compare.test_compare_identical_files_match", + "eval.tests.test_compare.test_compare_identical_parquet_match", + "eval.tests.test_compare.test_compare_missing_input1", + "eval.tests.test_compare.test_compare_missing_input2", + "eval.tests.test_compare.test_compare_no_header_row_diff", + "eval.tests.test_compare.test_compare_no_header_row_identical", + "eval.tests.test_compare.test_compare_parquet_diff", + "eval.tests.test_compare.test_compare_rejects_parquet_parq_extension", + "eval.tests.test_compare.test_compare_row_count_diff", + "eval.tests.test_compare.test_compare_row_diff_carries_both_rows", + "eval.tests.test_compare.test_compare_row_diff_detected", + "eval.tests.test_compare.test_compare_row_length_mismatch", + "eval.tests.test_compare.test_compare_single_column_identical", + "eval.tests.test_compare.test_compare_unsupported_json_format", + "eval.tests.test_convert.test_convert_avro_output_rejected", + "eval.tests.test_convert.test_convert_bad_input_extension", + "eval.tests.test_convert.test_convert_bad_output_extension", + "eval.tests.test_convert.test_convert_csv_to_csv_multipart_dir", + "eval.tests.test_convert.test_convert_csv_to_csv_roundtrip_single", + "eval.tests.test_convert.test_convert_csv_to_json_multipart_dir", + "eval.tests.test_convert.test_convert_csv_to_json_single_file", + "eval.tests.test_convert.test_convert_csv_to_parquet_multipart_dir", + "eval.tests.test_convert.test_convert_csv_to_parquet_single_file", + "eval.tests.test_convert.test_convert_csv_to_parquet_then_back_exact", + "eval.tests.test_convert.test_convert_empty_csv_writes_no_part", + "eval.tests.test_convert.test_convert_headersonly_csv_writes_no_part", + "eval.tests.test_convert.test_convert_input_missing_extension", + "eval.tests.test_convert.test_convert_json_to_csv_multipart_dir", + "eval.tests.test_convert.test_convert_json_to_csv_single", + "eval.tests.test_convert.test_convert_json_to_json_multipart_dir", + "eval.tests.test_convert.test_convert_json_to_json_single", + "eval.tests.test_convert.test_convert_json_to_parquet_single", + "eval.tests.test_convert.test_convert_missing_input_error", + "eval.tests.test_convert.test_convert_parquet_output_extension_parq", + "eval.tests.test_convert.test_convert_parquet_to_csv_exact_roundtrip", + "eval.tests.test_convert.test_convert_parquet_to_csv_single", + "eval.tests.test_convert.test_convert_parquet_to_json_multipart", + "eval.tests.test_convert.test_convert_parquet_to_json_single", + "eval.tests.test_convert.test_convert_parquet_to_parquet_single_roundtrip", + "eval.tests.test_convert.test_convert_typed_csv_to_parquet_keeps_types", + "eval.tests.test_convert.test_convert_zstd_json_roundtrip_count", + "eval.tests.test_convert.test_convert_zstd_multipart_dir_produces_one_part", + "eval.tests.test_convert.test_convert_zstd_parquet_can_be_read_back", + "eval.tests.test_convert.test_convert_zstd_parquet_single", + "eval.tests.test_count.test_count_big_csv", + "eval.tests.test_count.test_count_csv", + "eval.tests.test_count.test_count_directory_rejected", + "eval.tests.test_count.test_count_empty_csv_is_zero", + "eval.tests.test_count.test_count_empty_data_no_header", + "eval.tests.test_count.test_count_empty_json_zero", + "eval.tests.test_count.test_count_json", + "eval.tests.test_count.test_count_jsonl_unsupported_extension", + "eval.tests.test_count.test_count_missing_file_error", + "eval.tests.test_count.test_count_parquet_parq_extension", + "eval.tests.test_count.test_count_parquet_people", + "eval.tests.test_count.test_count_parquet_wide", + "eval.tests.test_count.test_count_typed_parquet", + "eval.tests.test_count.test_count_unsupported_extension", + "eval.tests.test_help.test_count_requires_table_flag", + "eval.tests.test_help.test_help_flag_long_usage_structure", + "eval.tests.test_help.test_help_flag_short_lists_all_subcommands", + "eval.tests.test_help.test_help_subcommand", + "eval.tests.test_help.test_help_subcommand_compare", + "eval.tests.test_help.test_help_subcommand_convert", + "eval.tests.test_help.test_help_subcommand_count", + "eval.tests.test_help.test_help_subcommand_query", + "eval.tests.test_help.test_help_subcommand_schema", + "eval.tests.test_help.test_help_subcommand_view", + "eval.tests.test_help.test_help_subcommand_view_parquet_meta", + "eval.tests.test_help.test_invalid_subcommand_rejected", + "eval.tests.test_help.test_no_args_prints_usage_and_exits_nonzero", + "eval.tests.test_help.test_subcommand_help_flag_compare", + "eval.tests.test_help.test_subcommand_help_flag_convert", + "eval.tests.test_help.test_subcommand_help_flag_count", + "eval.tests.test_help.test_subcommand_help_flag_view", + "eval.tests.test_help.test_subcommand_version_echo", + "eval.tests.test_help.test_unknown_flag_at_top_level_rejected", + "eval.tests.test_help.test_version_flag_long", + "eval.tests.test_help.test_version_flag_short", + "eval.tests.test_help.test_view_help_shows_limit_option", + "eval.tests.test_parquet_meta.test_parquet_meta_boolean_statistics", + "eval.tests.test_parquet_meta.test_parquet_meta_column_headers", + "eval.tests.test_parquet_meta.test_parquet_meta_double_statistics", + "eval.tests.test_parquet_meta.test_parquet_meta_header_present", + "eval.tests.test_parquet_meta.test_parquet_meta_int64_statistics", + "eval.tests.test_parquet_meta.test_parquet_meta_non_parquet_file", + "eval.tests.test_parquet_meta.test_parquet_meta_nonexistent_file", + "eval.tests.test_parquet_meta.test_parquet_meta_parq_extension", + "eval.tests.test_parquet_meta.test_parquet_meta_people_rows", + "eval.tests.test_parquet_meta.test_parquet_meta_row_group_text_people", + "eval.tests.test_parquet_meta.test_parquet_meta_row_group_text_wide", + "eval.tests.test_parquet_meta.test_parquet_meta_string_statistics", + "eval.tests.test_parquet_meta.test_parquet_meta_typed_all_columns", + "eval.tests.test_parquet_meta.test_parquet_meta_wide_rows", + "eval.tests.test_query.test_query_aggregation_count", + "eval.tests.test_query.test_query_arithmetic_alias", + "eval.tests.test_query.test_query_bad_sql_error", + "eval.tests.test_query.test_query_both_sql_and_sql_file_panics", + "eval.tests.test_query.test_query_count_distinct", + "eval.tests.test_query.test_query_cte_with", + "eval.tests.test_query.test_query_distinct_values", + "eval.tests.test_query.test_query_empty_tables_directory_registers_nothing", + "eval.tests.test_query.test_query_group_by_sum", + "eval.tests.test_query.test_query_having_filters_groups", + "eval.tests.test_query.test_query_in_list_filter", + "eval.tests.test_query.test_query_is_null_filter", + "eval.tests.test_query.test_query_join_two_registered_tables", + "eval.tests.test_query.test_query_limit_rows", + "eval.tests.test_query.test_query_literal_query_no_tables", + "eval.tests.test_query.test_query_missing_sql_file_error", + "eval.tests.test_query.test_query_missing_tables_directory", + "eval.tests.test_query.test_query_multiple_tables", + "eval.tests.test_query.test_query_neither_sql_nor_sql_file_panics", + "eval.tests.test_query.test_query_order_by", + "eval.tests.test_query.test_query_order_by_desc", + "eval.tests.test_query.test_query_output_csv_dir", + "eval.tests.test_query.test_query_output_no_extension", + "eval.tests.test_query.test_query_output_overwrite_existing_dir", + "eval.tests.test_query.test_query_output_parquet_dir", + "eval.tests.test_query.test_query_output_parquet_readable_by_view", + "eval.tests.test_query.test_query_output_result_readable_by_count", + "eval.tests.test_query.test_query_output_unsupported_extension", + "eval.tests.test_query.test_query_parquet_extension_parq", + "eval.tests.test_query.test_query_select_star", + "eval.tests.test_query.test_query_sql_file", + "eval.tests.test_query.test_query_sql_with_case_insensitive_table_name", + "eval.tests.test_query.test_query_subquery_in_from", + "eval.tests.test_query.test_query_table_and_tables_both_registered", + "eval.tests.test_query.test_query_table_flag_registers_each_repeat", + "eval.tests.test_query.test_query_table_flag_sanitizes_hyphen_name", + "eval.tests.test_query.test_query_tables_dir_duplicate_table_name_error", + "eval.tests.test_query.test_query_tables_directory", + "eval.tests.test_query.test_query_tables_directory_non_utf8_filename_rejected", + "eval.tests.test_query.test_query_tables_directory_sanitizes_table_name", + "eval.tests.test_query.test_query_tables_directory_subdirectory_errors", + "eval.tests.test_query.test_query_unknown_column_schema_error", + "eval.tests.test_query.test_query_unknown_table_error", + "eval.tests.test_query.test_query_verbose_explain", + "eval.tests.test_query.test_query_verbose_with_output_writes_file", + "eval.tests.test_query.test_query_where_clause", + "eval.tests.test_query.test_query_where_like_prefix", + "eval.tests.test_query.test_query_where_string_equals", + "eval.tests.test_schema.test_schema_all_integer_csv_infers_int64", + "eval.tests.test_schema.test_schema_csv", + "eval.tests.test_schema.test_schema_empty_csv_infers_utf8", + "eval.tests.test_schema.test_schema_json", + "eval.tests.test_schema.test_schema_jsonl_unsupported_extension", + "eval.tests.test_schema.test_schema_missing_file_error", + "eval.tests.test_schema.test_schema_parquet", + "eval.tests.test_schema.test_schema_parquet_parq_extension", + "eval.tests.test_schema.test_schema_typed_csv_boolean", + "eval.tests.test_schema.test_schema_typed_parquet_boolean", + "eval.tests.test_schema.test_schema_unsupported_extension", + "eval.tests.test_view.test_view_big_csv_100_limit", + "eval.tests.test_view.test_view_big_csv_zero_prints_all", + "eval.tests.test_view.test_view_csv_column_width_grows_with_content", + "eval.tests.test_view.test_view_csv_default_limit", + "eval.tests.test_view.test_view_csv_empty_header_only_with_limit_5", + "eval.tests.test_view.test_view_csv_limit_1", + "eval.tests.test_view.test_view_csv_limit_2", + "eval.tests.test_view.test_view_csv_limit_2_uses_ascending_rows", + "eval.tests.test_view.test_view_csv_limit_zero_removes_limit", + "eval.tests.test_view.test_view_csv_preserves_header_and_all_rows", + "eval.tests.test_view.test_view_csv_quoted_commas_kept_in_cell", + "eval.tests.test_view.test_view_directory_as_filename_rejected", + "eval.tests.test_view.test_view_empty_csv_has_no_data_rows", + "eval.tests.test_view.test_view_empty_json_file", + "eval.tests.test_view.test_view_json", + "eval.tests.test_view.test_view_json_nested_object_and_array", + "eval.tests.test_view.test_view_json_rows_with_disjoint_fields", + "eval.tests.test_view.test_view_jsonl_unsupported_extension", + "eval.tests.test_view.test_view_limit_as_very_large", + "eval.tests.test_view.test_view_malformed_csv", + "eval.tests.test_view.test_view_missing_extension", + "eval.tests.test_view.test_view_missing_file_error", + "eval.tests.test_view.test_view_parquet_big_limit_caps_but_does_not_pad", + "eval.tests.test_view.test_view_parquet_full_with_limit_0", + "eval.tests.test_view.test_view_parquet_limit_zero", + "eval.tests.test_view.test_view_parquet_parq_extension", + "eval.tests.test_view.test_view_parquet_people", + "eval.tests.test_view.test_view_short_limit_flag", + "eval.tests.test_view.test_view_typed_csv_columns", + "eval.tests.test_view.test_view_unsupported_extension" + ] + }, + "generated_module_02": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [ + { + "name": "eval.tests.test_avro_and_full_paths.test_avro_extension_dispatches_to_avro_reader", + "reasons": [ + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_avro_and_full_paths.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_avro_and_full_paths.test_avro_extension_schema_dispatch", + "reasons": [ + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_avro_and_full_paths.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_avro_and_full_paths.test_avro_missing_file_not_found", + "reasons": [ + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_avro_and_full_paths.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_avro_and_full_paths.test_convert_csv_to_json_towns", + "reasons": [ + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_avro_and_full_paths.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_avro_and_full_paths.test_count_absolute_and_relative_path_consistency", + "reasons": [ + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_avro_and_full_paths.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_avro_and_full_paths.test_query_avg_aggregate", + "reasons": [ + { + "id": "sole_returncode", + "message": "pytest test only asserts returncode == 0", + "path": "eval/tests/test_avro_and_full_paths.py", + "repair_hint": "Check stdout, stderr, generated files, or structured output in addition to exit code.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_avro_and_full_paths.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_avro_and_full_paths.test_query_order_by_desc_limit_1", + "reasons": [ + { + "id": "sole_returncode", + "message": "pytest test only asserts returncode == 0", + "path": "eval/tests/test_avro_and_full_paths.py", + "repair_hint": "Check stdout, stderr, generated files, or structured output in addition to exit code.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_avro_and_full_paths.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_avro_and_full_paths.test_query_sum_aggregate", + "reasons": [ + { + "id": "sole_returncode", + "message": "pytest test only asserts returncode == 0", + "path": "eval/tests/test_avro_and_full_paths.py", + "repair_hint": "Check stdout, stderr, generated files, or structured output in addition to exit code.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_avro_and_full_paths.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_avro_and_full_paths.test_view_zero_byte_json_file", + "reasons": [ + { + "id": "sole_returncode", + "message": "pytest test only asserts returncode == 0", + "path": "eval/tests/test_avro_and_full_paths.py", + "repair_hint": "Check stdout, stderr, generated files, or structured output in addition to exit code.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_avro_and_full_paths.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_compare.test_compare_csv_no_header_row", + "reasons": [ + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_compare.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_compare.test_compare_different_row_counts_fails", + "reasons": [ + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_compare.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_compare.test_compare_epsilon_below_difference_still_fails", + "reasons": [ + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_compare.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_compare.test_compare_epsilon_large_enough_matches", + "reasons": [ + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_compare.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_compare.test_compare_epsilon_short_flag", + "reasons": [ + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_compare.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_compare.test_compare_epsilon_tolerates_close_floats", + "reasons": [ + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_compare.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_compare.test_compare_float_without_epsilon_fails", + "reasons": [ + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_compare.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_compare.test_compare_identical_files_match", + "reasons": [ + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_compare.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_compare.test_compare_int_first_column_mismatch", + "reasons": [ + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_compare.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_compare.test_compare_json_inputs_unsupported_format", + "reasons": [ + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_compare.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_compare.test_compare_missing_second_input", + "reasons": [ + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_compare.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_compare.test_compare_null_cell_matches_identical", + "reasons": [ + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_compare.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_compare.test_compare_null_vs_value_mismatch", + "reasons": [ + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_compare.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_compare.test_compare_row_length_mismatch", + "reasons": [ + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_compare.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_compare.test_compare_same_rows_different_value_fails", + "reasons": [ + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_compare.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_compare.test_compare_utf8_mismatch", + "reasons": [ + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_compare.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_convert.test_convert_csv_to_csv_copy", + "reasons": [ + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_convert.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_convert.test_convert_json_input_to_csv", + "reasons": [ + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_convert.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_convert.test_convert_towns_csv_to_json", + "reasons": [ + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_convert.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_count.test_count_csv_empty_data", + "reasons": [ + { + "id": "sole_returncode", + "message": "pytest test only asserts returncode == 0", + "path": "eval/tests/test_count.py", + "repair_hint": "Check stdout, stderr, generated files, or structured output in addition to exit code.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_count.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_count.test_count_csv_rows", + "reasons": [ + { + "id": "sole_returncode", + "message": "pytest test only asserts returncode == 0", + "path": "eval/tests/test_count.py", + "repair_hint": "Check stdout, stderr, generated files, or structured output in addition to exit code.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_count.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_count.test_count_json_rows", + "reasons": [ + { + "id": "sole_returncode", + "message": "pytest test only asserts returncode == 0", + "path": "eval/tests/test_count.py", + "repair_hint": "Check stdout, stderr, generated files, or structured output in addition to exit code.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_count.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_count.test_count_missing_file_notfound", + "reasons": [ + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_count.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_count.test_count_multiple_rows_dataset", + "reasons": [ + { + "id": "sole_returncode", + "message": "pytest test only asserts returncode == 0", + "path": "eval/tests/test_count.py", + "repair_hint": "Check stdout, stderr, generated files, or structured output in addition to exit code.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_count.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_count.test_count_parquet_rows", + "reasons": [ + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_count.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_count.test_count_single_line_csv", + "reasons": [ + { + "id": "sole_returncode", + "message": "pytest test only asserts returncode == 0", + "path": "eval/tests/test_count.py", + "repair_hint": "Check stdout, stderr, generated files, or structured output in addition to exit code.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_count.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_count.test_count_towns_rows", + "reasons": [ + { + "id": "sole_returncode", + "message": "pytest test only asserts returncode == 0", + "path": "eval/tests/test_count.py", + "repair_hint": "Check stdout, stderr, generated files, or structured output in addition to exit code.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_count.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_count.test_count_unknown_extension_rejected", + "reasons": [ + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_count.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_errors_and_rowiter.test_error_datafusion_avro_dispatch", + "reasons": [ + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_errors_and_rowiter.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_errors_and_rowiter.test_error_datafusion_missing_file", + "reasons": [ + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_errors_and_rowiter.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_errors_and_rowiter.test_error_general_convert_avro", + "reasons": [ + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_errors_and_rowiter.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_errors_and_rowiter.test_error_general_no_extension", + "reasons": [ + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_errors_and_rowiter.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_errors_and_rowiter.test_error_general_variant_unknown_extension", + "reasons": [ + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_errors_and_rowiter.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_errors_and_rowiter.test_error_io_missing_directory_tables", + "reasons": [ + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_errors_and_rowiter.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_errors_and_rowiter.test_fileformat_json_register_and_count", + "reasons": [ + { + "id": "sole_returncode", + "message": "pytest test only asserts returncode == 0", + "path": "eval/tests/test_errors_and_rowiter.py", + "repair_hint": "Check stdout, stderr, generated files, or structured output in addition to exit code.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_errors_and_rowiter.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_errors_and_rowiter.test_rowiter_first_column_mismatch", + "reasons": [ + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_errors_and_rowiter.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_errors_and_rowiter.test_rowiter_null_cell_matches_identical", + "reasons": [ + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_errors_and_rowiter.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_errors_and_rowiter.test_rowiter_null_vs_value_mismatch", + "reasons": [ + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_errors_and_rowiter.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_errors_and_rowiter.test_rowiter_utf8_mismatch", + "reasons": [ + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_errors_and_rowiter.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_file_format.test_arrow_extension_rejected_not_unimplemented", + "reasons": [ + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_file_format.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_file_format.test_avro_extension_register_error_for_missing_file", + "reasons": [ + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_file_format.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_file_format.test_csv_extension_accepted", + "reasons": [ + { + "id": "sole_returncode", + "message": "pytest test only asserts returncode == 0", + "path": "eval/tests/test_file_format.py", + "repair_hint": "Check stdout, stderr, generated files, or structured output in addition to exit code.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_file_format.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_file_format.test_general_missing_file_csv", + "reasons": [ + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_file_format.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_file_format.test_json_extension_accepted_for_view", + "reasons": [ + { + "id": "sole_returncode", + "message": "pytest test only asserts returncode == 0", + "path": "eval/tests/test_file_format.py", + "repair_hint": "Check stdout, stderr, generated files, or structured output in addition to exit code.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_file_format.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_file_format.test_json_extension_register_error_for_missing_file", + "reasons": [ + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_file_format.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_file_format.test_multi_part_extension_uses_last", + "reasons": [ + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_file_format.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_file_format.test_no_extension_missing_error", + "reasons": [ + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_file_format.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_file_format.test_parq_extension_maps_to_parquet", + "reasons": [ + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_file_format.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_file_format.test_txt_extension_rejected", + "reasons": [ + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_file_format.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_file_format.test_uppercase_extension_is_rejected", + "reasons": [ + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_file_format.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_file_format.test_uppercase_json_extension_rejected", + "reasons": [ + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_file_format.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_file_format.test_uppercase_parquet_extension_rejected", + "reasons": [ + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_file_format.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_help_and_args.test_compare_subcommand_help", + "reasons": [ + { + "id": "sole_returncode", + "message": "pytest test only asserts returncode == 0", + "path": "eval/tests/test_help_and_args.py", + "repair_hint": "Check stdout, stderr, generated files, or structured output in addition to exit code.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_help_and_args.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "golden_no_equality", + "message": "pytest test references golden data without equality comparison", + "path": "eval/tests/test_help_and_args.py", + "repair_hint": "Compare observed output to golden data with equality after any explicit normalization.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_help_and_args.test_convert_subcommand_help", + "reasons": [ + { + "id": "sole_returncode", + "message": "pytest test only asserts returncode == 0", + "path": "eval/tests/test_help_and_args.py", + "repair_hint": "Check stdout, stderr, generated files, or structured output in addition to exit code.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_help_and_args.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "golden_no_equality", + "message": "pytest test references golden data without equality comparison", + "path": "eval/tests/test_help_and_args.py", + "repair_hint": "Compare observed output to golden data with equality after any explicit normalization.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_help_and_args.test_count_subcommand_help", + "reasons": [ + { + "id": "sole_returncode", + "message": "pytest test only asserts returncode == 0", + "path": "eval/tests/test_help_and_args.py", + "repair_hint": "Check stdout, stderr, generated files, or structured output in addition to exit code.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_help_and_args.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "golden_no_equality", + "message": "pytest test references golden data without equality comparison", + "path": "eval/tests/test_help_and_args.py", + "repair_hint": "Compare observed output to golden data with equality after any explicit normalization.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_help_and_args.test_empty_invocation_prints_usage_and_exit_1", + "reasons": [ + { + "id": "golden_no_equality", + "message": "pytest test references golden data without equality comparison", + "path": "eval/tests/test_help_and_args.py", + "repair_hint": "Compare observed output to golden data with equality after any explicit normalization.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_help_and_args.test_help_subcommand_prints_subcommands", + "reasons": [ + { + "id": "sole_returncode", + "message": "pytest test only asserts returncode == 0", + "path": "eval/tests/test_help_and_args.py", + "repair_hint": "Check stdout, stderr, generated files, or structured output in addition to exit code.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_help_and_args.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "golden_no_equality", + "message": "pytest test references golden data without equality comparison", + "path": "eval/tests/test_help_and_args.py", + "repair_hint": "Compare observed output to golden data with equality after any explicit normalization.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_help_and_args.test_help_view_subcommand_dispatch", + "reasons": [ + { + "id": "sole_returncode", + "message": "pytest test only asserts returncode == 0", + "path": "eval/tests/test_help_and_args.py", + "repair_hint": "Check stdout, stderr, generated files, or structured output in addition to exit code.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_help_and_args.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "golden_no_equality", + "message": "pytest test references golden data without equality comparison", + "path": "eval/tests/test_help_and_args.py", + "repair_hint": "Compare observed output to golden data with equality after any explicit normalization.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_help_and_args.test_query_subcommand_help", + "reasons": [ + { + "id": "sole_returncode", + "message": "pytest test only asserts returncode == 0", + "path": "eval/tests/test_help_and_args.py", + "repair_hint": "Check stdout, stderr, generated files, or structured output in addition to exit code.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_help_and_args.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "golden_no_equality", + "message": "pytest test references golden data without equality comparison", + "path": "eval/tests/test_help_and_args.py", + "repair_hint": "Compare observed output to golden data with equality after any explicit normalization.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_help_and_args.test_schema_subcommand_help", + "reasons": [ + { + "id": "sole_returncode", + "message": "pytest test only asserts returncode == 0", + "path": "eval/tests/test_help_and_args.py", + "repair_hint": "Check stdout, stderr, generated files, or structured output in addition to exit code.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_help_and_args.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "golden_no_equality", + "message": "pytest test references golden data without equality comparison", + "path": "eval/tests/test_help_and_args.py", + "repair_hint": "Compare observed output to golden data with equality after any explicit normalization.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_help_and_args.test_top_level_help_lists_all_subcommands", + "reasons": [ + { + "id": "sole_returncode", + "message": "pytest test only asserts returncode == 0", + "path": "eval/tests/test_help_and_args.py", + "repair_hint": "Check stdout, stderr, generated files, or structured output in addition to exit code.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_help_and_args.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "golden_no_equality", + "message": "pytest test references golden data without equality comparison", + "path": "eval/tests/test_help_and_args.py", + "repair_hint": "Compare observed output to golden data with equality after any explicit normalization.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_help_and_args.test_top_level_help_via_h", + "reasons": [ + { + "id": "sole_returncode", + "message": "pytest test only asserts returncode == 0", + "path": "eval/tests/test_help_and_args.py", + "repair_hint": "Check stdout, stderr, generated files, or structured output in addition to exit code.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_help_and_args.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "golden_no_equality", + "message": "pytest test references golden data without equality comparison", + "path": "eval/tests/test_help_and_args.py", + "repair_hint": "Compare observed output to golden data with equality after any explicit normalization.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_help_and_args.test_version_flag_reports_bdt_version", + "reasons": [ + { + "id": "sole_returncode", + "message": "pytest test only asserts returncode == 0", + "path": "eval/tests/test_help_and_args.py", + "repair_hint": "Check stdout, stderr, generated files, or structured output in addition to exit code.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_help_and_args.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "golden_no_equality", + "message": "pytest test references golden data without equality comparison", + "path": "eval/tests/test_help_and_args.py", + "repair_hint": "Compare observed output to golden data with equality after any explicit normalization.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_help_and_args.test_version_flag_via_capital_v", + "reasons": [ + { + "id": "sole_returncode", + "message": "pytest test only asserts returncode == 0", + "path": "eval/tests/test_help_and_args.py", + "repair_hint": "Check stdout, stderr, generated files, or structured output in addition to exit code.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_help_and_args.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "golden_no_equality", + "message": "pytest test references golden data without equality comparison", + "path": "eval/tests/test_help_and_args.py", + "repair_hint": "Compare observed output to golden data with equality after any explicit normalization.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_help_and_args.test_view_parquet_meta_subcommand_help", + "reasons": [ + { + "id": "sole_returncode", + "message": "pytest test only asserts returncode == 0", + "path": "eval/tests/test_help_and_args.py", + "repair_hint": "Check stdout, stderr, generated files, or structured output in addition to exit code.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_help_and_args.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "golden_no_equality", + "message": "pytest test references golden data without equality comparison", + "path": "eval/tests/test_help_and_args.py", + "repair_hint": "Compare observed output to golden data with equality after any explicit normalization.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_help_and_args.test_view_subcommand_help", + "reasons": [ + { + "id": "sole_returncode", + "message": "pytest test only asserts returncode == 0", + "path": "eval/tests/test_help_and_args.py", + "repair_hint": "Check stdout, stderr, generated files, or structured output in addition to exit code.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_help_and_args.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "golden_no_equality", + "message": "pytest test references golden data without equality comparison", + "path": "eval/tests/test_help_and_args.py", + "repair_hint": "Compare observed output to golden data with equality after any explicit normalization.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_more_types.test_compare_negative_float_mismatch", + "reasons": [ + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_more_types.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_more_types.test_compare_negative_floats_match", + "reasons": [ + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_more_types.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_more_types.test_compare_special_char_strings_mismatch", + "reasons": [ + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_more_types.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_more_types.test_schema_large_int_is_int64", + "reasons": [ + { + "id": "sole_returncode", + "message": "pytest test only asserts returncode == 0", + "path": "eval/tests/test_more_types.py", + "repair_hint": "Check stdout, stderr, generated files, or structured output in addition to exit code.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_more_types.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_more_types.test_view_csv_quoted_values", + "reasons": [ + { + "id": "sole_returncode", + "message": "pytest test only asserts returncode == 0", + "path": "eval/tests/test_more_types.py", + "repair_hint": "Check stdout, stderr, generated files, or structured output in addition to exit code.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_more_types.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_more_types.test_view_json_with_numeric_columns", + "reasons": [ + { + "id": "sole_returncode", + "message": "pytest test only asserts returncode == 0", + "path": "eval/tests/test_more_types.py", + "repair_hint": "Check stdout, stderr, generated files, or structured output in addition to exit code.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_more_types.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_parquet_meta.test_meta_column_statistics_min_max", + "reasons": [ + { + "id": "sole_returncode", + "message": "pytest test only asserts returncode == 0", + "path": "eval/tests/test_parquet_meta.py", + "repair_hint": "Check stdout, stderr, generated files, or structured output in addition to exit code.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_parquet_meta.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "golden_no_equality", + "message": "pytest test references golden data without equality comparison", + "path": "eval/tests/test_parquet_meta.py", + "repair_hint": "Compare observed output to golden data with equality after any explicit normalization.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_parquet_meta.test_meta_invalid_file_errors", + "reasons": [ + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_parquet_meta.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_parquet_meta.test_meta_logical_and_physical_types", + "reasons": [ + { + "id": "sole_returncode", + "message": "pytest test only asserts returncode == 0", + "path": "eval/tests/test_parquet_meta.py", + "repair_hint": "Check stdout, stderr, generated files, or structured output in addition to exit code.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_parquet_meta.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "golden_no_equality", + "message": "pytest test references golden data without equality comparison", + "path": "eval/tests/test_parquet_meta.py", + "repair_hint": "Compare observed output to golden data with equality after any explicit normalization.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_parquet_meta.test_meta_towns_dataset", + "reasons": [ + { + "id": "sole_returncode", + "message": "pytest test only asserts returncode == 0", + "path": "eval/tests/test_parquet_meta.py", + "repair_hint": "Check stdout, stderr, generated files, or structured output in addition to exit code.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_parquet_meta.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "golden_no_equality", + "message": "pytest test references golden data without equality comparison", + "path": "eval/tests/test_parquet_meta.py", + "repair_hint": "Compare observed output to golden data with equality after any explicit normalization.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_parquet_meta.test_meta_version_created_by_rows", + "reasons": [ + { + "id": "sole_returncode", + "message": "pytest test only asserts returncode == 0", + "path": "eval/tests/test_parquet_meta.py", + "repair_hint": "Check stdout, stderr, generated files, or structured output in addition to exit code.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_parquet_meta.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "golden_no_equality", + "message": "pytest test references golden data without equality comparison", + "path": "eval/tests/test_parquet_meta.py", + "repair_hint": "Compare observed output to golden data with equality after any explicit normalization.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_query.test_query_avg_aggregate", + "reasons": [ + { + "id": "sole_returncode", + "message": "pytest test only asserts returncode == 0", + "path": "eval/tests/test_query.py", + "repair_hint": "Check stdout, stderr, generated files, or structured output in addition to exit code.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_query.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_query.test_query_bad_sql_syntax_error", + "reasons": [ + { + "detail": "assert False + where False = ('DataFusion(SQL(ParserError') + where = 'Register", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_query.test_query_count_all", + "reasons": [ + { + "id": "sole_returncode", + "message": "pytest test only asserts returncode == 0", + "path": "eval/tests/test_query.py", + "repair_hint": "Check stdout, stderr, generated files, or structured output in addition to exit code.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_query.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_query.test_query_division_by_zero_error", + "reasons": [ + { + "detail": "assert False + where False = ('DataFusion(ArrowError(DivideByZero') + where = \"", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_query.test_query_group_by", + "reasons": [ + { + "id": "sole_returncode", + "message": "pytest test only asserts returncode == 0", + "path": "eval/tests/test_query.py", + "repair_hint": "Check stdout, stderr, generated files, or structured output in addition to exit code.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_query.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_query.test_query_json_table_select", + "reasons": [ + { + "detail": "AssertionError: assert '+-------+ | ...a | +-------+' == '+-------+ | ...k | +-------+' - +-------+ | name | +-------+ | Eve | | Dana | | Frank | +-------+ ? --------- + +-------+ | name | +-------+ |", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + }, + { + "id": "sole_returncode", + "message": "pytest test only asserts returncode == 0", + "path": "eval/tests/test_query.py", + "repair_hint": "Check stdout, stderr, generated files, or structured output in addition to exit code.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_query.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_query.test_query_nonexistent_column_error", + "reasons": [ + { + "detail": "assert False + where False = ('DataFusion(SchemaError(FieldNotFound ') + where ", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + }, + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_query.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_query.test_query_order_by_asc", + "reasons": [ + { + "id": "sole_returncode", + "message": "pytest test only asserts returncode == 0", + "path": "eval/tests/test_query.py", + "repair_hint": "Check stdout, stderr, generated files, or structured output in addition to exit code.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_query.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_query.test_query_order_by_desc", + "reasons": [ + { + "id": "sole_returncode", + "message": "pytest test only asserts returncode == 0", + "path": "eval/tests/test_query.py", + "repair_hint": "Check stdout, stderr, generated files, or structured output in addition to exit code.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_query.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_query.test_query_output_csv_writes_directory", + "reasons": [ + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_query.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_query.test_query_output_no_extension_error", + "reasons": [ + { + "detail": "assert 'Registering ...ery results\")' == 'General(\"Uns...ery results\")' - General(\"Unsupported file format for saving query results\") + Registering table 'people' for /tmp/pytest-of-root/pytest-2/pope", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + }, + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_query.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_query.test_query_output_unsupported_ext_error", + "reasons": [ + { + "detail": "assert 'Registering ...ery results\")' == 'General(\"Uns...ery results\")' - General(\"Unsupported file format for saving query results\") + Registering table 'people' for /tmp/pytest-of-root/pytest-2/pope", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + }, + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_query.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_query.test_query_select_all_columns", + "reasons": [ + { + "id": "sole_returncode", + "message": "pytest test only asserts returncode == 0", + "path": "eval/tests/test_query.py", + "repair_hint": "Check stdout, stderr, generated files, or structured output in addition to exit code.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_query.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_query.test_query_sql_file_path", + "reasons": [ + { + "id": "sole_returncode", + "message": "pytest test only asserts returncode == 0", + "path": "eval/tests/test_query.py", + "repair_hint": "Check stdout, stderr, generated files, or structured output in addition to exit code.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_query.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_query.test_query_sum_aggregate", + "reasons": [ + { + "id": "sole_returncode", + "message": "pytest test only asserts returncode == 0", + "path": "eval/tests/test_query.py", + "repair_hint": "Check stdout, stderr, generated files, or structured output in addition to exit code.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_query.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_query.test_query_tables_nonexistent_dir_errors", + "reasons": [ + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_query.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_query.test_query_verbose_emits_explain_plan", + "reasons": [ + { + "detail": "AssertionError: assert '+-----------...l | +-------+' == '+-------+ | ...l | +-------+' - +-------+ | name | +-------+ | Alice | | Bob | | Carol | +-------+ + +---------------+------------------------", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + }, + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_query.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_rowiter_types.test_rowiter_date32_identical_match", + "reasons": [ + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_rowiter_types.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_rowiter_types.test_rowiter_date32_mismatch", + "reasons": [ + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_rowiter_types.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_rowiter_types.test_rowiter_float32_epsilon_tolerates_diff", + "reasons": [ + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_rowiter_types.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_rowiter_types.test_rowiter_float32_identical_match", + "reasons": [ + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_rowiter_types.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_rowiter_types.test_rowiter_float32_mismatch", + "reasons": [ + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_rowiter_types.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_rowiter_types.test_rowiter_float32_without_epsilon_fails", + "reasons": [ + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_rowiter_types.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_rowiter_types.test_rowiter_float64_epsilon_below_diff_fails", + "reasons": [ + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_rowiter_types.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_rowiter_types.test_rowiter_float64_epsilon_tolerates_close", + "reasons": [ + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_rowiter_types.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_rowiter_types.test_rowiter_float64_identical_match", + "reasons": [ + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_rowiter_types.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_rowiter_types.test_rowiter_float64_mismatch", + "reasons": [ + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_rowiter_types.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_rowiter_types.test_rowiter_int64_identical_match", + "reasons": [ + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_rowiter_types.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_rowiter_types.test_rowiter_int64_mismatch", + "reasons": [ + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_rowiter_types.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_rowiter_types.test_rowiter_int8_multibatch_mismatch", + "reasons": [ + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_rowiter_types.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_rowiter_types.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_rowiter_types.test_rowiter_uint16_identical_match", + "reasons": [ + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_rowiter_types.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_rowiter_types.test_rowiter_uint16_mismatch", + "reasons": [ + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_rowiter_types.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_rowiter_types.test_rowiter_uint32_identical_match", + "reasons": [ + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_rowiter_types.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_rowiter_types.test_rowiter_uint32_mismatch", + "reasons": [ + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_rowiter_types.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_rowiter_types.test_rowiter_uint32_multibatch_mismatch", + "reasons": [ + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_rowiter_types.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_rowiter_types.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_rowiter_types.test_rowiter_uint64_identical_match", + "reasons": [ + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_rowiter_types.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_rowiter_types.test_rowiter_uint64_mismatch", + "reasons": [ + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_rowiter_types.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_rowiter_types.test_rowiter_uint8_identical_match", + "reasons": [ + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_rowiter_types.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_rowiter_types.test_rowiter_uint8_mismatch", + "reasons": [ + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_rowiter_types.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_scale_and_edge.test_compare_float64_epsilon_covers_difference", + "reasons": [ + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_scale_and_edge.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_scale_and_edge.test_compare_float64_epsilon_left_exceeds_right", + "reasons": [ + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_scale_and_edge.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_scale_and_edge.test_compare_large_multibatch_detect_last_row", + "reasons": [ + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_scale_and_edge.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_scale_and_edge.test_compare_large_multibatch_identical", + "reasons": [ + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_scale_and_edge.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_scale_and_edge.test_convert_json_to_parquet_roundtrip", + "reasons": [ + { + "detail": "AssertionError: assert '| 40 | Dana | 6.5 |' in '+-----+-------+-------+ | age | name | score | +-----+-------+-------+ | 40 | Dana | 6.5 | | 22 | Eve | 9.0 | | 33 | Frank | 8.5 | +-----+-------+-----", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_scale_and_edge.test_count_large_file", + "reasons": [ + { + "id": "sole_returncode", + "message": "pytest test only asserts returncode == 0", + "path": "eval/tests/test_scale_and_edge.py", + "repair_hint": "Check stdout, stderr, generated files, or structured output in addition to exit code.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_scale_and_edge.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_scale_and_edge.test_query_group_by_aggregate", + "reasons": [ + { + "id": "sole_returncode", + "message": "pytest test only asserts returncode == 0", + "path": "eval/tests/test_scale_and_edge.py", + "repair_hint": "Check stdout, stderr, generated files, or structured output in addition to exit code.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_scale_and_edge.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_scale_and_edge.test_view_large_file_limit", + "reasons": [ + { + "detail": "AssertionError: assert False + where False = ('+-----+ | n') + where = '+----+", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + }, + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_scale_and_edge.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_schema.test_schema_csv_columns_and_types", + "reasons": [ + { + "id": "sole_returncode", + "message": "pytest test only asserts returncode == 0", + "path": "eval/tests/test_schema.py", + "repair_hint": "Check stdout, stderr, generated files, or structured output in addition to exit code.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_schema.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_schema.test_schema_csv_is_nullable_all_yes", + "reasons": [ + { + "id": "sole_returncode", + "message": "pytest test only asserts returncode == 0", + "path": "eval/tests/test_schema.py", + "repair_hint": "Check stdout, stderr, generated files, or structured output in addition to exit code.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_schema.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_schema.test_schema_empty_file_with_header", + "reasons": [ + { + "id": "sole_returncode", + "message": "pytest test only asserts returncode == 0", + "path": "eval/tests/test_schema.py", + "repair_hint": "Check stdout, stderr, generated files, or structured output in addition to exit code.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_schema.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_schema.test_schema_json_numeric_string_types", + "reasons": [ + { + "id": "sole_returncode", + "message": "pytest test only asserts returncode == 0", + "path": "eval/tests/test_schema.py", + "repair_hint": "Check stdout, stderr, generated files, or structured output in addition to exit code.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_schema.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_schema.test_schema_json_types", + "reasons": [ + { + "id": "sole_returncode", + "message": "pytest test only asserts returncode == 0", + "path": "eval/tests/test_schema.py", + "repair_hint": "Check stdout, stderr, generated files, or structured output in addition to exit code.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_schema.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_schema.test_schema_missing_filename_arg", + "reasons": [ + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_schema.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_schema.test_schema_mixed_int_float_types", + "reasons": [ + { + "id": "sole_returncode", + "message": "pytest test only asserts returncode == 0", + "path": "eval/tests/test_schema.py", + "repair_hint": "Check stdout, stderr, generated files, or structured output in addition to exit code.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_schema.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_schema.test_schema_string_utf8_column", + "reasons": [ + { + "id": "sole_returncode", + "message": "pytest test only asserts returncode == 0", + "path": "eval/tests/test_schema.py", + "repair_hint": "Check stdout, stderr, generated files, or structured output in addition to exit code.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_schema.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_schema.test_schema_towns_second_dataset", + "reasons": [ + { + "id": "sole_returncode", + "message": "pytest test only asserts returncode == 0", + "path": "eval/tests/test_schema.py", + "repair_hint": "Check stdout, stderr, generated files, or structured output in addition to exit code.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_schema.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_schema.test_schema_unsupported_extension_error", + "reasons": [ + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_schema.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_view.test_view_csv_column_header_shown", + "reasons": [ + { + "id": "sole_returncode", + "message": "pytest test only asserts returncode == 0", + "path": "eval/tests/test_view.py", + "repair_hint": "Check stdout, stderr, generated files, or structured output in addition to exit code.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_view.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_view.test_view_csv_full_table", + "reasons": [ + { + "id": "sole_returncode", + "message": "pytest test only asserts returncode == 0", + "path": "eval/tests/test_view.py", + "repair_hint": "Check stdout, stderr, generated files, or structured output in addition to exit code.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_view.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_view.test_view_csv_limit_0_removes_limit", + "reasons": [ + { + "id": "sole_returncode", + "message": "pytest test only asserts returncode == 0", + "path": "eval/tests/test_view.py", + "repair_hint": "Check stdout, stderr, generated files, or structured output in addition to exit code.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_view.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_view.test_view_csv_limit_1_row", + "reasons": [ + { + "id": "sole_returncode", + "message": "pytest test only asserts returncode == 0", + "path": "eval/tests/test_view.py", + "repair_hint": "Check stdout, stderr, generated files, or structured output in addition to exit code.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_view.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_view.test_view_csv_limit_1_short_flag", + "reasons": [ + { + "id": "sole_returncode", + "message": "pytest test only asserts returncode == 0", + "path": "eval/tests/test_view.py", + "repair_hint": "Check stdout, stderr, generated files, or structured output in addition to exit code.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_view.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_view.test_view_csv_limit_2_mid_subset", + "reasons": [ + { + "id": "sole_returncode", + "message": "pytest test only asserts returncode == 0", + "path": "eval/tests/test_view.py", + "repair_hint": "Check stdout, stderr, generated files, or structured output in addition to exit code.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_view.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_view.test_view_csv_limit_above_row_count", + "reasons": [ + { + "id": "sole_returncode", + "message": "pytest test only asserts returncode == 0", + "path": "eval/tests/test_view.py", + "repair_hint": "Check stdout, stderr, generated files, or structured output in addition to exit code.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_view.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_view.test_view_json_columns_and_rows", + "reasons": [ + { + "id": "sole_returncode", + "message": "pytest test only asserts returncode == 0", + "path": "eval/tests/test_view.py", + "repair_hint": "Check stdout, stderr, generated files, or structured output in addition to exit code.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_view.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_view.test_view_json_limit_1", + "reasons": [ + { + "id": "sole_returncode", + "message": "pytest test only asserts returncode == 0", + "path": "eval/tests/test_view.py", + "repair_hint": "Check stdout, stderr, generated files, or structured output in addition to exit code.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_view.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_view.test_view_missing_filename_arg", + "reasons": [ + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_view.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_view.test_view_parquet_reads_back_csv_data", + "reasons": [ + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_view.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_avro_and_full_paths.test_avro_extension_dispatches_to_avro_reader", + "eval.tests.test_avro_and_full_paths.test_avro_extension_schema_dispatch", + "eval.tests.test_avro_and_full_paths.test_avro_missing_file_not_found", + "eval.tests.test_avro_and_full_paths.test_convert_csv_to_json_towns", + "eval.tests.test_avro_and_full_paths.test_count_absolute_and_relative_path_consistency", + "eval.tests.test_avro_and_full_paths.test_query_avg_aggregate", + "eval.tests.test_avro_and_full_paths.test_query_order_by_desc_limit_1", + "eval.tests.test_avro_and_full_paths.test_query_sum_aggregate", + "eval.tests.test_avro_and_full_paths.test_view_zero_byte_json_file", + "eval.tests.test_compare.test_compare_csv_no_header_row", + "eval.tests.test_compare.test_compare_different_row_counts_fails", + "eval.tests.test_compare.test_compare_epsilon_below_difference_still_fails", + "eval.tests.test_compare.test_compare_epsilon_large_enough_matches", + "eval.tests.test_compare.test_compare_epsilon_short_flag", + "eval.tests.test_compare.test_compare_epsilon_tolerates_close_floats", + "eval.tests.test_compare.test_compare_float_without_epsilon_fails", + "eval.tests.test_compare.test_compare_identical_files_match", + "eval.tests.test_compare.test_compare_int_first_column_mismatch", + "eval.tests.test_compare.test_compare_json_inputs_unsupported_format", + "eval.tests.test_compare.test_compare_missing_second_input", + "eval.tests.test_compare.test_compare_null_cell_matches_identical", + "eval.tests.test_compare.test_compare_null_vs_value_mismatch", + "eval.tests.test_compare.test_compare_row_length_mismatch", + "eval.tests.test_compare.test_compare_same_rows_different_value_fails", + "eval.tests.test_compare.test_compare_utf8_mismatch", + "eval.tests.test_convert.test_convert_csv_to_csv_copy", + "eval.tests.test_convert.test_convert_csv_to_json_single_file", + "eval.tests.test_convert.test_convert_csv_to_parq_output", + "eval.tests.test_convert.test_convert_csv_to_parquet_single_file", + "eval.tests.test_convert.test_convert_json_input_to_csv", + "eval.tests.test_convert.test_convert_to_avro_rejected", + "eval.tests.test_convert.test_convert_to_parquet_dir_without_single_file", + "eval.tests.test_convert.test_convert_towns_csv_to_json", + "eval.tests.test_convert.test_convert_unsupported_input_extension", + "eval.tests.test_convert.test_convert_unsupported_output_extension", + "eval.tests.test_convert.test_convert_zstd_parquet_readable", + "eval.tests.test_count.test_count_csv_empty_data", + "eval.tests.test_count.test_count_csv_rows", + "eval.tests.test_count.test_count_json_rows", + "eval.tests.test_count.test_count_missing_file_notfound", + "eval.tests.test_count.test_count_multiple_rows_dataset", + "eval.tests.test_count.test_count_parquet_rows", + "eval.tests.test_count.test_count_requires_table_flag", + "eval.tests.test_count.test_count_single_line_csv", + "eval.tests.test_count.test_count_towns_rows", + "eval.tests.test_count.test_count_unknown_extension_rejected", + "eval.tests.test_errors_and_rowiter.test_error_datafusion_avro_dispatch", + "eval.tests.test_errors_and_rowiter.test_error_datafusion_missing_file", + "eval.tests.test_errors_and_rowiter.test_error_general_convert_avro", + "eval.tests.test_errors_and_rowiter.test_error_general_no_extension", + "eval.tests.test_errors_and_rowiter.test_error_general_variant_unknown_extension", + "eval.tests.test_errors_and_rowiter.test_error_io_missing_directory_tables", + "eval.tests.test_errors_and_rowiter.test_fileformat_json_register_and_count", + "eval.tests.test_errors_and_rowiter.test_rowiter_first_column_mismatch", + "eval.tests.test_errors_and_rowiter.test_rowiter_null_cell_matches_identical", + "eval.tests.test_errors_and_rowiter.test_rowiter_null_vs_value_mismatch", + "eval.tests.test_errors_and_rowiter.test_rowiter_utf8_mismatch", + "eval.tests.test_file_format.test_arrow_extension_rejected_not_unimplemented", + "eval.tests.test_file_format.test_avro_extension_register_error_for_missing_file", + "eval.tests.test_file_format.test_csv_extension_accepted", + "eval.tests.test_file_format.test_general_missing_file_csv", + "eval.tests.test_file_format.test_json_extension_accepted_for_view", + "eval.tests.test_file_format.test_json_extension_register_error_for_missing_file", + "eval.tests.test_file_format.test_multi_part_extension_uses_last", + "eval.tests.test_file_format.test_no_extension_missing_error", + "eval.tests.test_file_format.test_parq_extension_maps_to_parquet", + "eval.tests.test_file_format.test_txt_extension_rejected", + "eval.tests.test_file_format.test_uppercase_extension_is_rejected", + "eval.tests.test_file_format.test_uppercase_json_extension_rejected", + "eval.tests.test_file_format.test_uppercase_parquet_extension_rejected", + "eval.tests.test_help_and_args.test_compare_missing_second_input", + "eval.tests.test_help_and_args.test_compare_subcommand_help", + "eval.tests.test_help_and_args.test_convert_missing_output_arg", + "eval.tests.test_help_and_args.test_convert_subcommand_help", + "eval.tests.test_help_and_args.test_count_missing_required_table_flag", + "eval.tests.test_help_and_args.test_count_subcommand_help", + "eval.tests.test_help_and_args.test_empty_invocation_prints_usage_and_exit_1", + "eval.tests.test_help_and_args.test_help_subcommand_prints_subcommands", + "eval.tests.test_help_and_args.test_help_view_subcommand_dispatch", + "eval.tests.test_help_and_args.test_query_subcommand_help", + "eval.tests.test_help_and_args.test_schema_missing_filename_arg", + "eval.tests.test_help_and_args.test_schema_subcommand_help", + "eval.tests.test_help_and_args.test_top_level_help_lists_all_subcommands", + "eval.tests.test_help_and_args.test_top_level_help_via_h", + "eval.tests.test_help_and_args.test_unknown_subcommand_is_rejected", + "eval.tests.test_help_and_args.test_version_flag_reports_bdt_version", + "eval.tests.test_help_and_args.test_version_flag_via_capital_v", + "eval.tests.test_help_and_args.test_view_missing_filename_arg", + "eval.tests.test_help_and_args.test_view_parquet_meta_missing_input", + "eval.tests.test_help_and_args.test_view_parquet_meta_subcommand_help", + "eval.tests.test_help_and_args.test_view_subcommand_help", + "eval.tests.test_more_types.test_compare_negative_float_mismatch", + "eval.tests.test_more_types.test_compare_negative_floats_match", + "eval.tests.test_more_types.test_compare_special_char_strings_mismatch", + "eval.tests.test_more_types.test_schema_large_int_is_int64", + "eval.tests.test_more_types.test_view_csv_quoted_values", + "eval.tests.test_more_types.test_view_json_with_numeric_columns", + "eval.tests.test_parquet_meta.test_meta_column_statistics_min_max", + "eval.tests.test_parquet_meta.test_meta_directory_path_errors", + "eval.tests.test_parquet_meta.test_meta_invalid_file_errors", + "eval.tests.test_parquet_meta.test_meta_logical_and_physical_types", + "eval.tests.test_parquet_meta.test_meta_missing_file_ioerror", + "eval.tests.test_parquet_meta.test_meta_towns_dataset", + "eval.tests.test_parquet_meta.test_meta_version_created_by_rows", + "eval.tests.test_query.test_query_avg_aggregate", + "eval.tests.test_query.test_query_bad_sql_syntax_error", + "eval.tests.test_query.test_query_count_all", + "eval.tests.test_query.test_query_dash_filename_sanitized_to_underscore", + "eval.tests.test_query.test_query_division_by_zero_error", + "eval.tests.test_query.test_query_dot_filename_sanitized", + "eval.tests.test_query.test_query_group_by", + "eval.tests.test_query.test_query_json_table_select", + "eval.tests.test_query.test_query_multi_table_join", + "eval.tests.test_query.test_query_neither_sql_nor_sqlfile_panics", + "eval.tests.test_query.test_query_nonexistent_column_error", + "eval.tests.test_query.test_query_order_by_asc", + "eval.tests.test_query.test_query_order_by_desc", + "eval.tests.test_query.test_query_output_csv_writes_directory", + "eval.tests.test_query.test_query_output_no_extension_error", + "eval.tests.test_query.test_query_output_parquet_writes_directory", + "eval.tests.test_query.test_query_output_unsupported_ext_error", + "eval.tests.test_query.test_query_parquet_table", + "eval.tests.test_query.test_query_select_all_columns", + "eval.tests.test_query.test_query_select_filtered_rows", + "eval.tests.test_query.test_query_space_filename_sanitized", + "eval.tests.test_query.test_query_sql_and_sqlfile_both_selected_panics", + "eval.tests.test_query.test_query_sql_file_path", + "eval.tests.test_query.test_query_sum_aggregate", + "eval.tests.test_query.test_query_tables_directory_registers_each_file", + "eval.tests.test_query.test_query_tables_nonexistent_dir_errors", + "eval.tests.test_query.test_query_verbose_emits_explain_plan", + "eval.tests.test_rowiter_types.test_rowiter_date32_identical_match", + "eval.tests.test_rowiter_types.test_rowiter_date32_mismatch", + "eval.tests.test_rowiter_types.test_rowiter_float32_epsilon_tolerates_diff", + "eval.tests.test_rowiter_types.test_rowiter_float32_identical_match", + "eval.tests.test_rowiter_types.test_rowiter_float32_mismatch", + "eval.tests.test_rowiter_types.test_rowiter_float32_without_epsilon_fails", + "eval.tests.test_rowiter_types.test_rowiter_float64_epsilon_below_diff_fails", + "eval.tests.test_rowiter_types.test_rowiter_float64_epsilon_tolerates_close", + "eval.tests.test_rowiter_types.test_rowiter_float64_identical_match", + "eval.tests.test_rowiter_types.test_rowiter_float64_mismatch", + "eval.tests.test_rowiter_types.test_rowiter_int64_identical_match", + "eval.tests.test_rowiter_types.test_rowiter_int64_mismatch", + "eval.tests.test_rowiter_types.test_rowiter_int8_multibatch_mismatch", + "eval.tests.test_rowiter_types.test_rowiter_timestamp_hits_unsupported_todo", + "eval.tests.test_rowiter_types.test_rowiter_uint16_identical_match", + "eval.tests.test_rowiter_types.test_rowiter_uint16_mismatch", + "eval.tests.test_rowiter_types.test_rowiter_uint32_identical_match", + "eval.tests.test_rowiter_types.test_rowiter_uint32_mismatch", + "eval.tests.test_rowiter_types.test_rowiter_uint32_multibatch_mismatch", + "eval.tests.test_rowiter_types.test_rowiter_uint64_identical_match", + "eval.tests.test_rowiter_types.test_rowiter_uint64_mismatch", + "eval.tests.test_rowiter_types.test_rowiter_uint8_identical_match", + "eval.tests.test_rowiter_types.test_rowiter_uint8_mismatch", + "eval.tests.test_scale_and_edge.test_compare_float64_epsilon_covers_difference", + "eval.tests.test_scale_and_edge.test_compare_float64_epsilon_left_exceeds_right", + "eval.tests.test_scale_and_edge.test_compare_large_multibatch_detect_last_row", + "eval.tests.test_scale_and_edge.test_compare_large_multibatch_identical", + "eval.tests.test_scale_and_edge.test_convert_json_to_parquet_roundtrip", + "eval.tests.test_scale_and_edge.test_count_large_file", + "eval.tests.test_scale_and_edge.test_query_group_by_aggregate", + "eval.tests.test_scale_and_edge.test_query_output_parquet_verifies_content", + "eval.tests.test_scale_and_edge.test_view_large_file_limit", + "eval.tests.test_schema.test_schema_csv_columns_and_types", + "eval.tests.test_schema.test_schema_csv_is_nullable_all_yes", + "eval.tests.test_schema.test_schema_empty_file_with_header", + "eval.tests.test_schema.test_schema_json_numeric_string_types", + "eval.tests.test_schema.test_schema_json_types", + "eval.tests.test_schema.test_schema_missing_filename_arg", + "eval.tests.test_schema.test_schema_mixed_int_float_types", + "eval.tests.test_schema.test_schema_string_utf8_column", + "eval.tests.test_schema.test_schema_towns_second_dataset", + "eval.tests.test_schema.test_schema_unsupported_extension_error", + "eval.tests.test_view.test_view_csv_column_header_shown", + "eval.tests.test_view.test_view_csv_full_table", + "eval.tests.test_view.test_view_csv_limit_0_removes_limit", + "eval.tests.test_view.test_view_csv_limit_1_row", + "eval.tests.test_view.test_view_csv_limit_1_short_flag", + "eval.tests.test_view.test_view_csv_limit_2_mid_subset", + "eval.tests.test_view.test_view_csv_limit_above_row_count", + "eval.tests.test_view.test_view_json_columns_and_rows", + "eval.tests.test_view.test_view_json_limit_1", + "eval.tests.test_view.test_view_missing_filename_arg", + "eval.tests.test_view.test_view_parquet_reads_back_csv_data" + ] + }, + "generated_module_04": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [ + { + "name": "eval.tests.test_compare.test_compare_bad_epsilon_value_reports_invalid_literal_on_stderr", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_compare.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_compare.test_compare_epsilon_zero_tolerance_float_differs", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_compare.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_compare.test_compare_float32_epsilon_over_tolerance_fails", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_compare.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_compare.test_compare_float32_epsilon_over_tolerance_small_eps_fails", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_compare.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_compare.test_compare_float32_epsilon_signed_delta_match_and_fail_are_directional", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_compare.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_compare.test_compare_float_parquet_without_epsilon_fails", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_compare.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_compare.test_compare_float_value_mismatch_reports_decimals", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_compare.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_compare.test_compare_help_short_flag_is_documented", + "reasons": [ + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_compare.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_compare.test_compare_missing_second_argument_reports_usage_on_stderr", + "reasons": [ + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_compare.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_compare.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_compare.test_compare_multi_value_parquet_identifies_first_discrepancy", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_compare.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_compare.test_compare_negative_epsilon_reports_diff", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_compare.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_compare.test_compare_negative_float_difference", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_compare.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_compare.test_compare_negative_value_mismatch", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_compare.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_compare.test_compare_no_arguments_reports_usage_on_stderr", + "reasons": [ + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_compare.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_compare.test_compare_no_header_flag_on_differing_headers_reveals_row0", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_compare.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_compare.test_compare_no_header_flag_reveals_first_row_difference", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_compare.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_compare.test_compare_parquet_different_value_mismatch", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_compare.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_compare.test_compare_parquet_row_count_mismatch", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_compare.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_compare.test_compare_single_char_string_difference", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_compare.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_compare.test_compare_whitespace_leading_cell_is_string_typed", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_compare.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_parquet_meta.test_parquet_meta_binary_column_reports_byte_min_max", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_parquet_meta.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_parquet_meta.test_parquet_meta_boolean_bdt_column_reports_bool_stats", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_parquet_meta.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_parquet_meta.test_parquet_meta_boolean_column_reports_bool_min_max", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_parquet_meta.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_parquet_meta.test_parquet_meta_date32_column_lists_date_logical_type", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_parquet_meta.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_parquet_meta.test_parquet_meta_decimal_column_reports_unsupported_stats", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_parquet_meta.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_parquet_meta.test_parquet_meta_double_column_reports_decimal_min_max", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_parquet_meta.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_parquet_meta.test_parquet_meta_file_level_rows_matches_total_bdt_rows", + "reasons": [ + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_parquet_meta.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_parquet_meta.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_parquet_meta.test_parquet_meta_first_row_group_heading_reports_row_and_byte_size", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_parquet_meta.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "golden_docstring", + "message": "pytest test docstring mentions golden data that is not used in the body", + "path": "eval/tests/test_parquet_meta.py", + "repair_hint": "Use the golden fixture mentioned in the docstring or remove the misleading claim.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "golden_no_equality", + "message": "pytest test references golden data without equality comparison", + "path": "eval/tests/test_parquet_meta.py", + "repair_hint": "Compare observed output to golden data with equality after any explicit normalization.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_parquet_meta.test_parquet_meta_float32_hi_fixture_reports_float_stats", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_parquet_meta.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_parquet_meta.test_parquet_meta_float32_lo_and_hi_differ_only_in_min_max", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_parquet_meta.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_parquet_meta.test_parquet_meta_float32_lo_fixture_reports_datafusion_created_by", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_parquet_meta.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_parquet_meta.test_parquet_meta_float_column_reports_float_min_max", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_parquet_meta.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_parquet_meta.test_parquet_meta_int32_column_reports_numeric_min_max", + "reasons": [ + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_parquet_meta.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_parquet_meta.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_parquet_meta.test_parquet_meta_int64_two_columns_both_listed", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_parquet_meta.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_parquet_meta.test_parquet_meta_mixed_column_types_all_listed", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_parquet_meta.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_parquet_meta.test_parquet_meta_multiple_row_groups_each_printed", + "reasons": [ + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_parquet_meta.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_parquet_meta.test_parquet_meta_no_argument_reports_usage_on_stderr", + "reasons": [ + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_parquet_meta.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_parquet_meta.test_parquet_meta_non_parquet_extension_csv_rejected", + "reasons": [ + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_parquet_meta.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_parquet_meta.test_parquet_meta_reports_single_row_group_for_one_bdt_fixture", + "reasons": [ + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_parquet_meta.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_parquet_meta.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_parquet_meta.test_parquet_meta_row_group_banner_for_single_row_bdt", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_parquet_meta.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_parquet_meta.test_parquet_meta_string_column_reports_utf8_min_max", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_parquet_meta.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + } + ], + "tests": [ + "eval.tests.test_compare.test_compare_bad_epsilon_value_reports_invalid_literal_on_stderr", + "eval.tests.test_compare.test_compare_column_count_mismatch_reports_lengths[fewer_left]", + "eval.tests.test_compare.test_compare_column_count_mismatch_reports_lengths[fewer_left_values]", + "eval.tests.test_compare.test_compare_column_count_mismatch_reports_lengths[more_left]", + "eval.tests.test_compare.test_compare_column_count_mismatch_reports_lengths[two_vs_three_rows]", + "eval.tests.test_compare.test_compare_committed_float32_fixtures_compare", + "eval.tests.test_compare.test_compare_cross_format_csv_matches_parquet", + "eval.tests.test_compare.test_compare_epsilon_does_not_apply_to_integers[int_eps_huge]", + "eval.tests.test_compare.test_compare_epsilon_does_not_apply_to_integers[int_eps_large]", + "eval.tests.test_compare.test_compare_epsilon_does_not_apply_to_integers[int_eps_zero]", + "eval.tests.test_compare.test_compare_epsilon_equal_float_values_match", + "eval.tests.test_compare.test_compare_epsilon_flag_equals_form", + "eval.tests.test_compare.test_compare_epsilon_float_second_column_match", + "eval.tests.test_compare.test_compare_epsilon_long_form_flag", + "eval.tests.test_compare.test_compare_epsilon_negative_delta_always_matches[neg_delta_signed]", + "eval.tests.test_compare.test_compare_epsilon_negative_delta_always_matches[neg_delta_under]", + "eval.tests.test_compare.test_compare_epsilon_negative_delta_always_matches[neg_delta_wide]", + "eval.tests.test_compare.test_compare_epsilon_negative_delta_always_matches[neg_delta_zero_eps]", + "eval.tests.test_compare.test_compare_epsilon_on_second_float_column_only", + "eval.tests.test_compare.test_compare_epsilon_over_tolerance_fails[eps_delta_04_over]", + "eval.tests.test_compare.test_compare_epsilon_over_tolerance_fails[eps_delta_1_over]", + "eval.tests.test_compare.test_compare_epsilon_over_tolerance_fails[eps_delta_exactly_boundary]", + "eval.tests.test_compare.test_compare_epsilon_over_tolerance_fails[eps_delta_slightly_over]", + "eval.tests.test_compare.test_compare_epsilon_over_tolerance_fails[eps_large_diff]", + "eval.tests.test_compare.test_compare_epsilon_over_tolerance_fails[eps_over_left_larger]", + "eval.tests.test_compare.test_compare_epsilon_under_tolerance_matches[eps_delta_03]", + "eval.tests.test_compare.test_compare_epsilon_under_tolerance_matches[eps_delta_04]", + "eval.tests.test_compare.test_compare_epsilon_under_tolerance_matches[eps_delta_04_alt]", + "eval.tests.test_compare.test_compare_epsilon_under_tolerance_matches[eps_tiny_delta]", + "eval.tests.test_compare.test_compare_epsilon_under_tolerance_matches[eps_under_left_larger]", + "eval.tests.test_compare.test_compare_epsilon_under_tolerance_matches[identical_with_eps]", + "eval.tests.test_compare.test_compare_epsilon_zero_tolerance_float_differs", + "eval.tests.test_compare.test_compare_float32_epsilon_over_tolerance_fail_cases[eps_1_fail]", + "eval.tests.test_compare.test_compare_float32_epsilon_over_tolerance_fail_cases[eps_2_fail]", + "eval.tests.test_compare.test_compare_float32_epsilon_over_tolerance_fail_cases[eps_half_fail]", + "eval.tests.test_compare.test_compare_float32_epsilon_over_tolerance_fails", + "eval.tests.test_compare.test_compare_float32_epsilon_over_tolerance_match_cases[eps_3_match]", + "eval.tests.test_compare.test_compare_float32_epsilon_over_tolerance_match_cases[eps_5_match]", + "eval.tests.test_compare.test_compare_float32_epsilon_over_tolerance_match_cases[eps_dot01_match]", + "eval.tests.test_compare.test_compare_float32_epsilon_over_tolerance_small_eps_fails", + "eval.tests.test_compare.test_compare_float32_epsilon_signed_delta_match_and_fail_are_directional", + "eval.tests.test_compare.test_compare_float32_epsilon_under_tolerance_matches", + "eval.tests.test_compare.test_compare_float32_epsilon_within_tolerance_matches", + "eval.tests.test_compare.test_compare_float32_identical_values_match", + "eval.tests.test_compare.test_compare_float_parquet_with_epsilon_matches", + "eval.tests.test_compare.test_compare_float_parquet_without_epsilon_fails", + "eval.tests.test_compare.test_compare_float_value_mismatch_reports_decimals", + "eval.tests.test_compare.test_compare_header_assumed_by_default_matches[ints]", + "eval.tests.test_compare.test_compare_header_assumed_by_default_matches[strings]", + "eval.tests.test_compare.test_compare_header_mismatch_without_flag_still_matches", + "eval.tests.test_compare.test_compare_header_only_files_with_no_data_rows_match", + "eval.tests.test_compare.test_compare_help_lists_subcommand_and_arguments", + "eval.tests.test_compare.test_compare_help_short_flag_is_documented", + "eval.tests.test_compare.test_compare_identical_files_report_match[floats]", + "eval.tests.test_compare.test_compare_identical_files_report_match[ints]", + "eval.tests.test_compare.test_compare_identical_files_report_match[mixed_types]", + "eval.tests.test_compare.test_compare_identical_files_report_match[multiple_rows]", + "eval.tests.test_compare.test_compare_identical_files_report_match[single_row]", + "eval.tests.test_compare.test_compare_identical_files_report_match[strings]", + "eval.tests.test_compare.test_compare_identical_files_report_match[three_cols]", + "eval.tests.test_compare.test_compare_json_files_reported_unsupported", + "eval.tests.test_compare.test_compare_long_no_header_row_flag_matches", + "eval.tests.test_compare.test_compare_missing_extension_reported", + "eval.tests.test_compare.test_compare_missing_input_file_fails[missing_input1]", + "eval.tests.test_compare.test_compare_missing_input_file_fails[missing_input2]", + "eval.tests.test_compare.test_compare_missing_second_argument_reports_usage_on_stderr", + "eval.tests.test_compare.test_compare_multi_value_parquet_identifies_first_discrepancy", + "eval.tests.test_compare.test_compare_negative_epsilon_reports_diff", + "eval.tests.test_compare.test_compare_negative_float_difference", + "eval.tests.test_compare.test_compare_negative_float_values_match", + "eval.tests.test_compare.test_compare_negative_value_mismatch", + "eval.tests.test_compare.test_compare_no_arguments_reports_usage_on_stderr", + "eval.tests.test_compare.test_compare_no_header_flag_keeps_first_row_as_data", + "eval.tests.test_compare.test_compare_no_header_flag_on_differing_headers_reveals_row0", + "eval.tests.test_compare.test_compare_no_header_flag_reveals_first_row_difference", + "eval.tests.test_compare.test_compare_parquet_different_value_mismatch", + "eval.tests.test_compare.test_compare_parquet_row_count_mismatch", + "eval.tests.test_compare.test_compare_parquet_same_values_match", + "eval.tests.test_compare.test_compare_row_count_mismatch_reports_counts[data_vs_header_only]", + "eval.tests.test_compare.test_compare_row_count_mismatch_reports_counts[four_vs_two]", + "eval.tests.test_compare.test_compare_row_count_mismatch_reports_counts[header_only_vs_data]", + "eval.tests.test_compare.test_compare_row_count_mismatch_reports_counts[one_vs_four]", + "eval.tests.test_compare.test_compare_row_count_mismatch_reports_counts[three_vs_two]", + "eval.tests.test_compare.test_compare_same_file_to_itself_reports_match", + "eval.tests.test_compare.test_compare_single_char_string_difference", + "eval.tests.test_compare.test_compare_single_data_row_all_types_match", + "eval.tests.test_compare.test_compare_single_file_parquet_to_itself_weight_match", + "eval.tests.test_compare.test_compare_string_value_mismatch_mentions_both_values[int_second_col]", + "eval.tests.test_compare.test_compare_string_value_mismatch_mentions_both_values[string_second]", + "eval.tests.test_compare.test_compare_string_value_mismatch_mentions_both_values[string_value]", + "eval.tests.test_compare.test_compare_string_with_embedded_space_matches", + "eval.tests.test_compare.test_compare_unsupported_extension_reported[bin]", + "eval.tests.test_compare.test_compare_unsupported_extension_reported[dat]", + "eval.tests.test_compare.test_compare_unsupported_extension_reported[logs]", + "eval.tests.test_compare.test_compare_unsupported_extension_reported[txt]", + "eval.tests.test_compare.test_compare_value_mismatch_reports_exact_location[first_row_value]", + "eval.tests.test_compare.test_compare_value_mismatch_reports_exact_location[last_col_value]", + "eval.tests.test_compare.test_compare_value_mismatch_reports_exact_location[last_row_value]", + "eval.tests.test_compare.test_compare_value_mismatch_reports_exact_location[second_col_value]", + "eval.tests.test_compare.test_compare_value_mismatch_reports_exact_location[third_col_value]", + "eval.tests.test_compare.test_compare_whitespace_leading_cell_is_string_typed", + "eval.tests.test_parquet_meta.test_parquet_meta_all_null_column_reports_na_min_max", + "eval.tests.test_parquet_meta.test_parquet_meta_all_null_string_column_reports_null_count", + "eval.tests.test_parquet_meta.test_parquet_meta_binary_column_reports_byte_min_max", + "eval.tests.test_parquet_meta.test_parquet_meta_boolean_bdt_column_reports_bool_stats", + "eval.tests.test_parquet_meta.test_parquet_meta_boolean_column_reports_bool_min_max", + "eval.tests.test_parquet_meta.test_parquet_meta_date32_column_lists_date_logical_type", + "eval.tests.test_parquet_meta.test_parquet_meta_decimal_column_reports_unsupported_stats", + "eval.tests.test_parquet_meta.test_parquet_meta_directory_input_fails", + "eval.tests.test_parquet_meta.test_parquet_meta_double_column_reports_decimal_min_max", + "eval.tests.test_parquet_meta.test_parquet_meta_file_level_rows_matches_total_bdt_rows", + "eval.tests.test_parquet_meta.test_parquet_meta_first_row_group_heading_reports_row_and_byte_size", + "eval.tests.test_parquet_meta.test_parquet_meta_float32_hi_fixture_reports_float_stats", + "eval.tests.test_parquet_meta.test_parquet_meta_float32_lo_and_hi_differ_only_in_min_max", + "eval.tests.test_parquet_meta.test_parquet_meta_float32_lo_fixture_reports_datafusion_created_by", + "eval.tests.test_parquet_meta.test_parquet_meta_float_column_reports_float_min_max", + "eval.tests.test_parquet_meta.test_parquet_meta_full_output_matches_committed_golden[allnull_int]", + "eval.tests.test_parquet_meta.test_parquet_meta_full_output_matches_committed_golden[allnull_str]", + "eval.tests.test_parquet_meta.test_parquet_meta_full_output_matches_committed_golden[binary]", + "eval.tests.test_parquet_meta.test_parquet_meta_full_output_matches_committed_golden[boolean]", + "eval.tests.test_parquet_meta.test_parquet_meta_full_output_matches_committed_golden[date32]", + "eval.tests.test_parquet_meta.test_parquet_meta_full_output_matches_committed_golden[decimal]", + "eval.tests.test_parquet_meta.test_parquet_meta_full_output_matches_committed_golden[double]", + "eval.tests.test_parquet_meta.test_parquet_meta_full_output_matches_committed_golden[float]", + "eval.tests.test_parquet_meta.test_parquet_meta_full_output_matches_committed_golden[int32]", + "eval.tests.test_parquet_meta.test_parquet_meta_full_output_matches_committed_golden[int64_two]", + "eval.tests.test_parquet_meta.test_parquet_meta_full_output_matches_committed_golden[mixed_stats]", + "eval.tests.test_parquet_meta.test_parquet_meta_full_output_matches_committed_golden[multi_rowgroup]", + "eval.tests.test_parquet_meta.test_parquet_meta_full_output_matches_committed_golden[string]", + "eval.tests.test_parquet_meta.test_parquet_meta_help_lists_input_argument", + "eval.tests.test_parquet_meta.test_parquet_meta_help_short_flag_lists_input_argument", + "eval.tests.test_parquet_meta.test_parquet_meta_int32_column_reports_numeric_min_max", + "eval.tests.test_parquet_meta.test_parquet_meta_int64_two_columns_both_listed", + "eval.tests.test_parquet_meta.test_parquet_meta_missing_file_reports_io_error_on_stdout", + "eval.tests.test_parquet_meta.test_parquet_meta_mixed_column_types_all_listed", + "eval.tests.test_parquet_meta.test_parquet_meta_multi_column_bdt_convert_reports_int64_and_string", + "eval.tests.test_parquet_meta.test_parquet_meta_multiple_row_groups_each_printed", + "eval.tests.test_parquet_meta.test_parquet_meta_no_argument_reports_usage_on_stderr", + "eval.tests.test_parquet_meta.test_parquet_meta_non_parquet_extension_csv_rejected", + "eval.tests.test_parquet_meta.test_parquet_meta_non_parquet_input_fails[corrupt_bytes]", + "eval.tests.test_parquet_meta.test_parquet_meta_non_parquet_input_fails[corrupt_parquet_content]", + "eval.tests.test_parquet_meta.test_parquet_meta_non_parquet_input_fails[csv_input]", + "eval.tests.test_parquet_meta.test_parquet_meta_non_parquet_input_fails[json_input]", + "eval.tests.test_parquet_meta.test_parquet_meta_on_bdt_converted_parquet", + "eval.tests.test_parquet_meta.test_parquet_meta_physical_and_logical_type[boolean_phys]", + "eval.tests.test_parquet_meta.test_parquet_meta_physical_and_logical_type[date32_int32]", + "eval.tests.test_parquet_meta.test_parquet_meta_physical_and_logical_type[double_phys]", + "eval.tests.test_parquet_meta.test_parquet_meta_physical_and_logical_type[float_phys]", + "eval.tests.test_parquet_meta.test_parquet_meta_physical_and_logical_type[int32_phys]", + "eval.tests.test_parquet_meta.test_parquet_meta_physical_and_logical_type[string_byte_array]", + "eval.tests.test_parquet_meta.test_parquet_meta_report_file_level_metadata[boolean]", + "eval.tests.test_parquet_meta.test_parquet_meta_report_file_level_metadata[decimal]", + "eval.tests.test_parquet_meta.test_parquet_meta_report_file_level_metadata[double]", + "eval.tests.test_parquet_meta.test_parquet_meta_report_file_level_metadata[float]", + "eval.tests.test_parquet_meta.test_parquet_meta_report_file_level_metadata[int32]", + "eval.tests.test_parquet_meta.test_parquet_meta_report_file_level_metadata[mixed]", + "eval.tests.test_parquet_meta.test_parquet_meta_report_file_level_metadata[multi_rowgroup]", + "eval.tests.test_parquet_meta.test_parquet_meta_report_file_level_metadata[string]", + "eval.tests.test_parquet_meta.test_parquet_meta_reports_single_row_group_for_one_bdt_fixture", + "eval.tests.test_parquet_meta.test_parquet_meta_row_group_banner_for_single_row_bdt", + "eval.tests.test_parquet_meta.test_parquet_meta_single_row_group_for_small_bdt_convert", + "eval.tests.test_parquet_meta.test_parquet_meta_string_column_reports_utf8_min_max" + ] + } + }, + "commit": "5c6730a8e3cd43c7847aef76b499197730cded58", + "data_source": "synthetic_programgym", + "difficulty": "easy", + "difficulty_score": 1.6940784620807596, + "eval_clean_hashes": [ + "8904e8c92a77bfbdb869294b9bc5cabcc6be00574ce9ceed153ba6ed4b182e0b" + ], + "input_record": { + "codeql_db_mb": 83.75, + "codeql_status": true, + "codeql_time": 62.48939963406883, + "commit": "5c6730a8e3cd43c7847aef76b499197730cded58", + "commits": 68, + "contributors": 5, + "difficulty": "easy", + "difficulty_code_lines": 824, + "difficulty_has_tests": false, + "difficulty_product_code_lines": 824, + "difficulty_runtime_deps": 5, + "difficulty_score": 1.6940784620807596, + "difficulty_test_code_lines": 0, + "full_name": "datafusion-contrib/bdt", + "github_stars": 245, + "input_codeql_db": "rust_codeql/datafusion-contrib__bdt", + "language": "rs", + "pb_match": [ + { + "pb_fullname": "BurntSushi/xsv", + "rank": 44, + "similarity": 0.572548508644104 + }, + { + "pb_fullname": "AmmarAbouZor/tui-journal", + "rank": 589, + "similarity": 0.4910200834274292 + }, + { + "pb_fullname": "Miserlou/Loop", + "rank": 611, + "similarity": 0.4487597942352295 + }, + { + "pb_fullname": "Drew-Alleman/DataSurgeon", + "rank": 204, + "similarity": 0.5362170934677124 + }, + { + "pb_fullname": "Canop/rhit", + "rank": 157, + "similarity": 0.48451825976371765 + }, + { + "pb_fullname": "bootandy/dust", + "rank": 764, + "similarity": 0.4699964225292206 + }, + { + "pb_fullname": "sharkdp/hyperfine", + "rank": 200, + "similarity": 0.5055456161499023 + }, + { + "pb_fullname": "jhspetersson/fselect", + "rank": 258, + "similarity": 0.48437851667404175 + }, + { + "pb_fullname": "kaushiksrini/parqeye", + "rank": 269, + "similarity": 0.4985395669937134 + }, + { + "pb_fullname": "orf/gping", + "rank": 776, + "similarity": 0.447904109954834 + }, + { + "pb_fullname": "sstadick/hck", + "rank": 245, + "similarity": 0.468997985124588 + }, + { + "pb_fullname": "bensadeh/tailspin", + "rank": 192, + "similarity": 0.5273425579071045 + }, + { + "pb_fullname": "Isona/dirble", + "rank": 782, + "similarity": 0.4493521749973297 + }, + { + "pb_fullname": "o2sh/onefetch", + "rank": 913, + "similarity": 0.45057007670402527 + }, + { + "pb_fullname": "riquito/tuc", + "rank": 680, + "similarity": 0.42308545112609863 + }, + { + "pb_fullname": "rcoh/angle-grinder", + "rank": 901, + "similarity": 0.45493701100349426 + }, + { + "pb_fullname": "mgdm/htmlq", + "rank": 853, + "similarity": 0.4382629692554474 + }, + { + "pb_fullname": "nikolassv/bartib", + "rank": 197, + "similarity": 0.4836254417896271 + }, + { + "pb_fullname": "KSXGitHub/parallel-disk-usage", + "rank": 724, + "similarity": 0.45985567569732666 + }, + { + "pb_fullname": "rochacbruno/marmite", + "rank": 392, + "similarity": 0.4406341016292572 + }, + { + "pb_fullname": "agourlay/zip-password-finder", + "rank": 998, + "similarity": 0.4528661370277405 + }, + { + "pb_fullname": "XAMPPRocky/tokei", + "rank": 759, + "similarity": 0.41593998670578003 + }, + { + "pb_fullname": "wfxr/csview", + "rank": 937, + "similarity": 0.4373551607131958 + }, + { + "pb_fullname": "yaa110/nomino", + "rank": 810, + "similarity": 0.4295511245727539 + } + ], + "repo_age": 4.16, + "repo_path": "rust/datafusion-contrib__bdt", + "rust_channel": "stable", + "rust_edition": "2021", + "rust_release_date": "2021-10-21", + "rust_version": "1.56.0", + "rust_version_source": "edition", + "source": "commit:5c6730a8e3cd43c7847aef76b499197730cded58", + "status": "done", + "url": "https://github.com/datafusion-contrib/bdt" + }, + "instance_id": "datafusion-contrib__bdt.5c6730a", + "language": "rust", + "module_iterations": [ + { + "actual_iterations": 5, + "branch_name": "generated_module_01", + "iteration_limit": 5, + "module_index": 1, + "module_kind": "source", + "termination_reason": "max_iterations" + }, + { + "actual_iterations": 5, + "branch_name": "generated_module_02", + "iteration_limit": 5, + "module_index": 2, + "module_kind": "source", + "termination_reason": "max_iterations" + }, + { + "actual_iterations": 5, + "branch_name": "generated_module_03", + "iteration_limit": 5, + "module_index": 3, + "module_kind": "source", + "termination_reason": "max_iterations" + }, + { + "actual_iterations": 5, + "branch_name": "generated_module_04", + "iteration_limit": 5, + "module_index": 4, + "module_kind": "source", + "termination_reason": "max_iterations" + } + ], + "repository": "datafusion-contrib/bdt" +}