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

#[allow(clippy::module_inception)]
#[cfg(test)]
mod tests {

    use crate::prelude::{load, store, Serializable, Serializer};
    use crate::result::IoResult;
    use borsh::{BorshDeserialize, BorshSerialize};

    #[derive(BorshSerialize, BorshDeserialize, Debug, PartialEq)]
    struct MyStruct {
        field1: u32,
        field2: String,
    }

    #[test]
    fn test_serializer_store_and_load() -> Result<(), Box<dyn std::error::Error>> {
        let value = MyStruct {
            field1: 42,
            field2: String::from("Hello, world!"),
        };

        // Serialize (store)
        let mut buffer = Vec::new();
        store!(MyStruct, &value, &mut buffer)?;

        // Deserialize (load)
        let deserialized_value: MyStruct = load!(MyStruct, &mut buffer.as_slice())?;

        // Assert the original and deserialized values are the same
        assert_eq!(value, deserialized_value);

        Ok(())
    }

    struct MyVersionedStruct {
        field1: u32,
        field2: String,
        field3: bool,
    }

    impl Serializer for MyVersionedStruct {
        fn serialize<W: std::io::Write>(&self, writer: &mut W) -> std::io::Result<()> {
            // Serialize the version
            store!(u32, &1, writer)?;
            // Serialize the fields
            store!(u32, &self.field1, writer)?;
            store!(String, &self.field2, writer)?;
            store!(bool, &self.field3, writer)?;

            Ok(())
        }

        fn deserialize<R: std::io::Read>(reader: &mut R) -> IoResult<Self> {
            // Deserialize the version
            let version: u32 = load!(u32, reader)?;
            // Deserialize the fields
            let field1: u32 = load!(u32, reader)?;
            let field2: String = load!(String, reader)?;
            let field3: bool = load!(bool, reader)?;

            assert_eq!(version, 1);

            Ok(Self {
                field1,
                field2,
                field3,
            })
        }
    }

    #[test]
    fn test_serializer_versioning() -> Result<(), Box<dyn std::error::Error>> {
        let value = MyVersionedStruct {
            field1: 42,
            field2: String::from("Hello, world!"),
            field3: true,
        };

        let serializable = Serializable(value);
        let mut buffer = Vec::new();
        borsh::BorshSerialize::serialize(&serializable, &mut buffer)?;

        let deserialized: Serializable<MyVersionedStruct> =
            borsh::BorshDeserialize::deserialize(&mut buffer.as_slice())?;
        let deserialized_value = deserialized.into_inner();

        // assert_eq!(version, 1);
        assert_eq!(deserialized_value.field1, 42);
        assert!(deserialized_value.field2 == "Hello, world!");
        assert!(deserialized_value.field3);

        Ok(())
    }
}