eeprom24x 0.7.2

Platform-agnostic Rust driver for the 24x series serial EEPROMs.
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

use eeprom24x::{Eeprom24x, Error, Storage};
use embedded_hal_mock::eh1::{
    delay::NoopDelay,
    i2c::{Mock as I2cMock, Transaction as I2cTrans},
};
use embedded_storage::{ReadStorage, Storage as _};
mod common;
use crate::common::{
    destroy, new_24csx01, new_24csx02, new_24csx04, new_24csx08, new_24csx16, new_24csx32,
    new_24csx64, new_24x00, new_24x01, new_24x02, new_24x04, new_24x08, new_24x128, new_24x16,
    new_24x256, new_24x32, new_24x512, new_24x64, new_24xm01, new_24xm02, new_m24x01, new_m24x02,
    DEV_ADDR,
};

fn storage_new<PS, AS, SN>(
    eeprom: Eeprom24x<I2cMock, PS, AS, SN>,
) -> Storage<I2cMock, PS, AS, SN, NoopDelay> {
    Storage::new(eeprom, NoopDelay)
}

macro_rules! can_query_capacity {
    ($name:ident, $create:ident, $capacity:expr) => {
        #[test]
        fn $name() {
            let storage = storage_new($create(&[]));
            let capacity = storage.capacity();
            assert_eq!(capacity, $capacity);
            destroy(storage.eeprom);
        }
    };
}
for_all_ics_with_capacity!(can_query_capacity);

macro_rules! can_read_byte_1byte_addr {
    ($name:ident, $create:ident) => {
        #[test]
        fn $name() {
            let trans = [I2cTrans::write_read(DEV_ADDR, vec![0xF], vec![0xAB])];
            let mut storage = storage_new($create(&trans));
            let mut data = [0u8; 1];
            storage.read(0xF, &mut data).unwrap();
            assert_eq!(0xAB, data[0]);
            destroy(storage.eeprom);
        }
    };
}
for_all_ics_with_1b_addr!(can_read_byte_1byte_addr);

macro_rules! can_read_byte_2byte_addr {
    ($name:ident, $create:ident) => {
        #[test]
        fn $name() {
            let trans = [I2cTrans::write_read(DEV_ADDR, vec![0xF, 0x34], vec![0xAB])];
            let mut storage = storage_new($create(&trans));
            let mut data = [0u8; 1];
            storage.read(0xF34, &mut data).unwrap();
            assert_eq!(0xAB, data[0]);
            destroy(storage.eeprom);
        }
    };
}
for_all_ics_with_2b_addr!(can_read_byte_2byte_addr);

macro_rules! can_write_array_1byte_addr {
    ($name:ident, $create:ident, $_page_size:expr) => {
        #[test]
        fn $name() {
            let trans = [I2cTrans::write(DEV_ADDR, vec![0x34, 0xAB, 0xCD, 0xEF])];
            let mut storage = storage_new($create(&trans));
            storage.write(0x34, &[0xAB, 0xCD, 0xEF]).unwrap();
            destroy(storage.eeprom);
        }
    };
}
for_all_ics_with_1b_addr_and_page_size!(can_write_array_1byte_addr);

macro_rules! can_write_array_2byte_addr {
    ($name:ident, $create:ident, $_page_size:expr) => {
        #[test]
        fn $name() {
            let trans = [I2cTrans::write(DEV_ADDR, vec![0xF, 0x34, 0xAB, 0xCD, 0xEF])];
            let mut storage = storage_new($create(&trans));
            storage.write(0xF34, &[0xAB, 0xCD, 0xEF]).unwrap();
            destroy(storage.eeprom);
        }
    };
}
for_all_ics_with_2b_addr_and_page_size!(can_write_array_2byte_addr);

macro_rules! cannot_write_too_much_data {
    ($name:ident, $create:ident, $capacity:expr) => {
        #[test]
        fn $name() {
            let mut storage = storage_new($create(&[]));
            match storage.write(0x34, &[0xAB; 1 + $capacity]) {
                Err(Error::TooMuchData) => (),
                _ => panic!("Error::TooMuchData not returned."),
            }
            destroy(storage.eeprom);
        }
    };
}
for_all_writestorage_ics_with_capacity!(cannot_write_too_much_data);