mavryk_data_encoding 0.6.0

Utilities for encoding/decoding data compatible with mavryk data encoding.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

use crate::types::SizedBytes;

use fuzzcheck::mutators::{
    fixed_len_vector::FixedLenVecMutator, integer::U8Mutator, map::MapMutator,
};
use fuzzcheck::MutatorWrapper;

type SizedBytesMutatorInner<const SIZE: usize> = MapMutator<
    Vec<u8>,
    SizedBytes<SIZE>,
    FixedLenVecMutator<u8, U8Mutator>,
    fn(&SizedBytes<SIZE>) -> Option<Vec<u8>>,
    fn(&Vec<u8>) -> SizedBytes<SIZE>,
    fn(&SizedBytes<SIZE>, f64) -> f64,
>;
pub struct SizedBytesMutator<const SIZE: usize>(SizedBytesMutatorInner<SIZE>);

#[no_coverage]
fn vec_from_sizedbytes<const SIZE: usize>(sb: &SizedBytes<SIZE>) -> Option<Vec<u8>> {
    Some(sb.0.to_vec())
}

#[no_coverage]
fn sizedbytes_from_vec<const SIZE: usize>(v: &Vec<u8>) -> SizedBytes<SIZE> {
    let bytes: [u8; SIZE] = v[0..SIZE].try_into().unwrap();
    SizedBytes::<SIZE>::from(bytes)
}

#[no_coverage]
fn complexity<const SIZE: usize>(_t: &SizedBytes<SIZE>, cplx: f64) -> f64 {
    cplx
}

impl<const SIZE: usize> SizedBytesMutator<SIZE> {
    #[no_coverage]
    pub fn new() -> Self {
        Self {
            0: MapMutator::new(
                FixedLenVecMutator::<u8, U8Mutator>::new_with_repeated_mutator(
                    U8Mutator::default(),
                    SIZE,
                ),
                vec_from_sizedbytes,
                sizedbytes_from_vec,
                complexity,
            ),
        }
    }
}

impl<const SIZE: usize> MutatorWrapper for SizedBytesMutator<SIZE> {
    type Wrapped = SizedBytesMutatorInner<SIZE>;

    fn wrapped_mutator(&self) -> &Self::Wrapped {
        &self.0
    }
}

impl<const SIZE: usize> Default for SizedBytesMutator<SIZE> {
    #[no_coverage]
    fn default() -> Self {
        SizedBytesMutator::<SIZE>::new()
    }
}