Method run

datafusion/core/tests/fuzz_cases/sort_query_fuzz.rs:192–238

(&mut self)

    }

    pub async fn run(&mut self) -> Result<()> {
        let start_time = Instant::now();

        // Execute until either`max_rounds` or `time_limit` is reached
        let max_rounds = self.max_rounds.unwrap_or(usize::MAX);
        for round in 0..max_rounds {
            let init_seed = self.runner_rng.random();
            for query_i in 0..self.queries_per_round {
                let query_seed = self.runner_rng.random();
                let mut expected_results: Option<Vec<RecordBatch>> = None; // use first config's result as the expected result
                for config_i in 0..self.config_variations_per_query {
                    if self.should_stop_due_to_time_limit(start_time, round, query_i) {
                        return Ok(());
                    }

                    let config_seed = self.runner_rng.random();

                    println!(
                        "[SortQueryFuzzer] Round {round}, Query {query_i} (Config {config_i})"
                    );
                    println!("  Seeds:");
                    println!("    init_seed   = {init_seed}");
                    println!("    query_seed  = {query_seed}");
                    println!("    config_seed = {config_seed}");

                    let results = self
                        .test_gen
                        .fuzzer_run(init_seed, query_seed, config_seed)
                        .await?;
                    println!("\n"); // Separator between tested runs

                    if expected_results.is_none() {
                        expected_results = Some(results);
                    } else if let Some(ref expected) = expected_results {
                        // `fuzzer_run` might append `LIMIT k` to either the
                        // expected or actual query. The number of results is
                        // checked inside `fuzzer_run()`. Here we only check
                        // that the first k rows of each result are consistent.
                        check_equality_of_batches(expected, &results).unwrap();
                    } else {
                        unreachable!();
                    }
                }
            }
        }
        Ok(())
    }
}

/// Struct to generate and manage a random dataset for fuzz testing.