Function extend_input_by

hail-fuzz/src/mutations.rs:71–118

(
    rng: &mut R,
    dict: DictionaryRef,
    bytes: &mut Vec<u8>,
    amount: usize,
)

];

pub(crate) fn extend_input_by<R: Rng>(
    rng: &mut R,
    dict: DictionaryRef,
    bytes: &mut Vec<u8>,
    amount: usize,
) -> Extension {
    let new_len = bytes.len() + amount;
    let kind = *ALL_EXTENSIONS.choose(rng).unwrap();
    match kind {
        Extension::Interesting => {
            let value = INTERESTING_VALUES.choose(rng).unwrap();
            while bytes.len() < new_len {
                bytes.extend_from_slice(value);
            }
        }
        Extension::Prev if bytes.len() > 2 => {
            while bytes.len() < new_len {
                bytes.extend_from_within(rand_range(rng, 0, bytes.len(), amount));
            }
        }
        Extension::PrevRepeat if bytes.len() > 2 => {
            let range = rand_range(rng, 0, bytes.len(), amount);
            while bytes.len() < new_len {
                bytes.extend_from_within(range.clone());
            }
        }
        Extension::Dict => {
            while bytes.len() < new_len {
                let (value, strides) = dict.choose(rng);
                let stride = random_stride(rng, strides);
                bytes.extend(value.iter().flat_map(|x| std::iter::repeat(x).take(stride)));
            }
        }
        Extension::DictRepeat => {
            let (value, strides) = dict.choose(rng);
            let stride = random_stride(rng, strides);
            while bytes.len() < new_len {
                bytes.extend(value.iter().flat_map(|x| std::iter::repeat(x).take(stride)));
            }
        }
        Extension::Random | _ => {
            for _ in 0..amount {
                bytes.push(rng.gen());
            }
        }
    }
    kind
}

#[derive(Copy, Clone, Debug, serde::Serialize, serde::Deserialize)]
pub enum Mutation {