blob: 134ad522eff4d1789f113f57b778745fd12f9322 [file]
// Copyright 2026 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//! [`Domain`] implementations for native Rust tuples.
//!
//! Any tuple `(T0, ...)` of domains (from 0 up to 12 elements) is itself a [`Domain`] that
//! generates tuples of elements drawn from the inner domains.
//!
//! # Examples
//!
//! ```
//! # use fuzztest::domains::Domain;
//! # use fuzztest::domains::arbitrary::Arbitrary;
//! # use fuzztest::domains::range::InRange;
//! # use rand::rngs::SmallRng;
//! # use rand::SeedableRng;
//! let mut domain = (InRange::new(0i32, 10), Arbitrary::<bool>::default());
//! let mut rng = SmallRng::seed_from_u64(42);
//!
//! let sample = domain.init(&mut rng).unwrap();
//! assert!((0..=10).contains(&sample.0));
//! ```
use super::{Domain, ReversibleDomain};
use anyhow::{Context, Result};
use rand::{Rng, RngExt};
impl Domain for () {
type UserValue<'user> = ();
type CorpusValue = ();
fn init(&mut self, _rng: &mut dyn Rng) -> Result<Self::CorpusValue> {
Ok(())
}
fn mutate(
&mut self,
_corpus_value: &mut Self::CorpusValue,
_rng: &mut dyn Rng,
_only_shrink: bool,
) -> Result<()> {
Ok(())
}
fn corpus_to_user_value<'a>(
&self,
_corpus_value: &'a Self::CorpusValue,
) -> Result<Self::UserValue<'a>> {
Ok(())
}
}
impl ReversibleDomain<()> for () {
fn to_unvalidated_corpus_value(&self, _value: ()) -> Result<Self::CorpusValue> {
Ok(())
}
}
impl<'a> ReversibleDomain<&'a ()> for () {
fn to_unvalidated_corpus_value(&self, _value: &'a ()) -> Result<Self::CorpusValue> {
Ok(())
}
}
macro_rules! impl_domain_for_tuple {
($( $idx:tt : $ty:ident / $seed_ty:ident ),+ $(,)?) => {
impl<$( $ty ),+> Domain for ( $( $ty, )+ )
where
$( $ty: Domain, )+
{
type UserValue<'user> = ( $( $ty::UserValue<'user>, )+ );
type CorpusValue = ( $( $ty::CorpusValue, )+ );
fn init(&mut self, rng: &mut dyn Rng) -> Result<Self::CorpusValue> {
Ok(( $( self.$idx.init(rng)?, )+ ))
}
fn mutate(
&mut self,
corpus_value: &mut Self::CorpusValue,
rng: &mut dyn Rng,
only_shrink: bool,
) -> Result<()> {
const COUNT: usize = [$( $idx ),+].len();
match rng.random_range(0..COUNT) {
$(
$idx => self.$idx.mutate(&mut corpus_value.$idx, rng, only_shrink),
)+
_ => unreachable!(),
}
}
fn corpus_to_user_value<'a>(
&self,
corpus_value: &'a Self::CorpusValue,
) -> Result<Self::UserValue<'a>> {
Ok(( $( self.$idx.corpus_to_user_value(&corpus_value.$idx)?, )+ ))
}
fn validate_corpus_value(&self, corpus_value: &Self::CorpusValue) -> Result<()> {
$(
self.$idx
.validate_corpus_value(&corpus_value.$idx)
.with_context(|| format!("Invalid value in tuple element {}", $idx))?;
)+
Ok(())
}
}
impl<$( $ty, $seed_ty ),+> ReversibleDomain<( $( $seed_ty, )+ )> for ( $( $ty, )+ )
where
$( $ty: ReversibleDomain<$seed_ty>, )+
{
fn to_unvalidated_corpus_value(
&self,
value: ( $( $seed_ty, )+ ),
) -> Result<Self::CorpusValue> {
Ok(( $(
self.$idx
.to_unvalidated_corpus_value(value.$idx)
.with_context(|| {
format!("Failed to convert seed in tuple element {}", $idx)
})?,
)+ ))
}
}
impl<'a, $( $ty, $seed_ty ),+> ReversibleDomain<&'a ( $( $seed_ty, )+ )> for ( $( $ty, )+ )
where
$( $ty: ReversibleDomain<&'a $seed_ty>, )+
{
fn to_unvalidated_corpus_value(
&self,
value: &'a ( $( $seed_ty, )+ ),
) -> Result<Self::CorpusValue> {
Ok(( $(
self.$idx
.to_unvalidated_corpus_value(&value.$idx)
.with_context(|| {
format!("Failed to convert seed in tuple element {}", $idx)
})?,
)+ ))
}
}
};
}
impl_domain_for_tuple!(0: T0 / S0);
impl_domain_for_tuple!(0: T0 / S0, 1: T1 / S1);
impl_domain_for_tuple!(0: T0 / S0, 1: T1 / S1, 2: T2 / S2);
impl_domain_for_tuple!(0: T0 / S0, 1: T1 / S1, 2: T2 / S2, 3: T3 / S3);
impl_domain_for_tuple!(0: T0 / S0, 1: T1 / S1, 2: T2 / S2, 3: T3 / S3, 4: T4 / S4);
impl_domain_for_tuple!(0: T0 / S0, 1: T1 / S1, 2: T2 / S2, 3: T3 / S3, 4: T4 / S4, 5: T5 / S5);
impl_domain_for_tuple!(
0: T0 / S0,
1: T1 / S1,
2: T2 / S2,
3: T3 / S3,
4: T4 / S4,
5: T5 / S5,
6: T6 / S6
);
impl_domain_for_tuple!(
0: T0 / S0,
1: T1 / S1,
2: T2 / S2,
3: T3 / S3,
4: T4 / S4,
5: T5 / S5,
6: T6 / S6,
7: T7 / S7
);
impl_domain_for_tuple!(
0: T0 / S0,
1: T1 / S1,
2: T2 / S2,
3: T3 / S3,
4: T4 / S4,
5: T5 / S5,
6: T6 / S6,
7: T7 / S7,
8: T8 / S8
);
impl_domain_for_tuple!(
0: T0 / S0,
1: T1 / S1,
2: T2 / S2,
3: T3 / S3,
4: T4 / S4,
5: T5 / S5,
6: T6 / S6,
7: T7 / S7,
8: T8 / S8,
9: T9 / S9
);
impl_domain_for_tuple!(
0: T0 / S0,
1: T1 / S1,
2: T2 / S2,
3: T3 / S3,
4: T4 / S4,
5: T5 / S5,
6: T6 / S6,
7: T7 / S7,
8: T8 / S8,
9: T9 / S9,
10: T10 / S10
);
impl_domain_for_tuple!(
0: T0 / S0,
1: T1 / S1,
2: T2 / S2,
3: T3 / S3,
4: T4 / S4,
5: T5 / S5,
6: T6 / S6,
7: T7 / S7,
8: T8 / S8,
9: T9 / S9,
10: T10 / S10,
11: T11 / S11
);
#[cfg(test)]
mod tests {
use super::*;
use crate::domains::arbitrary::Arbitrary;
use crate::domains::containers::{ContainerDomain, VecOf};
use crate::domains::range::InRange;
use crate::domains::utility::iterations_to_hit_all;
use crate::domains::SeedableDomainExt;
use googletest::prelude::*;
use rand::rngs::{SmallRng, SysRng};
use rand::SeedableRng;
use std::collections::HashSet;
fn get_rng() -> SmallRng {
SmallRng::try_from_rng(&mut SysRng).expect("Failed to create RNG")
}
#[gtest]
fn test_tuple_of_1_domain() {
let mut domain = (InRange::new(10i32, 20),);
let mut rng = get_rng();
for _ in 0..50 {
let mut val = domain.init(&mut rng).unwrap();
expect_that!(val.0, all!(ge(10), le(20)));
expect_that!(domain.validate_corpus_value(&val), ok(anything()));
expect_that!(domain.corpus_to_user_value(&val).unwrap(), eq(val));
domain.mutate(&mut val, &mut rng, false).unwrap();
expect_that!(val.0, all!(ge(10), le(20)));
}
// Verify shrinking vs non-shrinking on 1-tuple.
let mut arb_domain = (Arbitrary::<i32>::default(),);
let mut zero_val = (0i32,);
arb_domain.mutate(&mut zero_val, &mut rng, true).unwrap();
expect_that!(zero_val, eq((0,)));
arb_domain.mutate(&mut zero_val, &mut rng, false).unwrap();
expect_that!(zero_val, not(eq((0,))));
let mut shrink_val = (1000i32,);
arb_domain.mutate(&mut shrink_val, &mut rng, true).unwrap();
expect_that!(shrink_val.0, all!(ge(0), lt(1000)));
expect_that!(domain.validate_corpus_value(&(5,)), err(anything()));
expect_that!(domain.validate_corpus_value(&(25,)), err(anything()));
}
#[gtest]
fn test_tuple_of_2_init_and_corpus_to_user_value() {
let mut domain = (InRange::new(-5i32, 5), VecOf::new(InRange::new(1u8, 3)).with_len(2));
let mut rng = get_rng();
for _ in 0..50 {
let corpus_val = domain.init(&mut rng).unwrap();
expect_that!(corpus_val.0, all!(ge(-5), le(5)));
expect_that!(corpus_val.1.len(), eq(2));
for &elem in &corpus_val.1 {
expect_that!(elem, all!(ge(1), le(3)));
}
let user_val = domain.corpus_to_user_value(&corpus_val).unwrap();
expect_that!(user_val, eq(&corpus_val));
}
}
struct BorrowedStrDomain;
impl Domain for BorrowedStrDomain {
type UserValue<'user> = &'user str;
type CorpusValue = String;
fn init(&mut self, _rng: &mut dyn Rng) -> anyhow::Result<Self::CorpusValue> {
Ok(String::from("hello"))
}
fn mutate(
&mut self,
corpus_value: &mut Self::CorpusValue,
_rng: &mut dyn Rng,
_only_shrink: bool,
) -> anyhow::Result<()> {
corpus_value.push('!');
Ok(())
}
fn corpus_to_user_value<'a>(
&self,
corpus_value: &'a Self::CorpusValue,
) -> anyhow::Result<Self::UserValue<'a>> {
Ok(corpus_value.as_str())
}
}
#[gtest]
fn test_tuple_of_custom_and_borrowing_corpus_to_user_value() {
let mut domain = (BorrowedStrDomain, InRange::new(10i32, 20));
let mut rng = get_rng();
let mut corpus_val: (String, i32) = domain.init(&mut rng).unwrap();
let user_val: (&str, i32) = domain.corpus_to_user_value(&corpus_val).unwrap();
expect_that!(user_val.0, eq("hello"));
expect_that!(user_val.1, all!(ge(10), le(20)));
domain.mutate(&mut corpus_val, &mut rng, false).unwrap();
let mutated_user_val: (&str, i32) = domain.corpus_to_user_value(&corpus_val).unwrap();
expect_that!(mutated_user_val.0, any!(eq("hello"), eq("hello!")));
expect_that!(mutated_user_val.1, all!(ge(10), le(20)));
}
#[gtest]
fn test_tuple_of_mutate_mutates_one_element_per_step_and_covers_all() {
let mut domain =
(Arbitrary::<i32>::default(), Arbitrary::<i32>::default(), Arbitrary::<i32>::default());
let mut rng = get_rng();
let mut val = (0, 0, 0);
let mut mutated_0 = false;
let mut mutated_1 = false;
let mut mutated_2 = false;
for _ in 0..iterations_to_hit_all(3, 1.0 / 3.0) {
let prev = val;
domain.mutate(&mut val, &mut rng, false).unwrap();
let changed_0 = val.0 != prev.0;
let changed_1 = val.1 != prev.1;
let changed_2 = val.2 != prev.2;
let changed_count =
usize::from(changed_0) + usize::from(changed_1) + usize::from(changed_2);
expect_that!(
changed_count,
eq(1),
"Each tuple mutation step should mutate exactly one element"
);
mutated_0 |= changed_0;
mutated_1 |= changed_1;
mutated_2 |= changed_2;
}
expect_true!(mutated_0);
expect_true!(mutated_1);
expect_true!(mutated_2);
}
#[gtest]
fn test_tuple_of_shrink_converges_to_target() {
let mut domain =
(Arbitrary::<i32>::default(), Arbitrary::<u8>::default(), Arbitrary::<bool>::default());
let mut rng = get_rng();
let mut val = (1000i32, 200u8, true);
for _ in 0..1000 {
if val == (0, 0, false) {
break;
}
let prev = val;
domain.mutate(&mut val, &mut rng, true).unwrap();
expect_that!(val.0.abs(), le(prev.0.abs()));
expect_that!(val.1, le(prev.1));
if !prev.2 {
expect_that!(val.2, eq(false));
}
}
expect_that!(val, eq((0, 0, false)));
// Shrinking at target must stay at target.
domain.mutate(&mut val, &mut rng, true).unwrap();
expect_that!(val, eq((0, 0, false)));
}
#[gtest]
fn test_tuple_of_validate_corpus_value() {
let constrained = (
InRange::new(10i32, 20),
VecOf::new(InRange::new(1u8, 5)).with_min_len(1).with_max_len(2),
);
let valid_val = (15i32, vec![2u8, 4u8]);
expect_that!(constrained.validate_corpus_value(&valid_val), ok(anything()));
let invalid_first = (5i32, vec![2u8, 4u8]);
expect_that!(constrained.validate_corpus_value(&invalid_first), err(anything()));
let invalid_second_elem = (15i32, vec![2u8, 9u8]);
expect_that!(constrained.validate_corpus_value(&invalid_second_elem), err(anything()));
let invalid_second_len = (15i32, Vec::<u8>::new());
expect_that!(constrained.validate_corpus_value(&invalid_second_len), err(anything()));
}
#[gtest]
fn test_tuple_of_serde_roundtrip() {
let domain = (
InRange::new(10i32, 20),
VecOf::new(InRange::new(1u8, 5)).with_min_len(1).with_max_len(2),
);
let val = (15i32, vec![2u8, 4u8]);
let bytes = domain.serialize_corpus(&val).unwrap();
expect_that!(domain.parse_corpus(&bytes).unwrap(), eq(&val));
let unconstrained = (Arbitrary::<i32>::default(), VecOf::new(Arbitrary::<u8>::default()));
let invalid_bytes = unconstrained.serialize_corpus(&(5i32, vec![2u8])).unwrap();
expect_that!(domain.parse_corpus(&invalid_bytes), err(anything()));
}
#[gtest]
fn test_tuple_of_nested() {
let mut domain = (
(InRange::new(1i32, 5), Arbitrary::<bool>::default()),
VecOf::new(InRange::new(10u8, 20)).with_len(2),
);
let mut rng = get_rng();
let mut val = domain.init(&mut rng).unwrap();
expect_that!(domain.validate_corpus_value(&val), ok(anything()));
for _ in 0..50 {
domain.mutate(&mut val, &mut rng, false).unwrap();
expect_that!(domain.validate_corpus_value(&val), ok(anything()));
}
let bytes = domain.serialize_corpus(&val).unwrap();
let parsed = domain.parse_corpus(&bytes).unwrap();
expect_that!(parsed, eq(&val));
}
#[gtest]
fn test_tuple_of_arities_up_to_12() {
let mut rng = get_rng();
let mut d0 = ();
let mut v0 = d0.init(&mut rng).unwrap();
d0.mutate(&mut v0, &mut rng, false).unwrap();
expect_that!(d0.validate_corpus_value(&v0), ok(anything()));
expect_that!(d0.corpus_to_user_value(&v0), ok(eq(&())));
let bytes0 = d0.serialize_corpus(&v0).unwrap();
expect_that!(d0.parse_corpus(&bytes0), ok(eq(&())));
macro_rules! check_tuple_arity {
($( $idx:tt ),+ $(,)?) => {{
let mut domain = ( $( { let _ = $idx; InRange::new(1u8, 5) }, )+ );
let mut val = domain.init(&mut rng).unwrap();
for _ in 0..10 {
domain.mutate(&mut val, &mut rng, false).unwrap();
expect_that!(domain.validate_corpus_value(&val), ok(anything()));
}
expect_that!(domain.corpus_to_user_value(&val), ok(eq(&val)));
let bytes = domain.serialize_corpus(&val).unwrap();
expect_that!(domain.parse_corpus(&bytes), ok(eq(&val)));
$(
let mut invalid = val;
invalid.$idx = 99;
let err = domain.validate_corpus_value(&invalid).unwrap_err();
expect_that!(
format!("{err:#}"),
contains_substring(format!("Invalid value in tuple element {}", $idx))
);
)+
}};
}
check_tuple_arity!(0);
check_tuple_arity!(0, 1);
check_tuple_arity!(0, 1, 2);
check_tuple_arity!(0, 1, 2, 3);
check_tuple_arity!(0, 1, 2, 3, 4);
check_tuple_arity!(0, 1, 2, 3, 4, 5);
check_tuple_arity!(0, 1, 2, 3, 4, 5, 6);
check_tuple_arity!(0, 1, 2, 3, 4, 5, 6, 7);
check_tuple_arity!(0, 1, 2, 3, 4, 5, 6, 7, 8);
check_tuple_arity!(0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
check_tuple_arity!(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
check_tuple_arity!(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11);
}
#[gtest]
fn test_tuple_of_reversible_domain_and_seeding() {
let mut rng = get_rng();
let unit_domain = ();
expect_that!(unit_domain.into_corpus_value(()), ok(eq(&())));
expect_that!(unit_domain.into_corpus_value(&()), ok(eq(&())));
let base_domain = (InRange::new(10u8, 20), InRange::new(30u8, 40));
expect_that!(base_domain.into_corpus_value((12u8, 34u8)), ok(eq(&(12u8, 34u8))));
expect_that!(base_domain.into_corpus_value(&(15u8, 38u8)), ok(eq(&(15u8, 38u8))));
expect_that!(base_domain.into_corpus_value((5u8, 34u8)), err(anything()));
expect_that!(base_domain.into_corpus_value((12u8, 99u8)), err(anything()));
let mut seeded = base_domain
.with_seeds([(11u8, 31u8)])
.with_seeds(&[(19u8, 39u8)])
.with_seed_provider(|| vec![(15u8, 35u8)]);
let mut observed = HashSet::new();
for _ in 0..iterations_to_hit_all(3, 0.5 / 3.0) {
observed.insert(seeded.init(&mut rng).unwrap());
}
expect_that!(observed, contains(eq(&(11u8, 31u8))));
expect_that!(observed, contains(eq(&(19u8, 39u8))));
expect_that!(observed, contains(eq(&(15u8, 35u8))));
}
}