Function equation_test_template

poly-commit/src/lib.rs:902–1081

(info: TestInfo<F, P, S>)

    }

    fn equation_test_template<F, P, PC, S>(info: TestInfo<F, P, S>) -> Result<(), PC::Error>
    where
        F: PrimeField,
        P: Polynomial<F>,
        PC: PolynomialCommitment<F, P>,
        S: CryptographicSponge,
    {
        let TestInfo {
            num_iters,
            max_degree,
            supported_degree,
            num_vars,
            num_polynomials,
            enforce_degree_bounds,
            max_num_queries,
            num_equations,
            rand_poly,
            rand_point,
            sponge,
        } = info;

        let sponge = sponge();

        let rng = &mut ChaCha20Rng::from_rng(test_rng()).unwrap();
        // If testing multivariate polynomials, make the max degree lower
        let max_degree = match num_vars {
            Some(_) => max_degree.unwrap_or(Uniform::from(2..=10).sample(rng)),
            None => max_degree.unwrap_or(Uniform::from(2..=64).sample(rng)),
        };
        let pp = PC::setup(max_degree, num_vars, rng)?;

        for _ in 0..num_iters {
            let supported_degree =
                supported_degree.unwrap_or(Uniform::from(1..=max_degree).sample(rng));
            assert!(
                max_degree >= supported_degree,
                "max_degree < supported_degree"
            );
            let mut polynomials = Vec::new();
            let mut degree_bounds = if enforce_degree_bounds {
                Some(Vec::new())
            } else {
                None
            };

            let mut labels = Vec::new();
            println!("Sampled supported degree");

            // Generate polynomials
            let num_points_in_query_set = Uniform::from(1..=max_num_queries).sample(rng);
            for i in 0..num_polynomials {
                let label = format!("Test{}", i);
                labels.push(label.clone());
                let degree = Uniform::from(1..=supported_degree).sample(rng);
                let degree_bound = if let Some(degree_bounds) = &mut degree_bounds {
                    if rng.gen() {
                        let range = Uniform::from(degree..=supported_degree);
                        let degree_bound = range.sample(rng);