Function apply_mutation

hail-fuzz/src/mutations.rs:179–296

(
    mutation: Mutation,
    rng: &mut R,
    dict: DictionaryRef,
    input: &mut Vec<u8>,
    key: StreamKey,
    corpus: &S,
    offset: usize,
)

}

pub(crate) fn apply_mutation<R, S>(
    mutation: Mutation,
    rng: &mut R,
    dict: DictionaryRef,
    input: &mut Vec<u8>,
    key: StreamKey,
    corpus: &S,
    offset: usize,
) where
    R: Rng,
    S: InputSource,
{
    let len = input.len();
    match mutation {
        Mutation::BitFlip => {
            let bit_offset: usize = rng.gen_range(offset * 8..len * 8);
            let mask = 1 << (bit_offset % 8);
            input[bit_offset / 8] ^= input[bit_offset / 8] & mask;
        }
        Mutation::IncDec => {
            let offset: usize = rng.gen_range(offset..len);
            input[offset] = match rng.gen_bool(0.5) {
                true => input[offset].wrapping_add(1),
                false => input[offset].wrapping_sub(1),
            };
        }

        Mutation::ReplaceByte => {
            let offset: usize = rng.gen_range(offset..len);
            input[offset] = rng.gen();
        }
        Mutation::InsertByte => {
            let offset: usize = rng.gen_range(offset..len + 1);
            input.insert(offset, rng.gen())
        }
        Mutation::Insert4 => {
            let offset: usize = rng.gen_range(offset..len + 1);
            insert_slice(input, &rng.gen::<[u8; 4]>(), offset);
        }

        Mutation::InterestingValue => {
            let offset: usize = rng.gen_range(offset..len);
            let x = INTERESTING_VALUES.choose(rng).unwrap();
            let stride = random_stride(rng, 1 | 2 | 4);
            replace_slice_strided(input, x, offset, stride);
        }
        Mutation::DictReplace => {
            let (x, strides) = dict.choose(rng);
            let x = if rng.gen() { x } else { random_subslice(rng, x) };

            let stride = random_stride(rng, strides);
            replace_slice_strided(input, x, offset, stride);
        }
        Mutation::DictInsert => {
            let (x, strides) = dict.choose(rng);
            let x = if rng.gen() { x } else { random_subslice(rng, x) };
            let stride = random_stride(rng, strides);
            insert_slice_strided(input, x, offset, stride);