epserde 0.13.1

ε-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

/*
 * SPDX-FileCopyrightText: 2026 Sebastiano Vigna
 *
 * SPDX-License-Identifier: Apache-2.0 OR MIT
 */

//! Tests for SerIter, which serializes exact-size iterators as vectors.

use epserde::impls::iter::SerIter;
use epserde::prelude::*;
use epserde::ser;

#[test]
fn test_ser_iter_zero_copy() -> anyhow::Result<()> {
    let data = [1_i32, 2, 3];
    let iter = SerIter::<i32, _>::new(data.iter());
    let mut cursor = <AlignedCursor<Aligned16>>::new();
    unsafe { iter.serialize(&mut cursor)? };

    cursor.set_position(0);
    let full = unsafe { <Vec<i32>>::deserialize_full(&mut cursor)? };
    assert_eq!(full, vec![1, 2, 3]);

    let eps = unsafe { <Vec<i32>>::deserialize_eps(cursor.as_bytes())? };
    assert_eq!(eps, &[1, 2, 3]);
    Ok(())
}

#[test]
fn test_ser_iter_deep_copy() -> anyhow::Result<()> {
    let data = vec!["a".to_string(), "b".to_string(), "longer".to_string()];
    let iter = SerIter::<String, _>::new(data.iter());
    let mut cursor = <AlignedCursor<Aligned16>>::new();
    unsafe { iter.serialize(&mut cursor)? };

    cursor.set_position(0);
    let full = unsafe { <Vec<String>>::deserialize_full(&mut cursor)? };
    assert_eq!(full, data);

    let eps = unsafe { <Vec<String>>::deserialize_eps(cursor.as_bytes())? };
    assert_eq!(eps, vec!["a", "b", "longer"]);
    Ok(())
}

/// An exact-size iterator whose reported length is off by a given delta.
struct LyingLen<I: ExactSizeIterator> {
    inner: I,
    delta: isize,
}

impl<I: ExactSizeIterator> Iterator for LyingLen<I> {
    type Item = I::Item;

    fn next(&mut self) -> Option<Self::Item> {
        self.inner.next()
    }

    // The lie must be consistent between len and size_hint, as
    // ExactSizeIterator requires.
    fn size_hint(&self) -> (usize, Option<usize>) {
        let len = self.inner.len().checked_add_signed(self.delta).unwrap_or(0);
        (len, Some(len))
    }
}

impl<I: ExactSizeIterator> ExactSizeIterator for LyingLen<I> {
    fn len(&self) -> usize {
        self.inner.len().checked_add_signed(self.delta).unwrap_or(0)
    }
}

#[test]
fn test_ser_iter_len_over_reported() -> anyhow::Result<()> {
    let data = [1_i32, 2, 3];
    let iter = SerIter::<i32, _>::new(LyingLen {
        inner: data.iter(),
        delta: 1,
    });
    let mut cursor = <AlignedCursor<Aligned16>>::new();
    let err = match unsafe { iter.serialize(&mut cursor) } {
        Ok(_) => anyhow::bail!("serialization should have failed"),
        Err(err) => err,
    };
    match err {
        ser::Error::IteratorLengthMismatch { actual, expected } => {
            // The iterator returned three items but declared four.
            assert_eq!(actual, 3);
            assert_eq!(expected, 4);
        }
        err => anyhow::bail!("wrong error type: {:?}", err),
    }
    Ok(())
}

#[test]
fn test_ser_iter_len_under_reported() -> anyhow::Result<()> {
    let data = [1_i32, 2, 3];
    let iter = SerIter::<i32, _>::new(LyingLen {
        inner: data.iter(),
        delta: -1,
    });
    let mut cursor = <AlignedCursor<Aligned16>>::new();
    let err = match unsafe { iter.serialize(&mut cursor) } {
        Ok(_) => anyhow::bail!("serialization should have failed"),
        Err(err) => err,
    };
    match err {
        ser::Error::IteratorLengthMismatch { actual, expected } => {
            // The iterator declared two items; the reported actual count is a
            // lower bound, as serialization stops writing at the declared
            // length.
            assert_eq!(actual, 3);
            assert_eq!(expected, 2);
        }
        err => anyhow::bail!("wrong error type: {:?}", err),
    }
    Ok(())
}

#[test]
fn test_ser_iter_serialized_twice() -> anyhow::Result<()> {
    let data = [1_i32, 2, 3];
    let iter = SerIter::<i32, _>::new(data.iter());
    let mut cursor = <AlignedCursor<Aligned16>>::new();
    unsafe { iter.serialize(&mut cursor)? };

    // Serialization consumes the wrapped iterator: a second serialization
    // must produce a valid, empty sequence.
    let mut cursor = <AlignedCursor<Aligned16>>::new();
    unsafe { iter.serialize(&mut cursor)? };
    cursor.set_position(0);
    let full = unsafe { <Vec<i32>>::deserialize_full(&mut cursor)? };
    assert_eq!(full, Vec::<i32>::new());
    Ok(())
}