Allow to specify a generator with find-bad-case.

Author: veluca93

src/tools/find_bad_case/dag.rs

@@ -1,12 +1,13 @@
 use std::collections::HashMap;
 use std::path::{Path, PathBuf};
+use std::sync::Arc;
 
 use anyhow::{anyhow, bail, Context, Error};
 
 use task_maker_format::ioi::{
     InputGenerator, SubtaskInfo, TestcaseId, TestcaseInfo, GENERATION_PRIORITY,
 };
-use task_maker_format::{EvaluationData, TaskFormat};
+use task_maker_format::{EvaluationData, SourceFile, TaskFormat};
 
 /// The information about a testcase to generate.
 #[derive(Debug, Clone, Default)]
@@ -33,6 +34,7 @@ pub struct Batch {
 /// testcases instead of the normal ones.
 pub fn patch_task_for_batch(
     task: &mut TaskFormat,
+    generator: &Option<Arc<SourceFile>>,
     generator_args: &[String],
     batch_size: usize,
     batch_index: usize,
@@ -66,8 +68,11 @@ pub fn patch_task_for_batch(
                     InputGenerator::StaticFile(_) => {
                         unreachable!("The generator cannot be StaticFile")
                     }
-                    InputGenerator::Custom(_, args) => {
+                    InputGenerator::Custom(g, args) => {
                         args.clone_from(&generator_args);
+                        if let Some(generator) = generator {
+                            *g = generator.clone();
+                        }
                     }
                 }
 

src/tools/find_bad_case/mod.rs

@@ -7,6 +7,7 @@ use clap::{Parser, ValueHint};
 use task_maker_exec::ductile::ChannelSender;
 use task_maker_exec::proto::ExecutorClientMessage;
 use task_maker_exec::ExecutorClient;
+use task_maker_format::ioi::get_generator;
 use task_maker_format::ui::{CursesUI, StdoutPrinter, UIMessage, BLUE, BOLD, RED, UI, YELLOW};
 use task_maker_format::{cwrite, cwriteln, get_sanity_check_list, EvaluationConfig};
 
@@ -38,6 +39,10 @@ pub struct FindBadCaseOpt {
     #[clap(long, short, default_value = "100")]
     pub batch_size: usize,
 
+    /// Name of the generator to use.
+    #[clap(long, short)]
+    pub generator: Option<String>,
+
     /// Path to the solution to check against the official solution of the task.
     #[clap(value_hint = ValueHint::FilePath)]
     pub solution: PathBuf,
@@ -81,6 +86,11 @@ pub fn main_find_bad_case(opt: FindBadCaseOpt) -> Result<(), Error> {
 
     let task = opt.find_task.find_task(&eval_config)?;
     let task_path = task.path().to_path_buf();
+    let generator = opt
+        .generator
+        .as_ref()
+        .map(|x| get_generator(&format!("gen_{x}"), &task_path))
+        .transpose()?;
 
     // Create a single UI for all the batches.
     let ui_state = UIState::new(&opt, stop_evaluation);
@@ -120,6 +130,7 @@ pub fn main_find_bad_case(opt: FindBadCaseOpt) -> Result<(), Error> {
         let mut task = opt.find_task.find_task(&eval_config)?;
         let batch = patch_task_for_batch(
             &mut task,
+            &generator,
             &opt.generator_args,
             opt.batch_size,
             batch_index,

task-maker-format/src/ioi/format/italian_toml/gen_toml.rs

@@ -234,7 +234,26 @@ fn detect_validator(task_dir: &Path, validator: &str) -> Result<Arc<SourceFile>>
     Ok(validators.pop().map(Arc::new).unwrap())
 }
 
-pub fn parse(
+/// Finds a generator with the specified name.
+pub fn get_generator(generator: &str, task_dir: &Path) -> Result<Arc<SourceFile>> {
+    let mut generators = find_source_file(
+        task_dir,
+        vec![&format!("gen/{generator}.*")],
+        task_dir,
+        "Input file generator at",
+        None,
+        WriteBinTo::None,
+    );
+    if generators.len() > 1 {
+        let paths = generators.iter().map(|s| s.name()).collect::<Vec<_>>();
+        bail!("Multiple generators found: {:?}", paths);
+    } else if generators.is_empty() {
+        bail!("No generator `{generator}` found");
+    }
+    Ok(generators.pop().map(Arc::new).unwrap())
+}
+
+pub(super) fn parse(
     task_dir: &Path,
     config: &TaskYAML,
     grader_map: Arc<GraderMap>,
@@ -298,24 +317,6 @@ pub fn parse(
         }
     }
 
-    let get_generator = |generator: &str| {
-        let mut generators = find_source_file(
-            task_dir,
-            vec![&format!("gen/{generator}.*")],
-            task_dir,
-            "Input file generator at",
-            None,
-            WriteBinTo::None,
-        );
-        if generators.len() > 1 {
-            let paths = generators.iter().map(|s| s.name()).collect::<Vec<_>>();
-            bail!("Multiple generators found: {:?}", paths);
-        } else if generators.is_empty() {
-            bail!("No generator `{generator}` found");
-        }
-        Ok(generators.pop().map(Arc::new).unwrap())
-    };
-
     let mut process_group = |name: &str, group: &mut GroupConfig| -> Result<()> {
         group.resolve_repeats();
         let mut constants = constants.clone();
@@ -361,7 +362,7 @@ pub fn parse(
                     .push(id);
             }
             let generator = testcase.generator().unwrap_or(generator);
-            let generator = get_generator(generator)?;
+            let generator = get_generator(generator, task_dir)?;
             let input_generator =
                 InputGenerator::Custom(generator, testcase.args().instantiate(&constants)?);
             testcases.insert(

task-maker-format/src/ioi/format/italian_toml/mod.rs

@@ -16,7 +16,7 @@ use crate::ioi::{
 };
 use crate::{find_source_file, list_files, EvaluationConfig, WriteBinTo};
 
-mod gen_toml;
+pub(in crate::ioi) mod gen_toml;
 
 pub fn parse_task<P: AsRef<Path>>(
     task_dir: P,

task-maker-format/src/ioi/mod.rs

@@ -52,6 +52,8 @@ mod statement;
 pub(crate) mod task_info;
 pub(crate) mod ui_state;
 
+pub use format::italian_toml::gen_toml::get_generator;
+
 /// In IOI tasks the subtask numbers are non-negative 0-based integers.
 pub type SubtaskId = u32;
 /// In IOI tasks the testcase numbers are non-negative 0-based integers.