fn avro_3631_deserialize_value_to_struct_with_byte_types()

in avro/src/bytes.rs [362:485]

• 119 lines of code
• 1 McCabe index (conditional complexity)

    fn avro_3631_deserialize_value_to_struct_with_byte_types() {
        #[derive(Debug, Deserialize, PartialEq)]
        struct TestStructWithBytes<'a> {
            #[serde(with = "serde_avro_bytes")]
            vec_field: Vec<u8>,
            #[serde(with = "serde_avro_bytes_opt")]
            vec_field_opt: Option<Vec<u8>>,
            #[serde(with = "serde_avro_bytes_opt")]
            vec_field_opt2: Option<Vec<u8>>,

            #[serde(with = "serde_avro_fixed")]
            fixed_field: [u8; 6],
            #[serde(with = "serde_avro_fixed_opt")]
            fixed_field_opt: Option<[u8; 7]>,
            #[serde(with = "serde_avro_fixed_opt")]
            fixed_field_opt2: Option<[u8; 8]>,

            #[serde(with = "serde_avro_slice")]
            slice_bytes_field: &'a [u8],
            #[serde(with = "serde_avro_slice_opt")]
            slice_bytes_field_opt: Option<&'a [u8]>,
            #[serde(with = "serde_avro_slice_opt")]
            slice_bytes_field_opt2: Option<&'a [u8]>,

            #[serde(with = "serde_avro_slice")]
            slice_fixed_field: &'a [u8],
            #[serde(with = "serde_avro_slice_opt")]
            slice_fixed_field_opt: Option<&'a [u8]>,
            #[serde(with = "serde_avro_slice_opt")]
            slice_fixed_field_opt2: Option<&'a [u8]>,
        }

        let expected = TestStructWithBytes {
            vec_field: vec![3, 33],
            vec_field_opt: Some(vec![4, 44]),
            vec_field_opt2: None,
            fixed_field: [1; 6],
            fixed_field_opt: Some([7; 7]),
            fixed_field_opt2: None,
            slice_bytes_field: &[1, 11, 111],
            slice_bytes_field_opt: Some(&[5, 5, 5, 5, 5]),
            slice_bytes_field_opt2: None,
            slice_fixed_field: &[2, 22, 222],
            slice_fixed_field_opt: Some(&[3, 3, 3]),
            slice_fixed_field_opt2: None,
        };

        let value = Value::Record(vec![
            (
                "vec_field".to_owned(),
                Value::Bytes(expected.vec_field.clone()),
            ),
            (
                "vec_field_opt".to_owned(),
                Value::Union(
                    1,
                    Box::new(Value::Bytes(
                        expected.vec_field_opt.as_ref().unwrap().clone(),
                    )),
                ),
            ),
            (
                "vec_field_opt2".to_owned(),
                Value::Union(0, Box::new(Value::Null)),
            ),
            (
                "fixed_field".to_owned(),
                Value::Fixed(expected.fixed_field.len(), expected.fixed_field.to_vec()),
            ),
            (
                "fixed_field_opt".to_owned(),
                Value::Union(
                    1,
                    Box::new(Value::Fixed(
                        expected.fixed_field_opt.as_ref().unwrap().len(),
                        expected.fixed_field_opt.as_ref().unwrap().to_vec(),
                    )),
                ),
            ),
            (
                "fixed_field_opt2".to_owned(),
                Value::Union(0, Box::new(Value::Null)),
            ),
            (
                "slice_bytes_field".to_owned(),
                Value::Bytes(expected.slice_bytes_field.to_vec()),
            ),
            (
                "slice_bytes_field_opt".to_owned(),
                Value::Union(
                    1,
                    Box::new(Value::Bytes(
                        expected.slice_bytes_field_opt.as_ref().unwrap().to_vec(),
                    )),
                ),
            ),
            (
                "slice_bytes_field_opt2".to_owned(),
                Value::Union(0, Box::new(Value::Null)),
            ),
            (
                "slice_fixed_field".to_owned(),
                Value::Fixed(
                    expected.slice_fixed_field.len(),
                    expected.slice_fixed_field.to_vec(),
                ),
            ),
            (
                "slice_fixed_field_opt".to_owned(),
                Value::Union(
                    1,
                    Box::new(Value::Fixed(
                        expected.slice_fixed_field_opt.as_ref().unwrap().len(),
                        expected.slice_fixed_field_opt.as_ref().unwrap().to_vec(),
                    )),
                ),
            ),
            (
                "slice_fixed_field_opt2".to_owned(),
                Value::Union(1, Box::new(Value::Null)),
            ),
        ]);
        assert_eq!(expected, from_value(&value).unwrap());
    }