use crate::error::Error;
use crate::AsyncFile;
use nagoya::io::SeekFrom;
use rkyv::api::high::HighDeserializer;
use rkyv::Archive;
use super::SpaceInfoPage;
use crate::page::header::GeneralHeader;
use crate::page::ty::PageType;
use crate::page::PageId;
use crate::{DataPage, GeneralPage, Link, Persistable, GENERAL_HEADER_SIZE};
#[derive(Debug)]
pub struct PageOverflowError {
pub page_id: PageId,
pub data_length: usize,
pub capacity: usize,
}
impl std::fmt::Display for PageOverflowError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(
f,
"page {} write needs {} bytes, exceeding the {}-byte page slot",
self.page_id, self.data_length, self.capacity
)
}
}
impl std::error::Error for PageOverflowError {}
pub fn map_data_pages_to_general<const DATA_LENGTH: usize>(
pages: Vec<DataPage<DATA_LENGTH>>,
) -> Vec<GeneralPage<DataPage<DATA_LENGTH>>> {
let header = &mut GeneralHeader::new(1.into(), PageType::Data, 0.into());
let mut general_pages = vec![];
let mut pages = pages.into_iter();
if let Some(p) = pages.next() {
let general = GeneralPage {
header: *header,
inner: p,
};
general_pages.push(general);
}
let mut previous_header = header;
for p in pages {
let general = GeneralPage {
header: previous_header.follow_with(PageType::Data),
inner: p,
};
general_pages.push(general);
previous_header = &mut general_pages.last_mut().unwrap().header;
}
general_pages
}
pub async fn persist_page<'a, T, const STRIDE: u32>(
page: &'a mut GeneralPage<T>,
file: &'a mut impl AsyncFile,
) -> crate::error::Result<()>
where
T: Persistable + Send + Sync,
{
seek_to_page_start::<STRIDE>(file, page.header.page_id.0).await?;
let written = persist_page_in_place::<T, STRIDE>(page, file).await?;
let stride = STRIDE as usize;
let padding = stride.checked_sub(written).ok_or(Error::PageOverflow {
page: page.header.page_id,
needed: written,
capacity: stride,
})?;
if padding > 0 {
file.seek(SeekFrom::Current(padding as i64)).await?;
}
Ok(())
}
async fn persist_page_in_place<'a, T, const STRIDE: u32>(
page: &'a mut GeneralPage<T>,
file: &'a mut impl AsyncFile,
) -> crate::error::Result<usize>
where
T: Persistable + Send + Sync,
{
let inner_bytes = page.inner.as_bytes();
let inner_length = inner_bytes.as_ref().len();
let capacity = STRIDE as usize - GENERAL_HEADER_SIZE;
if inner_length > capacity {
return Err(Error::PageOverflow {
page: page.header.page_id,
needed: inner_length,
capacity,
});
}
page.header.data_length = inner_length as u32;
let header_bytes = page.header.as_bytes();
let header_length = header_bytes.as_ref().len();
file.write_all(header_bytes.as_ref()).await?;
file.write_all(inner_bytes.as_ref()).await?;
Ok(header_length + inner_length)
}
pub async fn persist_pages_batch<T, const STRIDE: u32>(
pages: Vec<GeneralPage<T>>,
file: &mut impl AsyncFile,
) -> crate::error::Result<()>
where
T: Persistable + Send + Sync,
{
const MAX_RUN_PAGES: u32 = 512;
let mut iter = pages.into_iter().peekable();
let mut buffer: Vec<u8> = Vec::new();
let mut run_start: Option<u32> = None;
let mut expected_next: u32 = 0;
while let Some(mut page) = iter.next() {
let id = page.header.page_id.0;
let breaks_run = run_start.is_some() && id != expected_next;
if breaks_run {
flush_run::<STRIDE>(file, run_start.take(), &mut buffer).await?;
}
if run_start.is_none() {
run_start = Some(id);
}
let start = run_start.expect("just set");
let offset_in_run = (id - start) as usize * STRIDE as usize;
buffer.resize(offset_in_run, 0);
persist_page_in_place_to::<T, STRIDE>(&mut page, &mut buffer)?;
expected_next = id.checked_add(1).ok_or(Error::Corrupt {
what: "page id overflowed while batching",
})?;
let run_is_long = id - start + 1 >= MAX_RUN_PAGES;
if iter.peek().is_none() || run_is_long {
flush_run::<STRIDE>(file, run_start.take(), &mut buffer).await?;
}
}
Ok(())
}
async fn flush_run<const STRIDE: u32>(
file: &mut impl AsyncFile,
run_start: Option<u32>,
buffer: &mut Vec<u8>,
) -> crate::error::Result<()> {
if let Some(start) = run_start {
if !buffer.is_empty() {
file.seek(SeekFrom::Start(page_start_offset::<STRIDE>(start)))
.await?;
file.write_all(buffer).await?;
}
}
buffer.clear();
Ok(())
}
fn persist_page_in_place_to<T, const STRIDE: u32>(
page: &mut GeneralPage<T>,
out: &mut Vec<u8>,
) -> crate::error::Result<usize>
where
T: Persistable + Send + Sync,
{
let inner_bytes = page.inner.as_bytes();
let inner_length = inner_bytes.as_ref().len();
let capacity = STRIDE as usize - GENERAL_HEADER_SIZE;
if inner_length > capacity {
return Err(Error::PageOverflow {
page: page.header.page_id,
needed: inner_length,
capacity,
});
}
page.header.data_length = inner_length as u32;
let header_bytes = page.header.as_bytes();
let header_length = header_bytes.as_ref().len();
out.extend_from_slice(header_bytes.as_ref());
out.extend_from_slice(inner_bytes.as_ref());
Ok(header_length + inner_length)
}
pub(crate) fn page_start_offset<const STRIDE: u32>(index: u32) -> u64 {
index as u64 * u64::from(STRIDE)
}
pub async fn seek_to_page_start<const STRIDE: u32>(
file: &mut impl AsyncFile,
index: u32,
) -> crate::error::Result<()> {
file.seek(SeekFrom::Start(page_start_offset::<STRIDE>(index)))
.await?;
Ok(())
}
pub async fn seek_by_link<const STRIDE: u32>(
file: &mut impl AsyncFile,
link: Link,
) -> crate::error::Result<()> {
file.seek(SeekFrom::Start(
page_start_offset::<STRIDE>(link.page_id.0)
+ GENERAL_HEADER_SIZE as u64
+ link.offset as u64,
))
.await?;
Ok(())
}
pub async fn update_at<const DATA_LENGTH: u32, const STRIDE: u32>(
file: &mut impl AsyncFile,
link: Link,
new_data: &[u8],
) -> crate::error::Result<()> {
if new_data.len() as u32 != link.length {
return Err(Error::LinkLengthMismatch {
expected: link.length,
found: new_data.len(),
});
}
if link.offset as u64 + link.length as u64 > DATA_LENGTH as u64 {
return Err(Error::LinkOutOfBounds {
offset: link.offset,
length: link.length,
capacity: DATA_LENGTH as usize,
});
}
seek_by_link::<STRIDE>(file, link).await?;
file.write_all(new_data).await?;
Ok(())
}
pub async fn parse_general_header(
file: &mut impl AsyncFile,
) -> crate::error::Result<GeneralHeader> {
let mut buffer = [0; GENERAL_HEADER_SIZE];
file.read_exact(&mut buffer).await?;
let archived = crate::access_archived::<<GeneralHeader as Archive>::Archived>(&buffer[..])
.map_err(|_| Error::Corrupt {
what: "page header",
})?;
let header =
rkyv::deserialize::<_, rkyv::rancor::Error>(archived).map_err(|_| Error::Corrupt {
what: "page header",
})?;
Ok(header)
}
pub async fn parse_page<Page, const INNER_PAGE_SIZE: u32, const STRIDE: u32>(
file: &mut impl AsyncFile,
index: u32,
) -> crate::error::Result<GeneralPage<Page>>
where
Page: rkyv::Archive + Persistable,
<Page as rkyv::Archive>::Archived:
rkyv::Deserialize<Page, HighDeserializer<rkyv::rancor::Error>>,
{
seek_to_page_start::<STRIDE>(file, index).await?;
parse_page_in_place::<Page, INNER_PAGE_SIZE>(file).await
}
async fn parse_page_in_place<Page, const INNER_PAGE_SIZE: u32>(
file: &mut impl AsyncFile,
) -> crate::error::Result<GeneralPage<Page>>
where
Page: rkyv::Archive + Persistable,
<Page as rkyv::Archive>::Archived:
rkyv::Deserialize<Page, HighDeserializer<rkyv::rancor::Error>>,
{
let header = parse_general_header(file).await?;
let length = if header.data_length == 0 {
INNER_PAGE_SIZE
} else {
header.data_length
};
let mut buffer: Vec<u8> = vec![0u8; length as usize];
file.read_exact(&mut buffer).await?;
let info = Page::from_bytes(buffer.as_ref(), header.data_version);
Ok(GeneralPage {
header,
inner: info,
})
}
pub async fn parse_pages_batch<Page, const PAGE_SIZE: u32, const STRIDE: u32>(
file: &mut impl AsyncFile,
indexes: Vec<u32>,
) -> crate::error::Result<Vec<GeneralPage<Page>>>
where
Page: rkyv::Archive + Persistable,
<Page as rkyv::Archive>::Archived:
rkyv::Deserialize<Page, HighDeserializer<rkyv::rancor::Error>>,
{
let mut iter = indexes.into_iter();
if let Some(index) = iter.next() {
let mut pages = vec![];
seek_to_page_start::<STRIDE>(file, index).await?;
let page = parse_page_in_place::<Page, PAGE_SIZE>(file).await?;
pages.push(page);
for index in iter {
seek_to_page_start::<STRIDE>(file, index).await?;
let page = parse_page_in_place::<Page, PAGE_SIZE>(file).await?;
pages.push(page);
}
Ok(pages)
} else {
Ok(vec![])
}
}
pub async fn parse_general_header_by_index<const STRIDE: u32>(
file: &mut impl AsyncFile,
index: u32,
) -> crate::error::Result<GeneralHeader> {
seek_to_page_start::<STRIDE>(file, index).await?;
let header = parse_general_header(file).await?;
Ok(header)
}
pub async fn parse_data_page<
const PAGE_SIZE: u32,
const INNER_PAGE_SIZE: usize,
const STRIDE: u32,
>(
file: &mut impl AsyncFile,
index: u32,
) -> crate::error::Result<GeneralPage<DataPage<INNER_PAGE_SIZE>>> {
seek_to_page_start::<STRIDE>(file, index).await?;
parse_data_page_in_place::<PAGE_SIZE, INNER_PAGE_SIZE>(file).await
}
async fn parse_data_page_in_place<const PAGE_SIZE: u32, const INNER_PAGE_SIZE: usize>(
file: &mut impl AsyncFile,
) -> crate::error::Result<GeneralPage<DataPage<INNER_PAGE_SIZE>>> {
let header = parse_general_header(file).await?;
let mut buffer = [0u8; INNER_PAGE_SIZE];
if header.next_id == 0.into() {
#[allow(clippy::unused_io_amount)]
file.read(&mut buffer).await?;
} else {
file.read_exact(&mut buffer).await?;
}
let data = DataPage {
data: buffer,
length: header.data_length,
};
Ok(GeneralPage {
header,
inner: data,
})
}
pub async fn parse_data_pages_batch<
const PAGE_SIZE: u32,
const INNER_PAGE_SIZE: usize,
const STRIDE: u32,
>(
file: &mut impl AsyncFile,
indexes: Vec<u32>,
) -> crate::error::Result<Vec<GeneralPage<DataPage<INNER_PAGE_SIZE>>>> {
let mut iter = indexes.into_iter();
if let Some(index) = iter.next() {
let mut pages = vec![];
seek_to_page_start::<STRIDE>(file, index).await?;
let page = parse_data_page_in_place::<PAGE_SIZE, INNER_PAGE_SIZE>(file).await?;
pages.push(page);
for index in iter {
seek_to_page_start::<STRIDE>(file, index).await?;
let page = parse_data_page_in_place::<PAGE_SIZE, INNER_PAGE_SIZE>(file).await?;
pages.push(page);
}
Ok(pages)
} else {
Ok(vec![])
}
}
pub async fn parse_space_info<const PAGE_SIZE: usize>(
file: &mut impl AsyncFile,
) -> crate::error::Result<SpaceInfoPage> {
file.seek(SeekFrom::Start(0)).await?;
let header = parse_general_header(file).await?;
let mut buffer = vec![0u8; header.data_length as usize];
file.read_exact(&mut buffer).await?;
Ok(SpaceInfoPage::from_bytes(&buffer, header.data_version))
}
#[cfg(test)]
mod tests {
use super::{page_start_offset, parse_data_pages_batch, persist_pages_batch};
use crate::page::header::GeneralHeader;
use crate::page::ty::PageType;
use crate::{
DataPage, GeneralPage, DATA_VERSION, DEFAULT_PAGE_STRIDE, INNER_PAGE_SIZE, PAGE_SIZE,
};
use nagoya::io::File as _;
const FIRST_PAGE_PAST_4_GIB: u32 = (u32::MAX / PAGE_SIZE as u32) + 1;
#[test]
fn page_start_offset_is_computed_in_u64() {
assert_eq!(
page_start_offset::<{ PAGE_SIZE as u32 }>(FIRST_PAGE_PAST_4_GIB),
FIRST_PAGE_PAST_4_GIB as u64 * PAGE_SIZE as u64
);
assert!(page_start_offset::<{ PAGE_SIZE as u32 }>(FIRST_PAGE_PAST_4_GIB) > u32::MAX as u64);
assert_eq!(
page_start_offset::<{ PAGE_SIZE as u32 }>(u32::MAX),
u32::MAX as u64 * PAGE_SIZE as u64
);
assert_ne!(
page_start_offset::<{ PAGE_SIZE as u32 }>(FIRST_PAGE_PAST_4_GIB),
FIRST_PAGE_PAST_4_GIB.wrapping_mul(PAGE_SIZE as u32) as u64
);
}
fn data_page_with_marker(marker: &[u8]) -> DataPage<INNER_PAGE_SIZE> {
let mut data = [0u8; INNER_PAGE_SIZE];
data[..marker.len()].copy_from_slice(marker);
DataPage {
length: marker.len() as u32,
data,
}
}
async fn scratch(name: &str) -> (std::path::PathBuf, nagoya::io::HostFile) {
let path =
std::env::temp_dir().join(format!("data_bucket_{name}_{}.wt", std::process::id()));
let _ = nagoya::io::remove_file(&path).await;
let file = nagoya::io::create(&path).await.unwrap();
(path, file)
}
#[tokio::test]
async fn a_batch_writes_what_one_at_a_time_writes() {
let markers: [&[u8]; 4] = [b"alpha", b"beta", b"gamma", b"delta"];
let (one_path, mut one) = scratch("batch_one_at_a_time").await;
for (n, marker) in markers.iter().enumerate() {
let mut page = page_at::<INNER_PAGE_SIZE>(n as u32, marker);
super::persist_page::<_, DEFAULT_PAGE_STRIDE>(&mut page, &mut one)
.await
.unwrap();
}
one.sync_all().await.unwrap();
drop(one);
let (many_path, mut many) = scratch("batch_together").await;
let pages: Vec<_> = markers
.iter()
.enumerate()
.map(|(n, marker)| page_at::<INNER_PAGE_SIZE>(n as u32, marker))
.collect();
persist_pages_batch::<_, DEFAULT_PAGE_STRIDE>(pages, &mut many)
.await
.unwrap();
many.sync_all().await.unwrap();
drop(many);
let expected = std::fs::read(&one_path).unwrap();
let actual = std::fs::read(&many_path).unwrap();
assert_eq!(
expected.len(),
actual.len(),
"the batch produced a file of a different length"
);
assert_eq!(expected, actual, "the batch produced different bytes");
std::fs::remove_file(&one_path).unwrap();
std::fs::remove_file(&many_path).unwrap();
}
#[tokio::test]
async fn a_batch_with_a_gap_puts_each_page_at_its_own_offset() {
let (path, mut file) = scratch("batch_with_a_gap").await;
let pages = vec![
page_at::<INNER_PAGE_SIZE>(0, b"first"),
page_at::<INNER_PAGE_SIZE>(1, b"second"),
page_at::<INNER_PAGE_SIZE>(4, b"fifth"),
];
persist_pages_batch::<_, DEFAULT_PAGE_STRIDE>(pages, &mut file)
.await
.unwrap();
file.sync_all().await.unwrap();
drop(file);
let bytes = std::fs::read(&path).unwrap();
assert_eq!(
bytes.len(),
4 * PAGE_SIZE + crate::GENERAL_HEADER_SIZE + b"fifth".len(),
"the file is the wrong length"
);
let marker_at = |page: usize, marker: &[u8]| {
let from = page * PAGE_SIZE + crate::GENERAL_HEADER_SIZE;
assert_eq!(
&bytes[from..from + marker.len()],
marker,
"page {page} holds the wrong data"
);
};
marker_at(0, b"first");
marker_at(1, b"second");
marker_at(4, b"fifth");
let gap = 2 * PAGE_SIZE + crate::GENERAL_HEADER_SIZE;
assert!(
bytes[gap..gap + 16].iter().all(|&b| b == 0),
"the gap was written over"
);
std::fs::remove_file(&path).unwrap();
}
#[tokio::test]
async fn a_run_longer_than_the_buffer_bound_still_joins_up() {
const COUNT: u32 = 520;
let (one_path, mut one) = scratch("long_run_one_at_a_time").await;
for id in 0..COUNT {
let mut page = page_at::<INNER_PAGE_SIZE>(id, format!("page{id}").as_bytes());
super::persist_page::<_, DEFAULT_PAGE_STRIDE>(&mut page, &mut one)
.await
.unwrap();
}
one.sync_all().await.unwrap();
drop(one);
let (many_path, mut many) = scratch("long_run_batched").await;
let pages: Vec<_> = (0..COUNT)
.map(|id| page_at::<INNER_PAGE_SIZE>(id, format!("page{id}").as_bytes()))
.collect();
persist_pages_batch::<_, DEFAULT_PAGE_STRIDE>(pages, &mut many)
.await
.unwrap();
many.sync_all().await.unwrap();
drop(many);
let expected = std::fs::read(&one_path).unwrap();
let actual = std::fs::read(&many_path).unwrap();
assert_eq!(expected.len(), actual.len(), "lengths differ across a seam");
assert_eq!(expected, actual, "bytes differ across a seam");
std::fs::remove_file(&one_path).unwrap();
std::fs::remove_file(&many_path).unwrap();
}
#[tokio::test]
async fn persist_page_rejects_inner_data_past_the_page_slot() {
const OVERSIZED: usize = crate::PAGE_SIZE + 128;
let path = std::env::temp_dir().join(format!(
"data_bucket_persist_overflow_{}.wt",
std::process::id()
));
let mut file = nagoya::io::create(&path).await.unwrap();
let mut page = GeneralPage {
header: GeneralHeader {
data_version: DATA_VERSION,
space_id: 1.into(),
page_id: 1.into(),
previous_id: 0.into(),
next_id: 0.into(),
page_type: PageType::Data,
data_length: 0,
},
inner: DataPage {
length: OVERSIZED as u32,
data: [7u8; OVERSIZED],
},
};
let err = super::persist_page::<_, { PAGE_SIZE as u32 }>(&mut page, &mut file)
.await
.unwrap_err();
assert!(
matches!(err, crate::error::Error::PageOverflow { .. }),
"expected a page overflow, got: {err}"
);
assert_eq!(nagoya::io::File::length(&mut file).await.unwrap(), 0);
page.inner.length = 64;
super::persist_page::<_, { PAGE_SIZE as u32 }>(&mut page, &mut file)
.await
.unwrap();
drop(file);
std::fs::remove_file(&path).unwrap();
}
#[tokio::test]
async fn update_at_rejects_offset_plus_length_wrapping_u32() {
let path = std::env::temp_dir().join(format!(
"data_bucket_update_at_wrap_{}.wt",
std::process::id()
));
let mut file = nagoya::io::create(&path).await.unwrap();
let link = crate::Link {
page_id: 1.into(),
offset: u32::MAX - 2,
length: 8,
};
let err = super::update_at::<100, { PAGE_SIZE as u32 }>(
&mut file,
link,
&[1, 2, 3, 4, 5, 6, 7, 8],
)
.await
.unwrap_err();
assert!(matches!(err, crate::error::Error::LinkOutOfBounds { .. }));
drop(file);
std::fs::remove_file(&path).unwrap();
}
#[tokio::test]
async fn batch_persist_and_parse_address_pages_past_4_gib() {
const FIRST_MARKER: &[u8] = b"FIRSTPG!";
const BOUNDARY_MARKER: &[u8] = b"BOUNDARY";
let path = std::env::temp_dir().join(format!(
"data_bucket_seek_past_4gib_{}.wt",
std::process::id()
));
let mut file = nagoya::io::create(&path).await.unwrap();
let first_page = GeneralPage {
header: GeneralHeader {
data_version: DATA_VERSION,
space_id: 1.into(),
page_id: 1.into(),
previous_id: 0.into(),
next_id: 2.into(),
page_type: PageType::Data,
data_length: 0,
},
inner: data_page_with_marker(FIRST_MARKER),
};
let boundary_page = GeneralPage {
header: GeneralHeader {
data_version: DATA_VERSION,
space_id: 1.into(),
page_id: FIRST_PAGE_PAST_4_GIB.into(),
previous_id: 1.into(),
next_id: 0.into(),
page_type: PageType::Data,
data_length: 0,
},
inner: data_page_with_marker(BOUNDARY_MARKER),
};
persist_pages_batch::<_, { PAGE_SIZE as u32 }>(vec![first_page, boundary_page], &mut file)
.await
.unwrap();
nagoya::io::Write::flush(&mut file).await.unwrap();
let file_length = nagoya::io::File::length(&mut file).await.unwrap();
assert!(file_length > page_start_offset::<{ PAGE_SIZE as u32 }>(FIRST_PAGE_PAST_4_GIB));
let pages = parse_data_pages_batch::<
{ PAGE_SIZE as u32 },
INNER_PAGE_SIZE,
{ PAGE_SIZE as u32 },
>(&mut file, vec![1, FIRST_PAGE_PAST_4_GIB])
.await
.unwrap();
assert_eq!(pages.len(), 2);
assert_eq!(pages[0].header.page_id, 1.into());
assert_eq!(&pages[0].inner.data[..FIRST_MARKER.len()], FIRST_MARKER);
assert_eq!(pages[1].header.page_id, FIRST_PAGE_PAST_4_GIB.into());
assert_eq!(
&pages[1].inner.data[..BOUNDARY_MARKER.len()],
BOUNDARY_MARKER
);
drop(file);
std::fs::remove_file(&path).unwrap();
}
const HALF: usize = PAGE_SIZE / 2;
const HALF_INNER: usize = HALF - crate::GENERAL_HEADER_SIZE;
fn page_at<const INNER: usize>(id: u32, marker: &[u8]) -> GeneralPage<DataPage<INNER>> {
let mut data = [0u8; INNER];
data[..marker.len()].copy_from_slice(marker);
GeneralPage {
header: GeneralHeader {
data_version: DATA_VERSION,
space_id: 1.into(),
page_id: id.into(),
previous_id: 0.into(),
next_id: 0.into(),
page_type: PageType::Data,
data_length: 0,
},
inner: DataPage {
length: marker.len() as u32,
data,
},
}
}
#[tokio::test]
async fn a_non_default_stride_is_written_and_read_back_at_that_stride() {
let path =
std::env::temp_dir().join(format!("data_bucket_stride_{}.wt", std::process::id()));
let mut file = nagoya::io::create(&path).await.unwrap();
let pages = vec![
page_at::<HALF_INNER>(0, b"zero"),
page_at::<HALF_INNER>(1, b"one"),
page_at::<HALF_INNER>(2, b"two"),
];
persist_pages_batch::<_, { HALF as u32 }>(pages, &mut file)
.await
.unwrap();
nagoya::io::Write::flush(&mut file).await.unwrap();
let written = std::fs::metadata(&path).unwrap().len();
assert!(
written > 2 * HALF as u64 && written <= 3 * HALF as u64,
"three pages at a {HALF}-byte stride should end inside the third, got {written}"
);
let read = parse_data_pages_batch::<{ HALF as u32 }, HALF_INNER, { HALF as u32 }>(
&mut file,
vec![0, 1, 2],
)
.await
.unwrap();
assert_eq!(read.len(), 3);
assert_eq!(&read[0].inner.data[..4], b"zero");
assert_eq!(&read[1].inner.data[..3], b"one");
assert_eq!(&read[2].inner.data[..3], b"two");
assert_eq!(read[2].header.page_id, 2.into());
let wrong = parse_data_pages_batch::<
{ PAGE_SIZE as u32 },
INNER_PAGE_SIZE,
{ PAGE_SIZE as u32 },
>(&mut file, vec![1])
.await;
assert!(
wrong.is_err() || wrong.unwrap()[0].header.page_id != 1.into(),
"reading at the wrong stride must not find page 1"
);
let _ = std::fs::remove_file(&path);
}
}