liteboxfs 0.1.0

use xpct::{be_ok, be_some, equal, expect, fields, have_len, match_elements, match_fields};

use crate::{
    block::{
        adapter::ChunkingBlockStoreAdapter,
        store::DataStore,
        store::{BlockStore, BlockStoreInput},
        types::{Block, FileId, FileOffset, HoleLen},
    },
    hash::BlockHasher,
    testing::{Case, MemoryBlockStore, random_buf, random_string},
};

use super::{BlockSignature, BlockStoreTestExt, DataBlock, TEST_BLOCK_SIZE};

#[test]
fn write_zero_bytes_is_noop() {
    let mut block_store = MemoryBlockStore::new();
    let file_id = FileId::from(1);

    let DataBlock {
        id: original_id,
        signature: original_sig,
        ..
    } = expect!(block_store.insert_data(file_id, 0))
        .to(be_ok())
        .into_inner();

    let mut data_store = ChunkingBlockStoreAdapter::without_chunking(block_store);

    let block_list = expect!(data_store.list_blocks(file_id))
        .to(be_ok())
        .into_inner();

    let write_data = b"";

    let block_list =
        expect!(data_store.write_block(file_id, 0, block_list, write_data.as_slice().into()))
            .to(be_ok())
            .into_inner()
            .into_iter()
            .collect::<Vec<_>>();

    expect!(&block_list).to(have_len(1));

    expect!(block_list.clone()).to(match_elements([match_fields(fields!(Block {
        id: equal(original_id),
        signature: equal(original_sig),
    }))]));

    let actual_block_list = expect!(data_store.list_blocks(file_id))
        .to(be_ok())
        .into_inner()
        .into_iter()
        .collect::<Vec<_>>();

    expect!(block_list).to(equal(actual_block_list));
}

#[test]
fn write_file_start_to_end() {
    let mut block_store = MemoryBlockStore::new();
    let file_id = FileId::from(1);

    expect!(block_store.insert_data(file_id, 0))
        .to(be_ok())
        .into_inner();
    expect!(block_store.insert_data(file_id, 1))
        .to(be_ok())
        .into_inner();

    let mut data_store = ChunkingBlockStoreAdapter::without_chunking(block_store);

    let write_len = TEST_BLOCK_SIZE * 2;
    let write_data = random_buf(write_len, Case::Upper);
    let write_hash = BlockHasher::hash(&write_data);

    let block_list = expect!(data_store.list_blocks(file_id))
        .to(be_ok())
        .into_inner();

    let block_list =
        expect!(data_store.write_block(file_id, 0, block_list, write_data.as_slice().into()))
            .to(be_ok())
            .into_inner()
            .into_iter()
            .collect::<Vec<_>>();

    expect!(&block_list).to(have_len(1));

    expect!(block_list.clone()).to(match_elements([match_fields(fields!(Block {
        signature: equal(BlockSignature::Data {
            hash: write_hash,
            len: write_data.len(),
        }),
    }))]));

    let actual_block_list = expect!(data_store.list_blocks(file_id))
        .to(be_ok())
        .into_inner()
        .into_iter()
        .collect::<Vec<_>>();

    expect!(block_list).to(equal(actual_block_list));
}

#[test]
fn write_file_start_to_block_boundary() {
    let mut block_store = MemoryBlockStore::new();
    let file_id = FileId::from(1);

    expect!(block_store.insert_data(file_id, 0))
        .to(be_ok())
        .into_inner();
    let DataBlock {
        bytes: second_bytes,
        hash: second_hash,
        ..
    } = expect!(block_store.insert_data(file_id, 1))
        .to(be_ok())
        .into_inner();

    let mut data_store = ChunkingBlockStoreAdapter::without_chunking(block_store);

    let write_data = random_buf(TEST_BLOCK_SIZE, Case::Upper);
    let write_hash = BlockHasher::hash(&write_data);

    let block_list = expect!(data_store.list_blocks(file_id))
        .to(be_ok())
        .into_inner();

    let block_list =
        expect!(data_store.write_block(file_id, 0, block_list, write_data.as_slice().into()))
            .to(be_ok())
            .into_inner()
            .into_iter()
            .collect::<Vec<_>>();

    expect!(&block_list).to(have_len(2));

    expect!(block_list.clone()).to(match_elements([
        match_fields(fields!(Block {
            signature: equal(BlockSignature::Data {
                hash: write_hash,
                len: write_data.len(),
            }),
        })),
        match_fields(fields!(Block {
            signature: equal(BlockSignature::Data {
                hash: second_hash,
                len: second_bytes.len(),
            }),
        })),
    ]));

    let actual_block_list = expect!(data_store.list_blocks(file_id))
        .to(be_ok())
        .into_inner()
        .into_iter()
        .collect::<Vec<_>>();

    expect!(block_list).to(equal(actual_block_list));
}

#[test]
fn write_file_start_to_mid_same_block() {
    let mut block_store = MemoryBlockStore::new();
    let file_id = FileId::from(1);

    let DataBlock { bytes, .. } = expect!(block_store.insert_data(file_id, 0))
        .to(be_ok())
        .into_inner();

    let mut data_store = ChunkingBlockStoreAdapter::without_chunking(block_store);

    let block_list = expect!(data_store.list_blocks(file_id))
        .to(be_ok())
        .into_inner();

    let new_bytes = b"XXX";

    let block_list =
        expect!(data_store.write_block(file_id, 0, block_list, new_bytes.as_slice().into()))
            .to(be_ok())
            .into_inner()
            .into_iter()
            .collect::<Vec<_>>();

    let expected_bytes = [new_bytes, &bytes[new_bytes.len()..]].concat();

    expect!(block_list.clone()).to(match_elements([match_fields(fields!(Block {
        signature: equal(BlockSignature::Data {
            hash: BlockHasher::hash(&expected_bytes),
            len: expected_bytes.len(),
        }),
    }))]));

    let actual_block_list = expect!(data_store.list_blocks(file_id))
        .to(be_ok())
        .into_inner()
        .into_iter()
        .collect::<Vec<_>>();

    expect!(block_list).to(equal(actual_block_list));
}

#[test]
fn write_file_start_to_mid_different_block() {
    let mut block_store = MemoryBlockStore::new();
    let file_id = FileId::from(1);

    expect!(block_store.insert_data(file_id, 0))
        .to(be_ok())
        .into_inner();
    let DataBlock {
        bytes: second_bytes,
        ..
    } = expect!(block_store.insert_data(file_id, 1))
        .to(be_ok())
        .into_inner();

    let mut data_store = ChunkingBlockStoreAdapter::without_chunking(block_store);

    let write_len = TEST_BLOCK_SIZE + TEST_BLOCK_SIZE / 2;
    let write_data = random_buf(write_len, Case::Upper);

    let block_list = expect!(data_store.list_blocks(file_id))
        .to(be_ok())
        .into_inner();

    let block_list =
        expect!(data_store.write_block(file_id, 0, block_list, write_data.as_slice().into()))
            .to(be_ok())
            .into_inner()
            .into_iter()
            .collect::<Vec<_>>();

    let expected_bytes = [&write_data, &second_bytes[TEST_BLOCK_SIZE / 2..]].concat();
    let expected_hash = BlockHasher::hash(&expected_bytes);

    expect!(block_list.clone()).to(match_elements([match_fields(fields!(Block {
        signature: equal(BlockSignature::Data {
            hash: expected_hash,
            len: expected_bytes.len(),
        }),
    }))]));

    let actual_block_list = expect!(data_store.list_blocks(file_id))
        .to(be_ok())
        .into_inner()
        .into_iter()
        .collect::<Vec<_>>();

    expect!(block_list).to(equal(actual_block_list));
}

#[test]
fn write_block_boundary_to_file_end() {
    let mut block_store = MemoryBlockStore::new();
    let file_id = FileId::from(1);

    let DataBlock {
        bytes: first_bytes,
        hash: first_hash,
        ..
    } = expect!(block_store.insert_data(file_id, 0))
        .to(be_ok())
        .into_inner();
    expect!(block_store.insert_data(file_id, 1))
        .to(be_ok())
        .into_inner();

    let mut data_store = ChunkingBlockStoreAdapter::without_chunking(block_store);

    let write_offset = TEST_BLOCK_SIZE as u64;
    let write_data = random_buf(TEST_BLOCK_SIZE, Case::Upper);
    let write_hash = BlockHasher::hash(&write_data);

    let block_list = expect!(data_store.list_blocks(file_id))
        .to(be_ok())
        .into_inner();

    let block_list = expect!(data_store.write_block(
        file_id,
        write_offset,
        block_list,
        write_data.as_slice().into(),
    ))
    .to(be_ok())
    .into_inner()
    .into_iter()
    .collect::<Vec<_>>();

    expect!(&block_list).to(have_len(2));

    expect!(block_list.clone()).to(match_elements([
        match_fields(fields!(Block {
            signature: equal(BlockSignature::Data {
                hash: first_hash,
                len: first_bytes.len(),
            }),
        })),
        match_fields(fields!(Block {
            signature: equal(BlockSignature::Data {
                hash: write_hash,
                len: write_data.len(),
            }),
        })),
    ]));

    let actual_block_list = expect!(data_store.list_blocks(file_id))
        .to(be_ok())
        .into_inner()
        .into_iter()
        .collect::<Vec<_>>();

    expect!(block_list).to(equal(actual_block_list));
}

#[test]
fn write_block_boundary_to_block_boundary() {
    let mut block_store = MemoryBlockStore::new();
    let file_id = FileId::from(1);

    let DataBlock {
        bytes: first_bytes,
        hash: first_hash,
        ..
    } = expect!(block_store.insert_data(file_id, 0))
        .to(be_ok())
        .into_inner();
    expect!(block_store.insert_data(file_id, 1))
        .to(be_ok())
        .into_inner();
    let DataBlock {
        bytes: third_bytes,
        hash: third_hash,
        ..
    } = expect!(block_store.insert_data(file_id, 2))
        .to(be_ok())
        .into_inner();

    let mut data_store = ChunkingBlockStoreAdapter::without_chunking(block_store);

    let block_list = expect!(data_store.list_blocks(file_id))
        .to(be_ok())
        .into_inner();

    let write_offset = TEST_BLOCK_SIZE as u64;
    let write_data = random_buf(TEST_BLOCK_SIZE, Case::Upper);
    let write_hash = BlockHasher::hash(&write_data);

    let block_list = expect!(data_store.write_block(
        file_id,
        write_offset,
        block_list,
        write_data.as_slice().into(),
    ))
    .to(be_ok())
    .into_inner()
    .into_iter()
    .collect::<Vec<_>>();

    expect!(&block_list).to(have_len(3));

    expect!(block_list.clone()).to(match_elements([
        match_fields(fields!(Block {
            signature: equal(BlockSignature::Data {
                hash: first_hash,
                len: first_bytes.len(),
            }),
        })),
        match_fields(fields!(Block {
            signature: equal(BlockSignature::Data {
                hash: write_hash,
                len: write_data.len(),
            }),
        })),
        match_fields(fields!(Block {
            signature: equal(BlockSignature::Data {
                hash: third_hash,
                len: third_bytes.len(),
            }),
        })),
    ]));

    let actual_block_list = expect!(data_store.list_blocks(file_id))
        .to(be_ok())
        .into_inner()
        .into_iter()
        .collect::<Vec<_>>();

    expect!(block_list).to(equal(actual_block_list));
}

#[test]
fn write_block_boundary_to_mid_same_block() {
    let mut block_store = MemoryBlockStore::new();
    let file_id = FileId::from(1);

    let DataBlock {
        bytes: first_bytes,
        hash: first_hash,
        ..
    } = expect!(block_store.insert_data(file_id, 0))
        .to(be_ok())
        .into_inner();
    let DataBlock {
        bytes: second_bytes,
        ..
    } = expect!(block_store.insert_data(file_id, 1))
        .to(be_ok())
        .into_inner();

    let mut data_store = ChunkingBlockStoreAdapter::without_chunking(block_store);

    let block_list = expect!(data_store.list_blocks(file_id))
        .to(be_ok())
        .into_inner();
    let write_offset = TEST_BLOCK_SIZE as u64;

    let write_len = TEST_BLOCK_SIZE / 2;
    let write_data = random_buf(write_len, Case::Upper);

    let block_list = expect!(data_store.write_block(
        file_id,
        write_offset,
        block_list,
        write_data.as_slice().into()
    ))
    .to(be_ok())
    .into_inner()
    .into_iter()
    .collect::<Vec<_>>();

    let expected_second_bytes = [&write_data, &second_bytes[write_len..]].concat();
    let expected_second_hash = BlockHasher::hash(&expected_second_bytes);

    expect!(&block_list).to(have_len(2));

    expect!(block_list.clone()).to(match_elements([
        match_fields(fields!(Block {
            signature: equal(BlockSignature::Data {
                hash: first_hash,
                len: first_bytes.len(),
            }),
        })),
        match_fields(fields!(Block {
            signature: equal(BlockSignature::Data {
                hash: expected_second_hash,
                len: expected_second_bytes.len(),
            }),
        })),
    ]));

    let actual_block_list = expect!(data_store.list_blocks(file_id))
        .to(be_ok())
        .into_inner()
        .into_iter()
        .collect::<Vec<_>>();

    expect!(block_list).to(equal(actual_block_list));
}

#[test]
fn write_block_boundary_to_mid_different_block() {
    let mut block_store = MemoryBlockStore::new();
    let file_id = FileId::from(1);

    let DataBlock {
        bytes: first_bytes,
        hash: first_hash,
        ..
    } = expect!(block_store.insert_data(file_id, 0))
        .to(be_ok())
        .into_inner();
    let DataBlock {
        bytes: second_bytes,
        ..
    } = expect!(block_store.insert_data(file_id, 1))
        .to(be_ok())
        .into_inner();

    let mut data_store = ChunkingBlockStoreAdapter::without_chunking(block_store);

    let block_list = expect!(data_store.list_blocks(file_id))
        .to(be_ok())
        .into_inner();

    let write_offset = TEST_BLOCK_SIZE as u64;
    let write_len = TEST_BLOCK_SIZE / 2;
    let write_data = random_buf(write_len, Case::Upper);

    let block_list = expect!(data_store.write_block(
        file_id,
        write_offset,
        block_list,
        write_data.as_slice().into()
    ))
    .to(be_ok())
    .into_inner()
    .into_iter()
    .collect::<Vec<_>>();

    let expected_second_bytes = [&write_data, &second_bytes[write_len..]].concat();
    let expected_second_hash = BlockHasher::hash(&expected_second_bytes);

    expect!(block_list.clone()).to(match_elements([
        match_fields(fields!(Block {
            signature: equal(BlockSignature::Data {
                hash: first_hash,
                len: first_bytes.len(),
            }),
        })),
        match_fields(fields!(Block {
            signature: equal(BlockSignature::Data {
                hash: expected_second_hash,
                len: expected_second_bytes.len(),
            }),
        })),
    ]));

    let actual_block_list = expect!(data_store.list_blocks(file_id))
        .to(be_ok())
        .into_inner()
        .into_iter()
        .collect::<Vec<_>>();

    expect!(block_list).to(equal(actual_block_list));
}

#[test]
fn write_mid_block_to_file_end() {
    let mut block_store = MemoryBlockStore::new();
    let file_id = FileId::from(1);

    let DataBlock {
        bytes: first_bytes, ..
    } = expect!(block_store.insert_data(file_id, 0))
        .to(be_ok())
        .into_inner();
    expect!(block_store.insert_data(file_id, 1))
        .to(be_ok())
        .into_inner();

    let mut data_store = ChunkingBlockStoreAdapter::without_chunking(block_store);

    let block_list = expect!(data_store.list_blocks(file_id))
        .to(be_ok())
        .into_inner();

    let write_offset = TEST_BLOCK_SIZE as u64 / 2;
    let write_data = random_buf(
        (TEST_BLOCK_SIZE - write_offset as usize) + TEST_BLOCK_SIZE,
        Case::Upper,
    );

    let block_list = expect!(data_store.write_block(
        file_id,
        write_offset,
        block_list,
        write_data.as_slice().into()
    ))
    .to(be_ok())
    .into_inner()
    .into_iter()
    .collect::<Vec<_>>();

    let expected_bytes = [&first_bytes[0..write_offset as usize], &write_data].concat();
    let expected_hash = BlockHasher::hash(&expected_bytes);

    expect!(&block_list).to(have_len(1));

    expect!(block_list.clone()).to(match_elements([match_fields(fields!(Block {
        signature: equal(BlockSignature::Data {
            hash: expected_hash,
            len: expected_bytes.len(),
        }),
    }))]));

    let actual_block_list = expect!(data_store.list_blocks(file_id))
        .to(be_ok())
        .into_inner()
        .into_iter()
        .collect::<Vec<_>>();

    expect!(block_list).to(equal(actual_block_list));
}

#[test]
fn write_mid_block_to_block_boundary() {
    let mut block_store = MemoryBlockStore::new();
    let file_id = FileId::from(1);

    let DataBlock {
        bytes: first_bytes, ..
    } = expect!(block_store.insert_data(file_id, 0))
        .to(be_ok())
        .into_inner();
    let DataBlock {
        bytes: second_bytes,
        hash: second_hash,
        ..
    } = expect!(block_store.insert_data(file_id, 1))
        .to(be_ok())
        .into_inner();

    let mut data_store = ChunkingBlockStoreAdapter::without_chunking(block_store);

    let block_list = expect!(data_store.list_blocks(file_id))
        .to(be_ok())
        .into_inner();

    let write_offset = TEST_BLOCK_SIZE as u64 / 2;
    let write_len = TEST_BLOCK_SIZE / 2;
    let write_data = random_buf(write_len, Case::Upper);

    let block_list = expect!(data_store.write_block(
        file_id,
        write_offset,
        block_list,
        write_data.as_slice().into()
    ))
    .to(be_ok())
    .into_inner()
    .into_iter()
    .collect::<Vec<_>>();

    let expected_first_bytes = [&first_bytes[0..write_offset as usize], &write_data].concat();
    let expected_first_hash = BlockHasher::hash(&expected_first_bytes);

    expect!(block_list.clone()).to(match_elements([
        match_fields(fields!(Block {
            signature: equal(BlockSignature::Data {
                hash: expected_first_hash,
                len: expected_first_bytes.len(),
            }),
        })),
        match_fields(fields!(Block {
            signature: equal(BlockSignature::Data {
                hash: second_hash,
                len: second_bytes.len(),
            }),
        })),
    ]));

    let actual_block_list = expect!(data_store.list_blocks(file_id))
        .to(be_ok())
        .into_inner()
        .into_iter()
        .collect::<Vec<_>>();

    expect!(block_list).to(equal(actual_block_list));
}

#[test]
fn write_mid_block_to_mid_same_block() {
    let mut block_store = MemoryBlockStore::new();
    let file_id = FileId::from(1);

    let DataBlock { bytes: block, .. } = expect!(block_store.insert_data(file_id, 0))
        .to(be_ok())
        .into_inner();

    let mut data_store = ChunkingBlockStoreAdapter::without_chunking(block_store);

    let block_list = expect!(data_store.list_blocks(file_id))
        .to(be_ok())
        .into_inner();

    let write_offset = TEST_BLOCK_SIZE as u64 - 3;
    let write_data = b"XX";

    let block_list = expect!(data_store.write_block(
        file_id,
        write_offset,
        block_list,
        write_data.as_slice().into()
    ))
    .to(be_ok())
    .into_inner()
    .into_iter()
    .collect::<Vec<_>>();

    let expected_bytes = &[
        &block[0..write_offset as usize],
        write_data,
        &block[(write_offset as usize + write_data.len())..],
    ]
    .concat();
    let expected_hash = BlockHasher::hash(expected_bytes);

    expect!(block_list.clone()).to(match_elements([match_fields(fields!(Block {
        signature: equal(BlockSignature::Data {
            hash: expected_hash,
            len: expected_bytes.len(),
        }),
    }))]));

    let actual_block_list = expect!(data_store.list_blocks(file_id))
        .to(be_ok())
        .into_inner()
        .into_iter()
        .collect::<Vec<_>>();

    expect!(block_list).to(equal(actual_block_list));
}

#[test]
fn write_mid_block_to_mid_different_block() {
    let mut block_store = MemoryBlockStore::new();
    let file_id = FileId::from(1);

    let DataBlock {
        bytes: first_bytes, ..
    } = expect!(block_store.insert_data(file_id, 0))
        .to(be_ok())
        .into_inner();

    expect!(block_store.insert_data(file_id, 1))
        .to(be_ok())
        .into_inner();

    let DataBlock {
        bytes: third_bytes, ..
    } = expect!(block_store.insert_data(file_id, 2))
        .to(be_ok())
        .into_inner();

    let mut data_store = ChunkingBlockStoreAdapter::without_chunking(block_store);

    let block_list = expect!(data_store.list_blocks(file_id))
        .to(be_ok())
        .into_inner();

    let write_offset = TEST_BLOCK_SIZE as u64 / 2;
    let write_len = TEST_BLOCK_SIZE * 2;
    let write_data = random_buf(write_len, Case::Upper);

    let block_list = expect!(data_store.write_block(
        file_id,
        write_offset,
        block_list,
        write_data.as_slice().into()
    ))
    .to(be_ok())
    .into_inner()
    .into_iter()
    .collect::<Vec<_>>();

    let expected_block = &[
        &first_bytes[0..write_offset as usize],
        &write_data,
        &third_bytes[TEST_BLOCK_SIZE / 2..],
    ]
    .concat();
    let expected_hash = BlockHasher::hash(expected_block);

    expect!(block_list.clone()).to(match_elements([match_fields(fields!(Block {
        signature: equal(BlockSignature::Data {
            hash: expected_hash,
            len: expected_block.len(),
        }),
    }))]));

    let actual_block_list = expect!(data_store.list_blocks(file_id))
        .to(be_ok())
        .into_inner()
        .into_iter()
        .collect::<Vec<_>>();

    expect!(block_list).to(equal(actual_block_list));
}

#[test]
fn write_append() {
    let mut block_store = MemoryBlockStore::new();
    let file_id = FileId::from(1);

    let DataBlock {
        id: original_id, ..
    } = expect!(block_store.insert_data(file_id, 0))
        .to(be_ok())
        .into_inner();

    let mut data_store = ChunkingBlockStoreAdapter::without_chunking(block_store);

    let block_list = expect!(data_store.list_blocks(file_id))
        .to(be_ok())
        .into_inner();

    let write_data = b"APPEND";
    let write_hash = BlockHasher::hash(write_data);

    let block_list = expect!(data_store.write_block(
        file_id,
        TEST_BLOCK_SIZE as u64,
        block_list,
        write_data.as_slice().into()
    ))
    .to(be_ok())
    .into_inner()
    .into_iter()
    .collect::<Vec<_>>();

    expect!(&block_list).to(have_len(2));

    expect!(block_list.clone()).to(match_elements([
        match_fields(fields!(Block {
            id: equal(original_id),
        })),
        match_fields(fields!(Block {
            signature: equal(BlockSignature::Data {
                hash: write_hash,
                len: write_data.len(),
            }),
        })),
    ]));

    let actual_block_list = expect!(data_store.list_blocks(file_id))
        .to(be_ok())
        .into_inner()
        .into_iter()
        .collect::<Vec<_>>();

    expect!(block_list).to(equal(actual_block_list));
}

#[test]
fn write_append_with_hole() {
    let mut block_store = MemoryBlockStore::new();
    let file_id = FileId::from(1);

    let DataBlock {
        id: original_id, ..
    } = expect!(block_store.insert_data(file_id, 0))
        .to(be_ok())
        .into_inner();

    let mut data_store = ChunkingBlockStoreAdapter::without_chunking(block_store);

    let block_list = expect!(data_store.list_blocks(file_id))
        .to(be_ok())
        .into_inner();

    let gap_size = 10;
    let write_offset = TEST_BLOCK_SIZE + gap_size;
    let write_data = b"GAPPED";
    let write_hash = BlockHasher::hash(write_data);

    let block_list = expect!(data_store.write_block(
        file_id,
        write_offset as FileOffset,
        block_list,
        write_data.as_slice().into()
    ))
    .to(be_ok())
    .into_inner()
    .into_iter()
    .collect::<Vec<_>>();

    expect!(&block_list).to(have_len(3));

    expect!(block_list.clone()).to(match_elements([
        match_fields(fields!(Block {
            id: equal(original_id),
        })),
        match_fields(fields!(Block {
            signature: equal(BlockSignature::Hole {
                len: gap_size as HoleLen
            }),
        })),
        match_fields(fields!(Block {
            signature: equal(BlockSignature::Data {
                hash: write_hash,
                len: write_data.len(),
            }),
        })),
    ]));

    let actual_block_list = expect!(data_store.list_blocks(file_id))
        .to(be_ok())
        .into_inner()
        .into_iter()
        .collect::<Vec<_>>();

    expect!(block_list).to(equal(actual_block_list));
}

#[test]
fn write_hole_into_existing_data() {
    // Tests the FullSliceBuf::splice path with BlockStoreInput::Hole, which creates:
    // [data_before_splice, hole, data_after_splice].
    let mut block_store = MemoryBlockStore::new();
    let file_id = FileId::from(1);

    expect!(block_store.insert_block(file_id, 0, b"AAAAAAAA".as_slice().into())).to(be_ok());
    expect!(block_store.insert_block(file_id, 1, b"BBBBBBBB".as_slice().into())).to(be_ok());

    let mut data_store = ChunkingBlockStoreAdapter::without_chunking(block_store);

    let block_list = expect!(data_store.list_blocks(file_id))
        .to(be_ok())
        .into_inner();

    // Splice a hole of 5 bytes at offset 4, replacing range [4, 9).
    // The slice loaded is [block 0, block 1] with data "AAAAAAAABBBBBBBB".
    // before_split = "AAAA" (bytes 0..4)
    // after_split = "BBBBBBB" (bytes 9..16)
    let hole_len = 5;
    let block_list = expect!(data_store.write_block(
        file_id,
        4,
        block_list,
        BlockStoreInput::Hole { len: hole_len }
    ))
    .to(be_ok())
    .into_inner()
    .into_iter()
    .collect::<Vec<_>>();

    // Should create 3 blocks:
    // 1. Data before splice: "AAAA" (4 bytes)
    // 2. Hole (5 bytes)
    // 3. Data after splice: "BBBBBBB" (7 bytes)
    expect!(&block_list).to(have_len(3));

    expect!(block_list.clone()).to(match_elements([
        match_fields(fields!(Block {
            signature: equal(BlockSignature::Data {
                hash: BlockHasher::hash(b"AAAA"),
                len: 4,
            }),
        })),
        match_fields(fields!(Block {
            signature: equal(BlockSignature::Hole { len: hole_len }),
        })),
        match_fields(fields!(Block {
            signature: equal(BlockSignature::Data {
                hash: BlockHasher::hash(b"BBBBBBB"),
                len: 7,
            }),
        })),
    ]));

    let actual_block_list = expect!(data_store.list_blocks(file_id))
        .to(be_ok())
        .into_inner()
        .into_iter()
        .collect::<Vec<_>>();

    expect!(block_list).to(equal(actual_block_list));
}

#[test]
fn write_hole_at_file_start() {
    // Tests splicing a hole at the very beginning of the file.
    let mut block_store = MemoryBlockStore::new();
    let file_id = FileId::from(1);

    expect!(block_store.insert_block(file_id, 0, b"AAAAAAAA".as_slice().into())).to(be_ok());

    let mut data_store = ChunkingBlockStoreAdapter::without_chunking(block_store);

    let block_list = expect!(data_store.list_blocks(file_id))
        .to(be_ok())
        .into_inner();

    // Splice a hole of 3 bytes at offset 0, replacing 4 bytes.
    let hole_len = 3;
    let block_list = expect!(data_store.write_block(
        file_id,
        0,
        block_list,
        BlockStoreInput::Hole { len: hole_len }
    ))
    .to(be_ok())
    .into_inner()
    .into_iter()
    .collect::<Vec<_>>();

    // Should create 3 blocks:
    // 1. Empty data before splice (0 bytes, but still created)
    // 2. Hole (3 bytes)
    // 3. Data after splice: "AAAA" (4 bytes)
    expect!(&block_list).to(have_len(3));

    expect!(block_list.get(1))
        .to(be_some())
        .map(|b| &b.signature)
        .to(equal(&BlockSignature::Hole { len: hole_len }));
}

#[test]
fn write_hole_at_file_end() {
    // Tests splicing a hole at the end of the file.
    let mut block_store = MemoryBlockStore::new();
    let file_id = FileId::from(1);

    expect!(block_store.insert_block(file_id, 0, b"AAAAAAAA".as_slice().into())).to(be_ok());

    let mut data_store = ChunkingBlockStoreAdapter::without_chunking(block_store);

    let block_list = expect!(data_store.list_blocks(file_id))
        .to(be_ok())
        .into_inner();

    // Splice a hole of 5 bytes at offset 4, replacing the last 4 bytes.
    let hole_len = 5;
    let block_list = expect!(data_store.write_block(
        file_id,
        4,
        block_list,
        BlockStoreInput::Hole { len: hole_len }
    ))
    .to(be_ok())
    .into_inner()
    .into_iter()
    .collect::<Vec<_>>();

    // Should create 3 blocks:
    // 1. Data before splice: "AAAA" (4 bytes)
    // 2. Hole (5 bytes)
    // 3. Empty data after splice (0 bytes, but still created)
    expect!(&block_list).to(have_len(3));

    expect!(block_list.get(0))
        .to(be_some())
        .map(|b| &b.signature)
        .to(equal(&BlockSignature::Data {
            hash: BlockHasher::hash(b"AAAA"),
            len: 4,
        }));

    expect!(block_list.get(1))
        .to(be_some())
        .map(|b| &b.signature)
        .to(equal(&BlockSignature::Hole { len: hole_len }));
}

#[test]
fn write_hole_spanning_multiple_blocks() {
    // Tests splicing a hole that spans multiple existing blocks.
    let mut block_store = MemoryBlockStore::new();
    let file_id = FileId::from(1);

    expect!(block_store.insert_block(file_id, 0, b"AAAAAAAA".as_slice().into())).to(be_ok());
    expect!(block_store.insert_block(file_id, 1, b"BBBBBBBB".as_slice().into())).to(be_ok());
    expect!(block_store.insert_block(file_id, 2, b"CCCCCCCC".as_slice().into())).to(be_ok());

    let mut data_store = ChunkingBlockStoreAdapter::without_chunking(block_store);

    let block_list = expect!(data_store.list_blocks(file_id))
        .to(be_ok())
        .into_inner();

    // Splice a hole of 10 bytes at offset 4, replacing range [4, 14).
    // The slice loaded is [block 0, block 1] with data "AAAAAAAABBBBBBBB" (16 bytes).
    // before_split = "AAAA" (bytes 0..4)
    // after_split = "BB" (bytes 14..16)
    // Block 2 ("CCCCCCCC") is not part of the loaded slice and remains unchanged.
    let hole_len = 10;
    let block_list = expect!(data_store.write_block(
        file_id,
        4,
        block_list,
        BlockStoreInput::Hole { len: hole_len }
    ))
    .to(be_ok())
    .into_inner()
    .into_iter()
    .collect::<Vec<_>>();

    // Should create 4 blocks:
    // 1. Data before splice: "AAAA" (4 bytes)
    // 2. Hole (10 bytes)
    // 3. Data after splice: "BB" (2 bytes)
    // 4. Unchanged block: "CCCCCCCC" (8 bytes)
    expect!(&block_list).to(have_len(4));

    expect!(block_list.clone()).to(match_elements([
        match_fields(fields!(Block {
            signature: equal(BlockSignature::Data {
                hash: BlockHasher::hash(b"AAAA"),
                len: 4,
            }),
        })),
        match_fields(fields!(Block {
            signature: equal(BlockSignature::Hole { len: hole_len }),
        })),
        match_fields(fields!(Block {
            signature: equal(BlockSignature::Data {
                hash: BlockHasher::hash(b"BB"),
                len: 2,
            }),
        })),
        match_fields(fields!(Block {
            signature: equal(BlockSignature::Data {
                hash: BlockHasher::hash(b"CCCCCCCC"),
                len: 8,
            }),
        })),
    ]));
}

#[test]
fn write_data_into_existing_hole_mid_block() {
    // Tests the regression where writing data into the middle of an existing hole block panicked
    // because the loaded buffer omitted the hole's implicit zero bytes while the splice offsets
    // were computed from the hole's logical length.
    let mut block_store = MemoryBlockStore::new();
    let file_id = FileId::from(1);

    let hole_len: HoleLen = 32;
    expect!(block_store.insert_block(file_id, 0, BlockStoreInput::Hole { len: hole_len }))
        .to(be_ok());

    let mut data_store = ChunkingBlockStoreAdapter::without_chunking(block_store);

    let block_list = expect!(data_store.list_blocks(file_id))
        .to(be_ok())
        .into_inner();

    // Write 4 bytes of data into the middle of the hole at offset 8.
    let write_data = b"DATA";
    let block_list =
        expect!(data_store.write_block(file_id, 8, block_list, write_data.as_slice().into()))
            .to(be_ok())
            .into_inner()
            .into_iter()
            .collect::<Vec<_>>();

    // Should create 3 blocks, preserving the surrounding sparsity:
    // 1. Hole (8 bytes) — original hole, truncated.
    // 2. Data "DATA" (4 bytes).
    // 3. Hole (20 bytes) — remainder of original hole.
    expect!(&block_list).to(have_len(3));

    expect!(block_list).to(match_elements([
        match_fields(fields!(Block {
            signature: equal(BlockSignature::Hole { len: 8 }),
        })),
        match_fields(fields!(Block {
            signature: equal(BlockSignature::Data {
                hash: BlockHasher::hash(b"DATA"),
                len: 4,
            }),
        })),
        match_fields(fields!(Block {
            signature: equal(BlockSignature::Hole { len: 20 }),
        })),
    ]));
}

#[test]
fn write_data_at_start_of_existing_hole() {
    let mut block_store = MemoryBlockStore::new();
    let file_id = FileId::from(1);

    let hole_len: HoleLen = 16;
    expect!(block_store.insert_block(file_id, 0, BlockStoreInput::Hole { len: hole_len }))
        .to(be_ok());

    let mut data_store = ChunkingBlockStoreAdapter::without_chunking(block_store);

    let block_list = expect!(data_store.list_blocks(file_id))
        .to(be_ok())
        .into_inner();

    // Write 4 bytes at the very start of the hole.
    let write_data = b"DATA";
    let block_list =
        expect!(data_store.write_block(file_id, 0, block_list, write_data.as_slice().into()))
            .to(be_ok())
            .into_inner()
            .into_iter()
            .collect::<Vec<_>>();

    // Should create 2 blocks: [data, hole_remainder].
    expect!(&block_list).to(have_len(2));

    expect!(block_list).to(match_elements([
        match_fields(fields!(Block {
            signature: equal(BlockSignature::Data {
                hash: BlockHasher::hash(b"DATA"),
                len: 4,
            }),
        })),
        match_fields(fields!(Block {
            signature: equal(BlockSignature::Hole { len: 12 }),
        })),
    ]));
}

#[test]
fn write_data_at_end_of_existing_hole() {
    let mut block_store = MemoryBlockStore::new();
    let file_id = FileId::from(1);

    let hole_len: HoleLen = 16;
    expect!(block_store.insert_block(file_id, 0, BlockStoreInput::Hole { len: hole_len }))
        .to(be_ok());

    let mut data_store = ChunkingBlockStoreAdapter::without_chunking(block_store);

    let block_list = expect!(data_store.list_blocks(file_id))
        .to(be_ok())
        .into_inner();

    // Write 4 bytes at the end of the hole, replacing its final 4 bytes.
    let write_data = b"DATA";
    let block_list =
        expect!(data_store.write_block(file_id, 12, block_list, write_data.as_slice().into()))
            .to(be_ok())
            .into_inner()
            .into_iter()
            .collect::<Vec<_>>();

    // Should create 2 blocks: [hole_prefix, data].
    expect!(&block_list).to(have_len(2));

    expect!(block_list).to(match_elements([
        match_fields(fields!(Block {
            signature: equal(BlockSignature::Hole { len: 12 }),
        })),
        match_fields(fields!(Block {
            signature: equal(BlockSignature::Data {
                hash: BlockHasher::hash(b"DATA"),
                len: 4,
            }),
        })),
    ]));
}

#[test]
fn write_data_spanning_hole_and_data_blocks() {
    // Write spans the tail of a hole block into the head of a data block. The partial path must
    // split the hole logically and the data block by bytes.
    let mut block_store = MemoryBlockStore::new();
    let file_id = FileId::from(1);

    let hole_len: HoleLen = 16;
    expect!(block_store.insert_block(file_id, 0, BlockStoreInput::Hole { len: hole_len }))
        .to(be_ok());
    expect!(block_store.insert_block(file_id, 1, b"AAAAAAAA".as_slice().into())).to(be_ok());

    let mut data_store = ChunkingBlockStoreAdapter::without_chunking(block_store);

    let block_list = expect!(data_store.list_blocks(file_id))
        .to(be_ok())
        .into_inner();

    // Write 6 bytes at offset 12: covers last 4 bytes of hole and first 2 bytes of data block.
    let write_data = b"NEWNEW";
    let block_list =
        expect!(data_store.write_block(file_id, 12, block_list, write_data.as_slice().into()))
            .to(be_ok())
            .into_inner()
            .into_iter()
            .collect::<Vec<_>>();

    // Should produce: [hole(12), new_data(6), data("AAAAAA"=6)].
    expect!(&block_list).to(have_len(3));

    expect!(block_list).to(match_elements([
        match_fields(fields!(Block {
            signature: equal(BlockSignature::Hole { len: 12 }),
        })),
        match_fields(fields!(Block {
            signature: equal(BlockSignature::Data {
                hash: BlockHasher::hash(b"NEWNEW"),
                len: 6,
            }),
        })),
        match_fields(fields!(Block {
            signature: equal(BlockSignature::Data {
                hash: BlockHasher::hash(b"AAAAAA"),
                len: 6,
            }),
        })),
    ]));
}

#[test]
fn write_data_spanning_data_and_hole_blocks() {
    // Symmetric to `write_data_spanning_hole_and_data_blocks`: a data block followed by a hole,
    // with a write that starts inside the data and ends inside the hole. The partial path must
    // truncate the trailing hole, not leave it intact in addition to the spliced fragment.
    let mut block_store = MemoryBlockStore::new();
    let file_id = FileId::from(1);

    expect!(block_store.insert_block(file_id, 0, b"AAAAAAAA".as_slice().into())).to(be_ok());
    let hole_len: HoleLen = 16;
    expect!(block_store.insert_block(file_id, 1, BlockStoreInput::Hole { len: hole_len }))
        .to(be_ok());

    let mut data_store = ChunkingBlockStoreAdapter::without_chunking(block_store);

    let block_list = expect!(data_store.list_blocks(file_id))
        .to(be_ok())
        .into_inner();

    // Write 6 bytes at offset 6: covers last 2 bytes of data and first 4 bytes of hole.
    let write_data = b"NEWNEW";
    let block_list =
        expect!(data_store.write_block(file_id, 6, block_list, write_data.as_slice().into()))
            .to(be_ok())
            .into_inner()
            .into_iter()
            .collect::<Vec<_>>();

    // Should produce: [data("AAAAAA"=6), new_data(6), hole(12)]. Total length 24, unchanged.
    expect!(&block_list).to(have_len(3));

    expect!(block_list).to(match_elements([
        match_fields(fields!(Block {
            signature: equal(BlockSignature::Data {
                hash: BlockHasher::hash(b"AAAAAA"),
                len: 6,
            }),
        })),
        match_fields(fields!(Block {
            signature: equal(BlockSignature::Data {
                hash: BlockHasher::hash(b"NEWNEW"),
                len: 6,
            }),
        })),
        match_fields(fields!(Block {
            signature: equal(BlockSignature::Hole { len: 12 }),
        })),
    ]));
}

#[test]
fn write_spanning_multiple_data_blocks_into_trailing_hole() {
    // Reproducer for the fsx size-mismatch: an extend-by-truncate-up appended a hole after
    // existing chunked data, and the next write spanned several data blocks into the trailing
    // hole. The expected total file size must equal the sum of: the unchanged data prefix, the
    // newly written bytes, and the hole remainder past the write end.
    let mut block_store = MemoryBlockStore::new();
    let file_id = FileId::from(1);

    // Four 8-byte data blocks then a 32-byte trailing hole. Total length: 64 bytes.
    expect!(block_store.insert_block(file_id, 0, b"AAAAAAAA".as_slice().into())).to(be_ok());
    expect!(block_store.insert_block(file_id, 1, b"BBBBBBBB".as_slice().into())).to(be_ok());
    expect!(block_store.insert_block(file_id, 2, b"CCCCCCCC".as_slice().into())).to(be_ok());
    expect!(block_store.insert_block(file_id, 3, b"DDDDDDDD".as_slice().into())).to(be_ok());
    let hole_len: HoleLen = 32;
    expect!(block_store.insert_block(file_id, 4, BlockStoreInput::Hole { len: hole_len }))
        .to(be_ok());

    // Use a small_write_threshold of 1 so the full path is preferred for any non-empty write that
    // touches only data blocks, mirroring the production setting; the partial path is still
    // selected here because the slice contains a hole.
    let mut data_store = ChunkingBlockStoreAdapter::with_small_write_threshold(block_store, 1);

    let block_list = expect!(data_store.list_blocks(file_id))
        .to(be_ok())
        .into_inner();
    expect!(block_list.clone().file_len()).to(equal(64 as FileOffset));

    // Write 20 bytes starting at offset 12: spans the tail of block 1, all of blocks 2 and 3, and
    // the first 4 bytes of the trailing hole.
    let write_data = random_buf(20, Case::Upper);
    let block_list =
        expect!(data_store.write_block(file_id, 12, block_list, write_data.as_slice().into()))
            .to(be_ok())
            .into_inner();

    // The total length of the file must be preserved: 64 bytes.
    expect!(block_list.clone().file_len()).to(equal(64 as FileOffset));

    // And re-reading from the store must agree with the in-memory editor.
    let stored = expect!(data_store.list_blocks(file_id))
        .to(be_ok())
        .into_inner();
    expect!(stored.clone().file_len()).to(equal(64 as FileOffset));
}

#[test]
fn write_spanning_data_into_adjacent_trailing_hole_with_large_threshold() {
    // Two-block slice (data then hole), write spans the boundary. Uses a small_write_threshold
    // larger than the write so the partial path is selected *only* because the slice contains a
    // hole (not because the write is small). Verifies the trailing hole is correctly truncated to
    // its remainder.
    let mut block_store = MemoryBlockStore::new();
    let file_id = FileId::from(1);

    expect!(block_store.insert_block(file_id, 0, b"AAAAAAAAAAAAAAAA".as_slice().into()))
        .to(be_ok());
    let hole_len: HoleLen = 32;
    expect!(block_store.insert_block(file_id, 1, BlockStoreInput::Hole { len: hole_len }))
        .to(be_ok());

    let mut data_store = ChunkingBlockStoreAdapter::with_small_write_threshold(block_store, 1024);

    let block_list = expect!(data_store.list_blocks(file_id))
        .to(be_ok())
        .into_inner();

    // Write 8 bytes at offset 12: last 4 of data, first 4 of hole.
    let write_data = b"NEW12345";
    let block_list =
        expect!(data_store.write_block(file_id, 12, block_list, write_data.as_slice().into()))
            .to(be_ok())
            .into_inner()
            .into_iter()
            .collect::<Vec<_>>();

    // Expect [data(12), new(8), hole(28)] — total 48 bytes, unchanged.
    expect!(&block_list).to(have_len(3));
    expect!(block_list).to(match_elements([
        match_fields(fields!(Block {
            signature: equal(BlockSignature::Data {
                hash: BlockHasher::hash(b"AAAAAAAAAAAA"),
                len: 12,
            }),
        })),
        match_fields(fields!(Block {
            signature: equal(BlockSignature::Data {
                hash: BlockHasher::hash(b"NEW12345"),
                len: 8,
            }),
        })),
        match_fields(fields!(Block {
            signature: equal(BlockSignature::Hole { len: 28 }),
        })),
    ]));
}

#[test]
fn write_large_data_into_existing_hole_does_not_panic() {
    // Reproducer for the FUSE/fsx panic: a write larger than `small_write_threshold` that lands
    // inside an existing hole. The full re-chunking path would index the loaded buffer using the
    // hole's logical length, which is out of bounds because hole reads append no bytes.
    let mut block_store = MemoryBlockStore::new();
    let file_id = FileId::from(1);

    let hole_len: HoleLen = 1024;
    expect!(block_store.insert_block(file_id, 0, BlockStoreInput::Hole { len: hole_len }))
        .to(be_ok());

    let mut data_store = ChunkingBlockStoreAdapter::with_small_write_threshold(block_store, 4);

    let block_list = expect!(data_store.list_blocks(file_id))
        .to(be_ok())
        .into_inner();

    let write_data = random_buf(256, Case::Upper);
    let block_list =
        expect!(data_store.write_block(file_id, 128, block_list, write_data.as_slice().into(),))
            .to(be_ok())
            .into_inner()
            .into_iter()
            .collect::<Vec<_>>();

    // Expect: [hole(128), data(256), hole(640)].
    expect!(&block_list).to(have_len(3));

    expect!(block_list).to(match_elements([
        match_fields(fields!(Block {
            signature: equal(BlockSignature::Hole { len: 128 }),
        })),
        match_fields(fields!(Block {
            signature: equal(BlockSignature::Data {
                hash: BlockHasher::hash(&write_data),
                len: 256,
            }),
        })),
        match_fields(fields!(Block {
            signature: equal(BlockSignature::Hole { len: 640 }),
        })),
    ]));
}

#[cfg(test)]
mod small_write_threshold {
    use super::*;

    #[test]
    fn small_write_creates_fragments() {
        let mut block_store = MemoryBlockStore::new();
        let file_id = FileId::from(1);

        let original_data = random_string(8, Case::Lower);
        expect!(block_store.insert_block(file_id, 0, original_data.as_bytes().into())).to(be_ok());

        let mut data_store =
            ChunkingBlockStoreAdapter::with_small_write_threshold(block_store, 100);

        let block_list = expect!(data_store.list_blocks(file_id))
            .to(be_ok())
            .into_inner();

        let write_data = random_string(4, Case::Upper);
        let block_list =
            expect!(data_store.write_block(file_id, 2, block_list, write_data.as_bytes().into()))
                .to(be_ok())
                .into_inner()
                .into_iter()
                .collect::<Vec<_>>();

        // Should create 3 blocks:
        // 1. Fragment (2 bytes)
        // 2. New data (4 bytes)
        // 3. Fragment (2 bytes)
        expect!(&block_list).to(have_len(3));

        expect!(block_list)
            .iter_map(|block| block.signature)
            .to(match_elements([have_len(2), have_len(4), have_len(2)]));
    }

    #[test]
    fn large_write_rechunks() {
        let mut block_store = MemoryBlockStore::new();
        let file_id = FileId::from(1);

        let original_data = random_string(8, Case::Lower);
        expect!(block_store.insert_block(file_id, 0, original_data.as_bytes().into())).to(be_ok());

        let mut data_store = ChunkingBlockStoreAdapter::with_small_write_threshold(block_store, 2);

        let block_list = expect!(data_store.list_blocks(file_id))
            .to(be_ok())
            .into_inner();

        // This is above the small write threshold.
        let write_data = random_string(4, Case::Upper);

        let block_list =
            expect!(data_store.write_block(file_id, 2, block_list, write_data.as_bytes().into()))
                .to(be_ok())
                .into_inner()
                .into_iter()
                .collect::<Vec<_>>();

        // Because we're using a nop chunker in these tests, rechunking should produce a single
        // block.
        expect!(block_list).to(have_len(1));
    }

    #[test]
    fn write_at_threshold_boundary_is_small() {
        let mut block_store = MemoryBlockStore::new();
        let file_id = FileId::from(1);

        let original_data = random_string(8, Case::Lower);
        expect!(block_store.insert_block(file_id, 0, original_data.as_bytes().into())).to(be_ok());

        let mut data_store = ChunkingBlockStoreAdapter::with_small_write_threshold(block_store, 5);

        let block_list = expect!(data_store.list_blocks(file_id))
            .to(be_ok())
            .into_inner();

        // This should use the small write path.
        let write_data = random_string(4, Case::Upper);
        let block_list =
            expect!(data_store.write_block(file_id, 2, block_list, write_data.as_bytes().into()))
                .to(be_ok())
                .into_inner()
                .into_iter()
                .collect::<Vec<_>>();

        expect!(&block_list).to(have_len(3));
        expect!(block_list.get(1))
            .to(be_some())
            .map(|block| &block.signature)
            .to(have_len(4));
    }

    #[test]
    fn write_above_threshold_is_large() {
        let mut block_store = MemoryBlockStore::new();
        let file_id = FileId::from(1);

        let original_data = random_string(8, Case::Lower);
        expect!(block_store.insert_block(file_id, 0, original_data.as_bytes().into())).to(be_ok());

        let mut data_store = ChunkingBlockStoreAdapter::with_small_write_threshold(block_store, 4);

        let block_list = expect!(data_store.list_blocks(file_id))
            .to(be_ok())
            .into_inner();

        let write_data = random_string(5, Case::Upper);
        let block_list =
            expect!(data_store.write_block(file_id, 1, block_list, write_data.as_bytes().into()))
                .to(be_ok())
                .into_inner();

        // Because we're using a nop chunker in these tests, rechunking should produce a single
        // block.
        expect!(block_list).to(have_len(1));
    }

    #[test]
    fn small_write_fragment_before_only() {
        let mut block_store = MemoryBlockStore::new();
        let file_id = FileId::from(1);

        let original_data = random_string(8, Case::Lower);
        expect!(block_store.insert_block(file_id, 0, original_data.as_bytes().into())).to(be_ok());

        let mut data_store =
            ChunkingBlockStoreAdapter::with_small_write_threshold(block_store, 100);

        let block_list = expect!(data_store.list_blocks(file_id))
            .to(be_ok())
            .into_inner();

        let write_data = random_string(4, Case::Upper);
        let block_list =
            expect!(data_store.write_block(file_id, 4, block_list, write_data.as_bytes().into()))
                .to(be_ok())
                .into_inner()
                .into_iter()
                .collect::<Vec<_>>();

        // Should create 2 blocks:
        // 1. Fragment (4 bytes)
        // 2. New data (4 bytes)
        expect!(&block_list).to(have_len(2));
        expect!(block_list)
            .iter_map(|block| block.signature)
            .to(match_elements([have_len(4), have_len(4)]));
    }

    #[test]
    fn small_write_fragment_after_only() {
        let mut block_store = MemoryBlockStore::new();
        let file_id = FileId::from(1);

        let original_data = random_string(8, Case::Lower);
        expect!(block_store.insert_block(file_id, 0, original_data.as_bytes().into())).to(be_ok());

        let mut data_store =
            ChunkingBlockStoreAdapter::with_small_write_threshold(block_store, 100);

        let block_list = expect!(data_store.list_blocks(file_id))
            .to(be_ok())
            .into_inner();

        let write_data = random_string(4, Case::Upper);
        let block_list =
            expect!(data_store.write_block(file_id, 0, block_list, write_data.as_bytes().into()))
                .to(be_ok())
                .into_inner()
                .into_iter()
                .collect::<Vec<_>>();

        // 1. New data (4 bytes)
        // 2. Fragment (4 bytes)
        expect!(&block_list).to(have_len(2));
        expect!(block_list)
            .iter_map(|block| block.signature)
            .to(match_elements([have_len(4), have_len(4)]));
    }

    #[test]
    fn small_write_no_fragments_full_block() {
        let mut block_store = MemoryBlockStore::new();
        let file_id = FileId::from(1);

        let original_data = random_string(8, Case::Lower);
        expect!(block_store.insert_block(file_id, 0, original_data.as_bytes().into())).to(be_ok());

        let mut data_store =
            ChunkingBlockStoreAdapter::with_small_write_threshold(block_store, 100);

        let block_list = expect!(data_store.list_blocks(file_id))
            .to(be_ok())
            .into_inner();

        // Overwrite the entire block.
        let write_data = random_string(8, Case::Upper);
        let block_list =
            expect!(data_store.write_block(file_id, 0, block_list, write_data.as_bytes().into()))
                .to(be_ok())
                .into_inner()
                .into_iter()
                .collect::<Vec<_>>();

        expect!(&block_list).to(have_len(1));
        expect!(block_list)
            .iter_map(|block| block.signature)
            .to(match_elements([have_len(8)]));
    }

    #[test]
    fn small_write_spanning_multiple_blocks() {
        let mut block_store = MemoryBlockStore::new();
        let file_id = FileId::from(1);

        for i in 0..3 {
            let data = random_string(8, Case::Lower);
            expect!(block_store.insert_block(file_id, i, data.as_bytes().into())).to(be_ok());
        }

        let mut data_store =
            ChunkingBlockStoreAdapter::with_small_write_threshold(block_store, 100);

        let block_list = expect!(data_store.list_blocks(file_id))
            .to(be_ok())
            .into_inner();

        // Write splits the first block and overwrites the second.
        let write_data = random_string(10, Case::Upper);
        let block_list =
            expect!(data_store.write_block(file_id, 6, block_list, write_data.as_bytes().into()))
                .to(be_ok())
                .into_inner()
                .into_iter()
                .collect::<Vec<_>>();

        // Should create:
        // - Fragment from first block (6 bytes)
        // - New data (10 bytes)
        // - Fragment from third block (8 bytes)
        expect!(&block_list).to(have_len(3));
        expect!(block_list)
            .iter_map(|block| block.signature)
            .to(match_elements([have_len(6), have_len(10), have_len(8)]));
    }

    #[test]
    fn zero_threshold_always_rechunks() {
        let mut block_store = MemoryBlockStore::new();
        let file_id = FileId::from(1);

        let original_data = random_string(8, Case::Lower);
        expect!(block_store.insert_block(file_id, 0, original_data.as_bytes().into())).to(be_ok());

        // Threshold of zero means all writes use the large write path.
        let mut data_store = ChunkingBlockStoreAdapter::with_small_write_threshold(block_store, 0);

        let block_list = expect!(data_store.list_blocks(file_id))
            .to(be_ok())
            .into_inner();

        // Write 1 byte (smallest possible write).
        let write_data = random_string(1, Case::Upper);
        expect!(data_store.write_block(file_id, 3, block_list, write_data.as_bytes().into()))
            .to(be_ok())
            .to(have_len(1));
    }

    #[test]
    fn threshold_comparison_is_strict_less_than() {
        let mut block_store = MemoryBlockStore::new();
        let file_id = FileId::from(1);

        for i in 0..3 {
            let data = random_string(TEST_BLOCK_SIZE, Case::Lower);
            expect!(block_store.insert_block(file_id, i, data.as_bytes().into())).to(be_ok());
        }

        let mut data_store = ChunkingBlockStoreAdapter::with_small_write_threshold(block_store, 10);

        let block_list = expect!(data_store.list_blocks(file_id))
            .to(be_ok())
            .into_inner();

        // This should use the small write path.
        let write_data = random_string(9, Case::Upper);
        let block_list_9 =
            expect!(data_store.write_block(file_id, 5, block_list, write_data.as_bytes().into()))
                .to(be_ok())
                .into_inner()
                .into_iter()
                .collect::<Vec<_>>();

        // Should create 4 blocks:
        // 1. Fragment (5 bytes)
        // 2. New data (9 bytes)
        // 3. Fragment (2 bytes)
        // 4. Unchanged block (8 bytes)
        expect!(&block_list_9).to(have_len(4));
        expect!(block_list_9)
            .iter_map(|block| block.signature)
            .to(match_elements([
                have_len(5),
                have_len(9),
                have_len(2),
                have_len(8),
            ]));
    }

    #[test]
    fn small_write_preserves_surrounding_data() {
        let mut block_store = MemoryBlockStore::new();
        let file_id = FileId::from(1);

        let original_data = b"abcdefgh";
        expect!(block_store.insert_block(file_id, 0, original_data.as_slice().into())).to(be_ok());

        let mut data_store =
            ChunkingBlockStoreAdapter::with_small_write_threshold(block_store, 100);

        let block_list = expect!(data_store.list_blocks(file_id))
            .to(be_ok())
            .into_inner();

        let write_data = b"XX";
        expect!(data_store.write_block(file_id, 3, block_list, write_data.as_slice().into()))
            .to(be_ok());

        let block_list = expect!(data_store.list_blocks(file_id))
            .to(be_ok())
            .into_inner();

        let mut result = Vec::new();
        for block in block_list.iter() {
            BlockStore::read_block(&mut data_store, block.id, &mut result).ok();
        }

        expect!(result).to(equal(b"abcXXfgh".to_vec()));
    }

    #[test]
    fn small_write_fragment_data_matches_original() {
        let mut block_store = MemoryBlockStore::new();
        let file_id = FileId::from(1);

        let original_data = b"abcdefgh";
        expect!(block_store.insert_block(file_id, 0, original_data.as_slice().into())).to(be_ok());

        let mut data_store =
            ChunkingBlockStoreAdapter::with_small_write_threshold(block_store, 100);

        let block_list = expect!(data_store.list_blocks(file_id))
            .to(be_ok())
            .into_inner();

        let write_data = b"XX";
        let block_list =
            expect!(data_store.write_block(file_id, 3, block_list, write_data.as_slice().into()))
                .to(be_ok())
                .into_inner()
                .into_iter()
                .collect::<Vec<_>>();

        let first_block_id = expect!(block_list.get(0))
            .to(be_some())
            .map(|block| block.id)
            .into_inner();

        let mut fragment_before = Vec::new();
        BlockStore::read_block(&mut data_store, first_block_id, &mut fragment_before).ok();
        expect!(fragment_before).to(equal(b"abc".to_vec()));

        let last_block_id = expect!(block_list.get(2))
            .to(be_some())
            .map(|block| block.id)
            .into_inner();

        let mut fragment_after = Vec::new();
        BlockStore::read_block(&mut data_store, last_block_id, &mut fragment_after).ok();
        expect!(fragment_after).to(equal(b"fgh".to_vec()));
    }

    #[test]
    fn large_write_data_integrity() {
        let mut block_store = MemoryBlockStore::new();
        let file_id = FileId::from(1);

        let original_data = b"abcdefgh";
        expect!(block_store.insert_block(file_id, 0, original_data.as_slice().into())).to(be_ok());

        let mut data_store = ChunkingBlockStoreAdapter::with_small_write_threshold(block_store, 2);

        let block_list = expect!(data_store.list_blocks(file_id))
            .to(be_ok())
            .into_inner();

        // This is above the small write threshold.
        let write_data = b"XXXX";
        expect!(data_store.write_block(file_id, 2, block_list, write_data.as_slice().into()))
            .to(be_ok());

        let block_list = expect!(data_store.list_blocks(file_id))
            .to(be_ok())
            .into_inner();

        let mut result = Vec::new();
        for block in block_list.iter() {
            BlockStore::read_block(&mut data_store, block.id, &mut result).ok();
        }

        expect!(result).to(equal(b"abXXXXgh".to_vec()));
    }

    #[test]
    fn small_write_at_file_start() {
        let mut block_store = MemoryBlockStore::new();
        let file_id = FileId::from(1);

        let original_data = random_string(8, Case::Lower);
        expect!(block_store.insert_block(file_id, 0, original_data.as_bytes().into())).to(be_ok());

        let mut data_store =
            ChunkingBlockStoreAdapter::with_small_write_threshold(block_store, 100);

        let block_list = expect!(data_store.list_blocks(file_id))
            .to(be_ok())
            .into_inner();

        let write_data = random_string(3, Case::Upper);
        let block_list =
            expect!(data_store.write_block(file_id, 0, block_list, write_data.as_bytes().into()))
                .to(be_ok())
                .into_inner()
                .into_iter()
                .collect::<Vec<_>>();

        // 1. New data (3 bytes)
        // 2. Fragment (5 bytes)
        expect!(&block_list).to(have_len(2));
        expect!(block_list)
            .iter_map(|block| block.signature)
            .to(match_elements([have_len(3), have_len(5)]));
    }

    #[test]
    fn small_write_at_file_end() {
        let mut block_store = MemoryBlockStore::new();
        let file_id = FileId::from(1);

        let original_data = random_string(8, Case::Lower);
        expect!(block_store.insert_block(file_id, 0, original_data.as_bytes().into())).to(be_ok());

        let mut data_store =
            ChunkingBlockStoreAdapter::with_small_write_threshold(block_store, 100);

        let block_list = expect!(data_store.list_blocks(file_id))
            .to(be_ok())
            .into_inner();

        let write_data = random_string(3, Case::Upper);
        let block_list =
            expect!(data_store.write_block(file_id, 5, block_list, write_data.as_bytes().into()))
                .to(be_ok())
                .into_inner()
                .into_iter()
                .collect::<Vec<_>>();

        // 1. Fragment (5 bytes)
        // 2. New data (3 bytes)
        expect!(&block_list).to(have_len(2));
        expect!(block_list)
            .iter_map(|block| block.signature)
            .to(match_elements([have_len(5), have_len(3)]));
    }

    #[test]
    fn small_write_beyond_file_end_appends() {
        let mut block_store = MemoryBlockStore::new();
        let file_id = FileId::from(1);

        let original_data = random_string(8, Case::Lower);
        expect!(block_store.insert_block(file_id, 0, original_data.as_bytes().into())).to(be_ok());

        let mut data_store =
            ChunkingBlockStoreAdapter::with_small_write_threshold(block_store, 100);

        let block_list = expect!(data_store.list_blocks(file_id))
            .to(be_ok())
            .into_inner();

        // Append at offset 8.
        let write_data = random_string(4, Case::Upper);
        expect!(data_store.write_block(file_id, 8, block_list, write_data.as_bytes().into()))
            .to(be_ok())
            .to(have_len(2));
    }

    #[test]
    fn small_write_single_byte() {
        let mut block_store = MemoryBlockStore::new();
        let file_id = FileId::from(1);

        let original_data = random_string(8, Case::Lower);
        expect!(block_store.insert_block(file_id, 0, original_data.as_bytes().into())).to(be_ok());

        let mut data_store =
            ChunkingBlockStoreAdapter::with_small_write_threshold(block_store, 100);

        let block_list = expect!(data_store.list_blocks(file_id))
            .to(be_ok())
            .into_inner();

        let write_data = random_string(1, Case::Upper);
        let block_list =
            expect!(data_store.write_block(file_id, 4, block_list, write_data.as_bytes().into()))
                .to(be_ok())
                .into_inner()
                .into_iter()
                .collect::<Vec<_>>();

        // 1. Fragment (4 bytes)
        // 2. New data (1 byte)
        // 3. Fragment (3 bytes)
        expect!(&block_list).to(have_len(3));
        expect!(block_list)
            .iter_map(|block| block.signature)
            .to(match_elements([have_len(4), have_len(1), have_len(3)]));
    }

    #[test]
    fn small_writes_increase_block_count() {
        let mut block_store = MemoryBlockStore::new();
        let file_id = FileId::from(1);

        let original_data = random_string(8, Case::Lower);
        expect!(block_store.insert_block(file_id, 0, original_data.as_bytes().into())).to(be_ok());

        let mut data_store =
            ChunkingBlockStoreAdapter::with_small_write_threshold(block_store, 100);

        let block_list = expect!(data_store.list_blocks(file_id))
            .to(be_ok())
            .into_inner();

        expect!(data_store.list_blocks(file_id))
            .to(be_ok())
            .to(have_len(1));

        let write_data = random_string(2, Case::Upper);
        expect!(data_store.write_block(file_id, 3, block_list, write_data.as_bytes().into()))
            .to(be_ok());

        // 1. Fragment (3 bytes)
        // 2. New data (2 bytes)
        // 3. Fragment (3 bytes)
        expect!(data_store.list_blocks(file_id))
            .to(be_ok())
            .to(have_len(3));
    }

    #[test]
    fn large_writes_maintain_or_reduce_block_count() {
        let mut block_store = MemoryBlockStore::new();
        let file_id = FileId::from(1);

        for i in 0..3 {
            let data = random_string(TEST_BLOCK_SIZE, Case::Lower);
            expect!(block_store.insert_block(file_id, i, data.as_bytes().into())).to(be_ok());
        }

        let mut data_store = ChunkingBlockStoreAdapter::with_small_write_threshold(block_store, 2);

        let block_list = expect!(data_store.list_blocks(file_id))
            .to(be_ok())
            .into_inner();

        let initial_count = expect!(data_store.list_blocks(file_id))
            .to(be_ok())
            .to(have_len(3))
            .into_inner()
            .len();

        // This is above the small write threshold.
        let write_data = random_string(10, Case::Upper);
        expect!(data_store.write_block(file_id, 5, block_list, write_data.as_bytes().into()))
            .to(be_ok());

        // Rechunking consolidates blocks.
        let final_count = expect!(data_store.list_blocks(file_id))
            .to(be_ok())
            .into_inner()
            .len();

        expect!(final_count <= initial_count).to(equal(true));
    }

    #[test]
    fn repeated_small_writes_accumulate_fragments() {
        let mut block_store = MemoryBlockStore::new();
        let file_id = FileId::from(1);

        let original_data = random_string(8, Case::Lower);
        expect!(block_store.insert_block(file_id, 0, original_data.as_bytes().into())).to(be_ok());

        let mut data_store =
            ChunkingBlockStoreAdapter::with_small_write_threshold(block_store, 100);

        let mut block_list = expect!(data_store.list_blocks(file_id))
            .to(be_ok())
            .into_inner();

        expect!(data_store.list_blocks(file_id))
            .to(be_ok())
            .to(have_len(1));

        block_list = expect!(data_store.write_block(
            file_id,
            1,
            block_list,
            random_string(1, Case::Upper).as_bytes().into()
        ))
        .to(be_ok())
        .into_inner();

        block_list = expect!(data_store.write_block(
            file_id,
            3,
            block_list,
            random_string(1, Case::Upper).as_bytes().into()
        ))
        .to(be_ok())
        .into_inner();

        expect!(data_store.write_block(
            file_id,
            5,
            block_list,
            random_string(1, Case::Upper).as_bytes().into()
        ))
        .to(be_ok());

        // Fragments accumulate with each small write.
        expect!(data_store.list_blocks(file_id))
            .to(be_ok())
            .to(have_len(7));
    }

    #[test]
    fn small_write_multi_block_no_start_fragment() {
        // Tests the PartialSliceBuf::splice multi-block path where the write starts at a block
        // boundary (has_start_fragment=false, has_end_fragment=true).
        let mut block_store = MemoryBlockStore::new();
        let file_id = FileId::from(1);

        // Create 3 blocks of 8 bytes each.
        for i in 0..3 {
            let data = random_string(8, Case::Lower);
            expect!(block_store.insert_block(file_id, i, data.as_bytes().into())).to(be_ok());
        }

        let mut data_store =
            ChunkingBlockStoreAdapter::with_small_write_threshold(block_store, 100);

        let block_list = expect!(data_store.list_blocks(file_id))
            .to(be_ok())
            .into_inner();

        // Write at offset 8 (block boundary) with length 10, spanning into block 2.
        // This creates BlockBoundaryToMidDifferentBlock with:
        // - start at block 1, offset 0 (no start fragment)
        // - end at block 2, offset 2 (has end fragment of 6 bytes)
        let write_data = random_string(10, Case::Upper);
        let block_list =
            expect!(data_store.write_block(file_id, 8, block_list, write_data.as_bytes().into()))
                .to(be_ok())
                .into_inner()
                .into_iter()
                .collect::<Vec<_>>();

        // Should create:
        // - Block 0: unchanged (8 bytes)
        // - Block 1: new data (10 bytes)
        // - Block 2: end fragment (6 bytes)
        expect!(&block_list).to(have_len(3));
        expect!(block_list)
            .iter_map(|block| block.signature)
            .to(match_elements([have_len(8), have_len(10), have_len(6)]));
    }

    #[test]
    fn small_write_multi_block_no_fragments() {
        // Tests the PartialSliceBuf::splice multi-block path where the write starts and ends at
        // block boundaries (has_start_fragment=false, has_end_fragment=false).
        let mut block_store = MemoryBlockStore::new();
        let file_id = FileId::from(1);

        // Create 4 blocks of 8 bytes each.
        for i in 0..4 {
            let data = random_string(8, Case::Lower);
            expect!(block_store.insert_block(file_id, i, data.as_bytes().into())).to(be_ok());
        }

        let mut data_store =
            ChunkingBlockStoreAdapter::with_small_write_threshold(block_store, 100);

        let block_list = expect!(data_store.list_blocks(file_id))
            .to(be_ok())
            .into_inner();

        // Write at offset 8 (block boundary) with length 16 (two full blocks).
        // This creates BlockBoundaryToBlockBoundary with:
        // - start at block 1, offset 0 (no start fragment)
        // - end at block 2, offset 8 (no end fragment, ends at block boundary)
        let write_data = random_string(16, Case::Upper);
        let block_list =
            expect!(data_store.write_block(file_id, 8, block_list, write_data.as_bytes().into()))
                .to(be_ok())
                .into_inner()
                .into_iter()
                .collect::<Vec<_>>();

        // Should create:
        // - Block 0: unchanged (8 bytes)
        // - Block 1: new data (16 bytes)
        // - Block 2: unchanged (8 bytes)
        expect!(&block_list).to(have_len(3));
        expect!(block_list)
            .iter_map(|block| block.signature)
            .to(match_elements([have_len(8), have_len(16), have_len(8)]));
    }

    #[test]
    fn small_write_multi_block_both_fragments() {
        // Tests the PartialSliceBuf::splice multi-block path where the write has both start and
        // end fragments (has_start_fragment=true, has_end_fragment=true).
        let mut block_store = MemoryBlockStore::new();
        let file_id = FileId::from(1);

        // Create 3 blocks of 8 bytes each.
        for i in 0..3 {
            let data = random_string(8, Case::Lower);
            expect!(block_store.insert_block(file_id, i, data.as_bytes().into())).to(be_ok());
        }

        let mut data_store =
            ChunkingBlockStoreAdapter::with_small_write_threshold(block_store, 100);

        let block_list = expect!(data_store.list_blocks(file_id))
            .to(be_ok())
            .into_inner();

        // Write at offset 4 with length 8, spanning blocks 0 and 1.
        // This creates MidBlockToMidDifferentBlock with:
        // - start at block 0, offset 4 (has start fragment of 4 bytes)
        // - end at block 1, offset 4 (has end fragment of 4 bytes)
        let write_data = random_string(8, Case::Upper);
        let block_list =
            expect!(data_store.write_block(file_id, 4, block_list, write_data.as_bytes().into()))
                .to(be_ok())
                .into_inner()
                .into_iter()
                .collect::<Vec<_>>();

        // Should create:
        // - Block 0: start fragment (4 bytes)
        // - Block 1: new data (8 bytes)
        // - Block 2: end fragment (4 bytes)
        // - Block 3: unchanged (8 bytes)
        expect!(&block_list).to(have_len(4));
        expect!(block_list)
            .iter_map(|block| block.signature)
            .to(match_elements([
                have_len(4),
                have_len(8),
                have_len(4),
                have_len(8),
            ]));
    }

    #[test]
    fn small_write_multi_block_preserves_data() {
        // Verifies that the actual data content is correct after a multi-block small write with
        // no start fragment.
        let mut block_store = MemoryBlockStore::new();
        let file_id = FileId::from(1);

        expect!(block_store.insert_block(file_id, 0, b"AAAAAAAA".as_slice().into())).to(be_ok());
        expect!(block_store.insert_block(file_id, 1, b"BBBBBBBB".as_slice().into())).to(be_ok());
        expect!(block_store.insert_block(file_id, 2, b"CCCCCCCC".as_slice().into())).to(be_ok());

        let mut data_store =
            ChunkingBlockStoreAdapter::with_small_write_threshold(block_store, 100);

        let block_list = expect!(data_store.list_blocks(file_id))
            .to(be_ok())
            .into_inner();

        // Write "XXXXXXXXXX" at offset 8 (start of block 1), spanning 10 bytes into block 2.
        expect!(data_store.write_block(file_id, 8, block_list, b"XXXXXXXXXX".as_slice().into()))
            .to(be_ok());

        let block_list = expect!(data_store.list_blocks(file_id))
            .to(be_ok())
            .into_inner();

        let mut result = Vec::new();
        for block in block_list.iter() {
            BlockStore::read_block(&mut data_store, block.id, &mut result).ok();
        }

        // Expected: AAAAAAAA + XXXXXXXXXX + CCCCCC
        expect!(result).to(equal(b"AAAAAAAAXXXXXXXXXXCCCCCC".to_vec()));
    }
}