littlefs/tests/test_bd.toml

# These tests don't really test littlefs at all, they are here only to make
# sure the underlying block device is working.
#
# Note we use 251, a prime, in places to avoid aliasing powers of 2.
# 

[cases.test_bd_one_block]
defines.READ = ['READ_SIZE', 'BLOCK_SIZE']
defines.PROG = ['PROG_SIZE', 'BLOCK_SIZE']
code = '''
    uint8_t buffer[lfs_max(READ, PROG)];

    // write data
    cfg->erase(cfg, 0) => 0;
    for (lfs_off_t i = 0; i < cfg->block_size; i += PROG) {
        for (lfs_off_t j = 0; j < PROG; j++) {
            buffer[j] = (i+j) % 251;
        }
        cfg->prog(cfg, 0, i, buffer, PROG) => 0;
    }

    // read data
    for (lfs_off_t i = 0; i < cfg->block_size; i += READ) {
        cfg->read(cfg, 0, i, buffer, READ) => 0;

        for (lfs_off_t j = 0; j < READ; j++) {
            LFS_ASSERT(buffer[j] == (i+j) % 251);
        }
    }
'''

[cases.test_bd_two_block]
defines.READ = ['READ_SIZE', 'BLOCK_SIZE']
defines.PROG = ['PROG_SIZE', 'BLOCK_SIZE']
code = '''
    uint8_t buffer[lfs_max(READ, PROG)];
    lfs_block_t block;

    // write block 0
    block = 0;
    cfg->erase(cfg, block) => 0;
    for (lfs_off_t i = 0; i < cfg->block_size; i += PROG) {
        for (lfs_off_t j = 0; j < PROG; j++) {
            buffer[j] = (block+i+j) % 251;
        }
        cfg->prog(cfg, block, i, buffer, PROG) => 0;
    }

    // read block 0
    block = 0;
    for (lfs_off_t i = 0; i < cfg->block_size; i += READ) {
        cfg->read(cfg, block, i, buffer, READ) => 0;

        for (lfs_off_t j = 0; j < READ; j++) {
            LFS_ASSERT(buffer[j] == (block+i+j) % 251);
        }
    }

    // write block 1
    block = 1;
    cfg->erase(cfg, block) => 0;
    for (lfs_off_t i = 0; i < cfg->block_size; i += PROG) {
        for (lfs_off_t j = 0; j < PROG; j++) {
            buffer[j] = (block+i+j) % 251;
        }
        cfg->prog(cfg, block, i, buffer, PROG) => 0;
    }

    // read block 1
    block = 1;
    for (lfs_off_t i = 0; i < cfg->block_size; i += READ) {
        cfg->read(cfg, block, i, buffer, READ) => 0;

        for (lfs_off_t j = 0; j < READ; j++) {
            LFS_ASSERT(buffer[j] == (block+i+j) % 251);
        }
    }

    // read block 0 again
    block = 0;
    for (lfs_off_t i = 0; i < cfg->block_size; i += READ) {
        cfg->read(cfg, block, i, buffer, READ) => 0;

        for (lfs_off_t j = 0; j < READ; j++) {
            LFS_ASSERT(buffer[j] == (block+i+j) % 251);
        }
    }
'''

[cases.test_bd_last_block]
defines.READ = ['READ_SIZE', 'BLOCK_SIZE']
defines.PROG = ['PROG_SIZE', 'BLOCK_SIZE']
code = '''
    uint8_t buffer[lfs_max(READ, PROG)];
    lfs_block_t block;

    // write block 0
    block = 0;
    cfg->erase(cfg, block) => 0;
    for (lfs_off_t i = 0; i < cfg->block_size; i += PROG) {
        for (lfs_off_t j = 0; j < PROG; j++) {
            buffer[j] = (block+i+j) % 251;
        }
        cfg->prog(cfg, block, i, buffer, PROG) => 0;
    }

    // read block 0
    block = 0;
    for (lfs_off_t i = 0; i < cfg->block_size; i += READ) {
        cfg->read(cfg, block, i, buffer, READ) => 0;

        for (lfs_off_t j = 0; j < READ; j++) {
            LFS_ASSERT(buffer[j] == (block+i+j) % 251);
        }
    }

    // write block n-1
    block = cfg->block_count-1;
    cfg->erase(cfg, block) => 0;
    for (lfs_off_t i = 0; i < cfg->block_size; i += PROG) {
        for (lfs_off_t j = 0; j < PROG; j++) {
            buffer[j] = (block+i+j) % 251;
        }
        cfg->prog(cfg, block, i, buffer, PROG) => 0;
    }

    // read block n-1
    block = cfg->block_count-1;
    for (lfs_off_t i = 0; i < cfg->block_size; i += READ) {
        cfg->read(cfg, block, i, buffer, READ) => 0;

        for (lfs_off_t j = 0; j < READ; j++) {
            LFS_ASSERT(buffer[j] == (block+i+j) % 251);
        }
    }

    // read block 0 again
    block = 0;
    for (lfs_off_t i = 0; i < cfg->block_size; i += READ) {
        cfg->read(cfg, block, i, buffer, READ) => 0;

        for (lfs_off_t j = 0; j < READ; j++) {
            LFS_ASSERT(buffer[j] == (block+i+j) % 251);
        }
    }
'''

[cases.test_bd_powers_of_two]
defines.READ = ['READ_SIZE', 'BLOCK_SIZE']
defines.PROG = ['PROG_SIZE', 'BLOCK_SIZE']
code = '''
    uint8_t buffer[lfs_max(READ, PROG)];

    // write/read every power of 2
    lfs_block_t block = 1;
    while (block < cfg->block_count) {
        // write
        cfg->erase(cfg, block) => 0;
        for (lfs_off_t i = 0; i < cfg->block_size; i += PROG) {
            for (lfs_off_t j = 0; j < PROG; j++) {
                buffer[j] = (block+i+j) % 251;
            }
            cfg->prog(cfg, block, i, buffer, PROG) => 0;
        }

        // read
        for (lfs_off_t i = 0; i < cfg->block_size; i += READ) {
            cfg->read(cfg, block, i, buffer, READ) => 0;

            for (lfs_off_t j = 0; j < READ; j++) {
                LFS_ASSERT(buffer[j] == (block+i+j) % 251);
            }
        }

        block *= 2;
    }

    // read every power of 2 again
    block = 1;
    while (block < cfg->block_count) {
        // read
        for (lfs_off_t i = 0; i < cfg->block_size; i += READ) {
            cfg->read(cfg, block, i, buffer, READ) => 0;

            for (lfs_off_t j = 0; j < READ; j++) {
                LFS_ASSERT(buffer[j] == (block+i+j) % 251);
            }
        }

        block *= 2;
    }
'''

[cases.test_bd_fibonacci]
defines.READ = ['READ_SIZE', 'BLOCK_SIZE']
defines.PROG = ['PROG_SIZE', 'BLOCK_SIZE']
code = '''
    uint8_t buffer[lfs_max(READ, PROG)];

    // write/read every fibonacci number on our device
    lfs_block_t block = 1;
    lfs_block_t block_ = 1;
    while (block < cfg->block_count) {
        // write
        cfg->erase(cfg, block) => 0;
        for (lfs_off_t i = 0; i < cfg->block_size; i += PROG) {
            for (lfs_off_t j = 0; j < PROG; j++) {
                buffer[j] = (block+i+j) % 251;
            }
            cfg->prog(cfg, block, i, buffer, PROG) => 0;
        }

        // read
        for (lfs_off_t i = 0; i < cfg->block_size; i += READ) {
            cfg->read(cfg, block, i, buffer, READ) => 0;

            for (lfs_off_t j = 0; j < READ; j++) {
                LFS_ASSERT(buffer[j] == (block+i+j) % 251);
            }
        }

        lfs_block_t nblock = block + block_;
        block_ = block;
        block = nblock;
    }

    // read every fibonacci number again
    block = 1;
    block_ = 1;
    while (block < cfg->block_count) {
        // read
        for (lfs_off_t i = 0; i < cfg->block_size; i += READ) {
            cfg->read(cfg, block, i, buffer, READ) => 0;

            for (lfs_off_t j = 0; j < READ; j++) {
                LFS_ASSERT(buffer[j] == (block+i+j) % 251);
            }
        }

        lfs_block_t nblock = block + block_;
        block_ = block;
        block = nblock;
    }
'''