epserde 0.13.0

ε-serde is an ε-copy (i.e., almost zero-copy) serialization/deserialization framework
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
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

/*
 * SPDX-FileCopyrightText: 2023 Inria
 *
 * SPDX-License-Identifier: Apache-2.0 OR LGPL-2.1-or-later
 */

use anyhow::Result;
use epserde::prelude::*;
use epserde::ser;

#[derive(Epserde, Debug, PartialEq, Eq, Clone)]
struct Data<A: PartialEq = usize, const Q: usize = 3> {
    a: A,
    b: [i32; Q],
}

#[test]
fn test_slices() -> Result<()> {
    let a = vec![1, 2, 3, 4];
    let s = a.as_slice();
    let mut cursor = <AlignedCursor<Aligned16>>::new();
    unsafe { s.serialize(&mut cursor)? };
    cursor.set_position(0);
    let b = unsafe { <Vec<i32>>::deserialize_full(&mut cursor)? };
    assert_eq!(a, b.as_slice());
    let b = unsafe { <Vec<i32>>::deserialize_eps(cursor.as_bytes())? };
    assert_eq!(a, b);

    cursor.set_position(0);
    let d = Data {
        a: vec![0, 1, 2, 3].into_boxed_slice(),
        b: [1, 2, 3],
    };
    unsafe { d.serialize(&mut cursor)? };
    cursor.set_position(0);
    let e = unsafe { Data::<Box<[i32]>>::deserialize_full(&mut cursor)? };
    assert_eq!(e, d);

    cursor.set_position(0);
    let v = vec![0, 1, 2, 3];
    let d = Data {
        a: v.as_slice(),
        b: [1, 2, 3],
    };
    unsafe { d.serialize(&mut cursor)? };
    cursor.set_position(0);
    let e = unsafe { Data::<Box<[i32]>>::deserialize_full(&mut cursor)? };
    assert_eq!(&*e.a, d.a);

    cursor.set_position(0);
    let d = Data { a: s, b: [1, 2, 3] };
    unsafe { d.serialize(&mut cursor)? };
    cursor.set_position(0);
    let e = unsafe { Data::<Vec<i32>>::deserialize_eps(cursor.as_bytes())? };
    assert_eq!(e, d);

    Ok(())
}

#[test]
fn test_mut_slices() -> Result<()> {
    let mut a = vec![1, 2, 3, 4];
    let mut cursor = <AlignedCursor<Aligned16>>::new();
    {
        let s = a.as_mut_slice();
        unsafe { s.serialize(&mut cursor)? };
        cursor.set_position(0);
    }

    let b = unsafe { <Vec<i32>>::deserialize_full(&mut cursor)? };
    assert_eq!(a, b);
    let b = unsafe { <Vec<i32>>::deserialize_eps(cursor.as_bytes())? };
    assert_eq!(a, b);

    cursor.set_position(0);
    let d = Data {
        a: vec![0, 1, 2, 3].into_boxed_slice(),
        b: [1, 2, 3],
    };
    unsafe { d.serialize(&mut cursor)? };
    cursor.set_position(0);
    let e = unsafe { Data::<Box<[i32]>>::deserialize_full(&mut cursor)? };
    assert_eq!(e, d);

    cursor.set_position(0);
    let mut v = vec![0, 1, 2, 3];
    let d = Data {
        a: v.as_mut_slice(),
        b: [1, 2, 3],
    };
    unsafe { d.serialize(&mut cursor)? };
    cursor.set_position(0);
    let e = unsafe { Data::<Box<[i32]>>::deserialize_full(&mut cursor)? };
    assert_eq!(&*e.a, d.a);

    cursor.set_position(0);
    let d = Data {
        a: a.as_mut_slice(),
        b: [1, 2, 3],
    };
    unsafe { d.serialize(&mut cursor)? };
    cursor.set_position(0);
    let e = unsafe { Data::<Vec<i32>>::deserialize_eps(cursor.as_bytes())? };
    assert_eq!(e.a, d.a);
    assert_eq!(e.b, d.b);
    Ok(())
}

/// A writer that accepts exactly `budget` bytes and then errors.
struct BudgetWriter {
    budget: usize,
}

// WriteNoStd is implemented directly, rather than through std::io::Write and
// the std-only blanket implementation, so that this test also compiles
// without the std feature.
impl ser::WriteNoStd for BudgetWriter {
    fn write_all(&mut self, buf: &[u8]) -> ser::Result<()> {
        let n = buf.len().min(self.budget);
        self.budget -= n;
        if n < buf.len() {
            return Err(ser::Error::WriteError);
        }
        Ok(())
    }

    fn flush(&mut self) -> ser::Result<()> {
        Ok(())
    }
}

#[test]
fn test_slice_ser_error_no_free() -> Result<()> {
    // Serializing a borrowed slice must not free the borrowed memory when the
    // writer errors, at whatever point the error happens; sweeping the budget
    // makes the write fail at every possible position (checked under Miri).
    let a = vec![1, 2, 3, 4];
    let s = &a[1..];
    let mut succeeded = false;
    for budget in 0..10_000 {
        let mut w = BudgetWriter { budget };
        if unsafe { s.serialize(&mut w) }.is_ok() {
            succeeded = true;
            break;
        }
    }
    assert!(succeeded);
    assert_eq!(a, vec![1, 2, 3, 4]);
    Ok(())
}