esp-nvs 0.1.3

ESP-IDF compatible, bare metal, non-volatile storage (NVS) library
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

use crate::common::Operation::{Read, Write};
use crate::common::{
    ENTRY_STATE_MAP_OFFSET, FLASH_SECTOR_SIZE, ITEM_OFFSET, ITEM_SIZE, PAGE_HEADER_SIZE, WORD_SIZE,
};
use esp_nvs::Key;

mod common;

#[test]
fn single_primitve() {
    let mut flash = common::Flash::new(2);

    let mut nvs = esp_nvs::Nvs::new(0, flash.len(), &mut flash).unwrap();
    nvs.set(&Key::from_str("ns1"), &Key::from_str("value"), 0xAAu8)
        .unwrap();

    let ops_init = vec![
        Read {
            offset: 0,
            len: FLASH_SECTOR_SIZE,
        },
        Read {
            offset: FLASH_SECTOR_SIZE as _,
            len: FLASH_SECTOR_SIZE,
        },
    ];

    let ops_write = vec![
        Write {
            offset: 0,
            len: PAGE_HEADER_SIZE,
        },
        Write {
            offset: ITEM_OFFSET as _,
            len: ITEM_SIZE,
        },
        Write {
            offset: ENTRY_STATE_MAP_OFFSET as _,
            len: WORD_SIZE,
        },
        Write {
            offset: (ITEM_OFFSET + 1 * ITEM_SIZE) as _,
            len: ITEM_SIZE,
        },
        Write {
            offset: ENTRY_STATE_MAP_OFFSET as _,
            len: WORD_SIZE,
        },
    ];

    let mut ops = ops_init.clone();
    ops.extend(ops_write);

    assert_eq!(flash.operations, ops);
    flash.operations.clear();

    let mut nvs = esp_nvs::Nvs::new(0, flash.len(), &mut flash).unwrap();
    assert_eq!(
        nvs.get::<u8>(&Key::from_str("ns1"), &Key::from_str("value"))
            .unwrap(),
        0xAA
    );

    // namespace is already cached, so only reading the actual value is required
    let ops_read = vec![Read {
        offset: (ITEM_OFFSET + 1 * ITEM_SIZE) as _,
        len: ITEM_SIZE,
    }];
    let mut ops = ops_init.clone();
    ops.extend(ops_read);

    assert_eq!(flash.operations, ops);
}