aljaz/turso
1
0
Fork 0
mirror of https://github.com/aljazceru/turso.git synced 2025-12-31 15:04:19 +01:00
Code Issues Packages Projects Releases Wiki Activity

fix tests

Browse Source
This commit is contained in:
Jussi Saurio
2025-08-23 00:25:50 +03:00
parent 1d24925e21
commit b4ee40dd3d
1 changed files with 125 additions and 124 deletions
Download Patch File Download Diff File Expand all files Collapse all files

249
core/storage/btree.rs
View File

@@ -7324,7 +7324,7 @@ mod tests {
fn add_record(
id: usize,
pos: usize,
page: &mut PageContent,
page: PageRef,
record: ImmutableRecord,
conn: &Arc<Connection>,
) -> Vec<u8> {
@@ -7333,7 +7333,7 @@ mod tests {
run_until_done(
|| {
fill_cell_payload(
page,
page.clone(),
Some(id as i64),
&mut payload,
pos,
@@ -7346,7 +7346,7 @@ mod tests {
&conn.pager.borrow().clone(),
)
.unwrap();
insert_into_cell(page, &payload, pos, 4096).unwrap();
insert_into_cell(page.get_contents(), &payload, pos, 4096).unwrap();
payload
}
@@ -7356,17 +7356,17 @@ mod tests {
let conn = db.connect().unwrap();
let page = get_page(2);
let page = page.get();
let page = page.get_contents();
let header_size = 8;
let regs = &[Register::Value(Value::Integer(1))];
let record = ImmutableRecord::from_registers(regs, regs.len());
let payload = add_record(1, 0, page, record, &conn);
assert_eq!(page.cell_count(), 1);
let free = compute_free_space(page, 4096);
let payload = add_record(1, 0, page.clone(), record, &conn);
let page_contents = page.get_contents();
assert_eq!(page_contents.cell_count(), 1);
let free = compute_free_space(page_contents, 4096);
assert_eq!(free, 4096 - payload.len() - 2 - header_size);
let cell_idx = 0;
ensure_cell(page, cell_idx, &payload);
ensure_cell(page_contents, cell_idx, &payload);
}
struct Cell {
@@ -7381,7 +7381,7 @@ mod tests {
let page = get_page(2);
let page = page.get();
let page = page.get_contents();
let page_contents = page.get_contents();
let header_size = 8;
let mut total_size = 0;
@@ -7390,22 +7390,22 @@ mod tests {
for i in 0..3 {
let regs = &[Register::Value(Value::Integer(i as i64))];
let record = ImmutableRecord::from_registers(regs, regs.len());
let payload = add_record(i, i, page, record, &conn);
assert_eq!(page.cell_count(), i + 1);
let free = compute_free_space(page, usable_space);
let payload = add_record(i, i, page.clone(), record, &conn);
assert_eq!(page_contents.cell_count(), i + 1);
let free = compute_free_space(page_contents, usable_space);
total_size += payload.len() + 2;
assert_eq!(free, 4096 - total_size - header_size);
cells.push(Cell { pos: i, payload });
}
for (i, cell) in cells.iter().enumerate() {
ensure_cell(page, i, &cell.payload);
ensure_cell(page_contents, i, &cell.payload);
}
cells.remove(1);
drop_cell(page, 1, usable_space).unwrap();
drop_cell(page_contents, 1, usable_space).unwrap();
for (i, cell) in cells.iter().enumerate() {
ensure_cell(page, i, &cell.payload);
ensure_cell(page_contents, i, &cell.payload);
}
}
@@ -8360,7 +8360,7 @@ mod tests {
let page = get_page(2);
let page = page.get();
let page = page.get_contents();
let page_contents = page.get_contents();
let header_size = 8;
let mut total_size = 0;
@@ -8370,9 +8370,9 @@ mod tests {
for i in 0..total_cells {
let regs = &[Register::Value(Value::Integer(i as i64))];
let record = ImmutableRecord::from_registers(regs, regs.len());
let payload = add_record(i, i, page, record, &conn);
assert_eq!(page.cell_count(), i + 1);
let free = compute_free_space(page, usable_space);
let payload = add_record(i, i, page.clone(), record, &conn);
assert_eq!(page_contents.cell_count(), i + 1);
let free = compute_free_space(page_contents, usable_space);
total_size += payload.len() + 2;
assert_eq!(free, 4096 - total_size - header_size);
cells.push(Cell { pos: i, payload });
@@ -8382,7 +8382,7 @@ mod tests {
let mut new_cells = Vec::new();
for cell in cells {
if cell.pos % 2 == 1 {
drop_cell(page, cell.pos - removed, usable_space).unwrap();
drop_cell(page_contents, cell.pos - removed, usable_space).unwrap();
removed += 1;
} else {
new_cells.push(cell);
@@ -8390,11 +8390,11 @@ mod tests {
}
let cells = new_cells;
for (i, cell) in cells.iter().enumerate() {
ensure_cell(page, i, &cell.payload);
ensure_cell(page_contents, i, &cell.payload);
}
for (i, cell) in cells.iter().enumerate() {
ensure_cell(page, i, &cell.payload);
ensure_cell(page_contents, i, &cell.payload);
}
}
@@ -8812,7 +8812,7 @@ mod tests {
let page = get_page(2);
let page = page.get();
let page = page.get_contents();
let page_contents = page.get_contents();
let header_size = 8;
let mut total_size = 0;
@@ -8821,28 +8821,28 @@ mod tests {
for i in 0..3 {
let regs = &[Register::Value(Value::Integer(i as i64))];
let record = ImmutableRecord::from_registers(regs, regs.len());
let payload = add_record(i, i, page, record, &conn);
assert_eq!(page.cell_count(), i + 1);
let free = compute_free_space(page, usable_space);
let payload = add_record(i, i, page.clone(), record, &conn);
assert_eq!(page_contents.cell_count(), i + 1);
let free = compute_free_space(page_contents, usable_space);
total_size += payload.len() + 2;
assert_eq!(free, 4096 - total_size - header_size);
cells.push(Cell { pos: i, payload });
}
for (i, cell) in cells.iter().enumerate() {
ensure_cell(page, i, &cell.payload);
ensure_cell(page_contents, i, &cell.payload);
}
cells.remove(1);
drop_cell(page, 1, usable_space).unwrap();
drop_cell(page_contents, 1, usable_space).unwrap();
for (i, cell) in cells.iter().enumerate() {
ensure_cell(page, i, &cell.payload);
ensure_cell(page_contents, i, &cell.payload);
}
defragment_page(page, usable_space, 4).unwrap();
defragment_page(page_contents, usable_space, 4).unwrap();
for (i, cell) in cells.iter().enumerate() {
ensure_cell(page, i, &cell.payload);
ensure_cell(page_contents, i, &cell.payload);
}
}
@@ -8853,7 +8853,7 @@ mod tests {
let page = get_page(2);
let page = page.get();
let page = page.get_contents();
let page_contents = page.get_contents();
let header_size = 8;
let mut total_size = 0;
@@ -8863,9 +8863,9 @@ mod tests {
for i in 0..total_cells {
let regs = &[Register::Value(Value::Integer(i as i64))];
let record = ImmutableRecord::from_registers(regs, regs.len());
let payload = add_record(i, i, page, record, &conn);
assert_eq!(page.cell_count(), i + 1);
let free = compute_free_space(page, usable_space);
let payload = add_record(i, i, page.clone(), record, &conn);
assert_eq!(page_contents.cell_count(), i + 1);
let free = compute_free_space(page_contents, usable_space);
total_size += payload.len() + 2;
assert_eq!(free, 4096 - total_size - header_size);
cells.push(Cell { pos: i, payload });
@@ -8875,7 +8875,7 @@ mod tests {
let mut new_cells = Vec::new();
for cell in cells {
if cell.pos % 2 == 1 {
drop_cell(page, cell.pos - removed, usable_space).unwrap();
drop_cell(page_contents, cell.pos - removed, usable_space).unwrap();
removed += 1;
} else {
new_cells.push(cell);
@@ -8883,13 +8883,13 @@ mod tests {
}
let cells = new_cells;
for (i, cell) in cells.iter().enumerate() {
ensure_cell(page, i, &cell.payload);
ensure_cell(page_contents, i, &cell.payload);
}
defragment_page(page, usable_space, 4).unwrap();
defragment_page(page_contents, usable_space, 4).unwrap();
for (i, cell) in cells.iter().enumerate() {
ensure_cell(page, i, &cell.payload);
ensure_cell(page_contents, i, &cell.payload);
}
}
@@ -8900,7 +8900,7 @@ mod tests {
let page = get_page(2);
let page = page.get();
let page = page.get_contents();
let page_contents = page.get_contents();
let header_size = 8;
let mut total_size = 0;
@@ -8915,8 +8915,8 @@ mod tests {
match rng.next_u64() % 4 {
0 => {
// allow appends with extra place to insert
let cell_idx = rng.next_u64() as usize % (page.cell_count() + 1);
let free = compute_free_space(page, usable_space);
let cell_idx = rng.next_u64() as usize % (page_contents.cell_count() + 1);
let free = compute_free_space(page_contents, usable_space);
let regs = &[Register::Value(Value::Integer(i as i64))];
let record = ImmutableRecord::from_registers(regs, regs.len());
let mut payload: Vec<u8> = Vec::new();
@@ -8924,7 +8924,7 @@ mod tests {
run_until_done(
|| {
fill_cell_payload(
page,
page.clone(),
Some(i as i64),
&mut payload,
cell_idx,
@@ -8941,34 +8941,34 @@ mod tests {
// do not try to insert overflow pages because they require balancing
continue;
}
insert_into_cell(page, &payload, cell_idx, 4096).unwrap();
assert!(page.overflow_cells.is_empty());
insert_into_cell(page_contents, &payload, cell_idx, 4096).unwrap();
assert!(page_contents.overflow_cells.is_empty());
total_size += payload.len() + 2;
cells.insert(cell_idx, Cell { pos: i, payload });
}
1 => {
if page.cell_count() == 0 {
if page_contents.cell_count() == 0 {
continue;
}
let cell_idx = rng.next_u64() as usize % page.cell_count();
let (_, len) = page.cell_get_raw_region(cell_idx, usable_space);
drop_cell(page, cell_idx, usable_space).unwrap();
let cell_idx = rng.next_u64() as usize % page_contents.cell_count();
let (_, len) = page_contents.cell_get_raw_region(cell_idx, usable_space);
drop_cell(page_contents, cell_idx, usable_space).unwrap();
total_size -= len + 2;
cells.remove(cell_idx);
}
2 => {
defragment_page(page, usable_space, 4).unwrap();
defragment_page(page_contents, usable_space, 4).unwrap();
}
3 => {
// check cells
for (i, cell) in cells.iter().enumerate() {
ensure_cell(page, i, &cell.payload);
ensure_cell(page_contents, i, &cell.payload);
}
assert_eq!(page.cell_count(), cells.len());
assert_eq!(page_contents.cell_count(), cells.len());
}
_ => unreachable!(),
}
let free = compute_free_space(page, usable_space);
let free = compute_free_space(page_contents, usable_space);
assert_eq!(free, 4096 - total_size - header_size);
}
}
@@ -8982,7 +8982,7 @@ mod tests {
let page = get_page(2);
let page = page.get();
let page = page.get_contents();
let page_contents = page.get_contents();
let header_size = 8;
let mut total_size = 0;
@@ -8997,8 +8997,8 @@ mod tests {
match rng.next_u64() % 3 {
0 => {
// allow appends with extra place to insert
let cell_idx = rng.next_u64() as usize % (page.cell_count() + 1);
let free = compute_free_space(page, usable_space);
let cell_idx = rng.next_u64() as usize % (page_contents.cell_count() + 1);
let free = compute_free_space(page_contents, usable_space);
let regs = &[Register::Value(Value::Integer(i))];
let record = ImmutableRecord::from_registers(regs, regs.len());
let mut payload: Vec<u8> = Vec::new();
@@ -9006,7 +9006,7 @@ mod tests {
run_until_done(
|| {
fill_cell_payload(
page,
page.clone(),
Some(i),
&mut payload,
cell_idx,
@@ -9023,8 +9023,8 @@ mod tests {
// do not try to insert overflow pages because they require balancing
continue;
}
insert_into_cell(page, &payload, cell_idx, 4096).unwrap();
assert!(page.overflow_cells.is_empty());
insert_into_cell(page_contents, &payload, cell_idx, 4096).unwrap();
assert!(page_contents.overflow_cells.is_empty());
total_size += payload.len() + 2;
cells.push(Cell {
pos: i as usize,
@@ -9032,21 +9032,21 @@ mod tests {
});
}
1 => {
if page.cell_count() == 0 {
if page_contents.cell_count() == 0 {
continue;
}
let cell_idx = rng.next_u64() as usize % page.cell_count();
let (_, len) = page.cell_get_raw_region(cell_idx, usable_space);
drop_cell(page, cell_idx, usable_space).unwrap();
let cell_idx = rng.next_u64() as usize % page_contents.cell_count();
let (_, len) = page_contents.cell_get_raw_region(cell_idx, usable_space);
drop_cell(page_contents, cell_idx, usable_space).unwrap();
total_size -= len + 2;
cells.remove(cell_idx);
}
2 => {
defragment_page(page, usable_space, 4).unwrap();
defragment_page(page_contents, usable_space, 4).unwrap();
}
_ => unreachable!(),
}
let free = compute_free_space(page, usable_space);
let free = compute_free_space(page_contents, usable_space);
assert_eq!(free, 4096 - total_size - header_size);
}
}
@@ -9158,14 +9158,14 @@ mod tests {
let conn = db.connect().unwrap();
let page = get_page(2);
let page = page.get();
let page = page.get_contents();
let page_contents = page.get_contents();
let header_size = 8;
let usable_space = 4096;
let regs = &[Register::Value(Value::Integer(0))];
let record = ImmutableRecord::from_registers(regs, regs.len());
let payload = add_record(0, 0, page, record, &conn);
let free = compute_free_space(page, usable_space);
let payload = add_record(0, 0, page.clone(), record, &conn);
let free = compute_free_space(page_contents, usable_space);
assert_eq!(free, 4096 - payload.len() - 2 - header_size);
}
@@ -9176,18 +9176,18 @@ mod tests {
let page = get_page(2);
let page = page.get();
let page = page.get_contents();
let page_contents = page.get_contents();
let usable_space = 4096;
let regs = &[Register::Value(Value::Integer(0))];
let record = ImmutableRecord::from_registers(regs, regs.len());
let payload = add_record(0, 0, page, record, &conn);
let payload = add_record(0, 0, page.clone(), record, &conn);
assert_eq!(page.cell_count(), 1);
defragment_page(page, usable_space, 4).unwrap();
assert_eq!(page.cell_count(), 1);
let (start, len) = page.cell_get_raw_region(0, usable_space);
let buf = page.as_ptr();
assert_eq!(page_contents.cell_count(), 1);
defragment_page(page_contents, usable_space, 4).unwrap();
assert_eq!(page_contents.cell_count(), 1);
let (start, len) = page_contents.cell_get_raw_region(0, usable_space);
let buf = page_contents.as_ptr();
assert_eq!(&payload, &buf[start..start + len]);
}
@@ -9198,7 +9198,7 @@ mod tests {
let page = get_page(2);
let page = page.get();
let page = page.get_contents();
let page_contents = page.get_contents();
let usable_space = 4096;
let regs = &[
@@ -9206,19 +9206,19 @@ mod tests {
Register::Value(Value::Text(Text::new("aaaaaaaa"))),
];
let record = ImmutableRecord::from_registers(regs, regs.len());
let _ = add_record(0, 0, page, record, &conn);
let _ = add_record(0, 0, page.clone(), record, &conn);
assert_eq!(page.cell_count(), 1);
drop_cell(page, 0, usable_space).unwrap();
assert_eq!(page.cell_count(), 0);
assert_eq!(page_contents.cell_count(), 1);
drop_cell(page_contents, 0, usable_space).unwrap();
assert_eq!(page_contents.cell_count(), 0);
let regs = &[Register::Value(Value::Integer(0))];
let record = ImmutableRecord::from_registers(regs, regs.len());
let payload = add_record(0, 0, page, record, &conn);
assert_eq!(page.cell_count(), 1);
let payload = add_record(0, 0, page.clone(), record, &conn);
assert_eq!(page_contents.cell_count(), 1);
let (start, len) = page.cell_get_raw_region(0, usable_space);
let buf = page.as_ptr();
let (start, len) = page_contents.cell_get_raw_region(0, usable_space);
let buf = page_contents.as_ptr();
assert_eq!(&payload, &buf[start..start + len]);
}
@@ -9229,7 +9229,7 @@ mod tests {
let page = get_page(2);
let page = page.get();
let page = page.get_contents();
let page_contents = page.get_contents();
let usable_space = 4096;
let regs = &[
@@ -9237,20 +9237,20 @@ mod tests {
Register::Value(Value::Text(Text::new("aaaaaaaa"))),
];
let record = ImmutableRecord::from_registers(regs, regs.len());
let _ = add_record(0, 0, page, record, &conn);
let _ = add_record(0, 0, page.clone(), record, &conn);
for _ in 0..100 {
assert_eq!(page.cell_count(), 1);
drop_cell(page, 0, usable_space).unwrap();
assert_eq!(page.cell_count(), 0);
assert_eq!(page_contents.cell_count(), 1);
drop_cell(page_contents, 0, usable_space).unwrap();
assert_eq!(page_contents.cell_count(), 0);
let regs = &[Register::Value(Value::Integer(0))];
let record = ImmutableRecord::from_registers(regs, regs.len());
let payload = add_record(0, 0, page, record, &conn);
assert_eq!(page.cell_count(), 1);
let payload = add_record(0, 0, page.clone(), record, &conn);
assert_eq!(page_contents.cell_count(), 1);
let (start, len) = page.cell_get_raw_region(0, usable_space);
let buf = page.as_ptr();
let (start, len) = page_contents.cell_get_raw_region(0, usable_space);
let buf = page_contents.as_ptr();
assert_eq!(&payload, &buf[start..start + len]);
}
}
@@ -9262,23 +9262,23 @@ mod tests {
let page = get_page(2);
let page = page.get();
let page = page.get_contents();
let page_contents = page.get_contents();
let usable_space = 4096;
let regs = &[Register::Value(Value::Integer(0))];
let record = ImmutableRecord::from_registers(regs, regs.len());
let payload = add_record(0, 0, page, record, &conn);
let payload = add_record(0, 0, page.clone(), record, &conn);
let regs = &[Register::Value(Value::Integer(1))];
let record = ImmutableRecord::from_registers(regs, regs.len());
let _ = add_record(1, 1, page, record, &conn);
let _ = add_record(1, 1, page.clone(), record, &conn);
let regs = &[Register::Value(Value::Integer(2))];
let record = ImmutableRecord::from_registers(regs, regs.len());
let _ = add_record(2, 2, page, record, &conn);
let _ = add_record(2, 2, page.clone(), record, &conn);
drop_cell(page, 1, usable_space).unwrap();
drop_cell(page, 1, usable_space).unwrap();
drop_cell(page_contents, 1, usable_space).unwrap();
drop_cell(page_contents, 1, usable_space).unwrap();
ensure_cell(page, 0, &payload);
ensure_cell(page_contents, 0, &payload);
}
#[test]
@@ -9288,29 +9288,29 @@ mod tests {
let page = get_page(2);
let page = page.get();
let page = page.get_contents();
let page_contents = page.get_contents();
let usable_space = 4096;
let regs = &[Register::Value(Value::Integer(0))];
let record = ImmutableRecord::from_registers(regs, regs.len());
let _ = add_record(0, 0, page, record, &conn);
let _ = add_record(0, 0, page.clone(), record, &conn);
let regs = &[Register::Value(Value::Integer(0))];
let record = ImmutableRecord::from_registers(regs, regs.len());
let _ = add_record(0, 0, page, record, &conn);
drop_cell(page, 0, usable_space).unwrap();
let _ = add_record(0, 0, page.clone(), record, &conn);
drop_cell(page_contents, 0, usable_space).unwrap();
defragment_page(page, usable_space, 4).unwrap();
defragment_page(page_contents, usable_space, 4).unwrap();
let regs = &[Register::Value(Value::Integer(0))];
let record = ImmutableRecord::from_registers(regs, regs.len());
let _ = add_record(0, 1, page, record, &conn);
let _ = add_record(0, 1, page.clone(), record, &conn);
drop_cell(page, 0, usable_space).unwrap();
drop_cell(page_contents, 0, usable_space).unwrap();
let regs = &[Register::Value(Value::Integer(0))];
let record = ImmutableRecord::from_registers(regs, regs.len());
let _ = add_record(0, 1, page, record, &conn);
let _ = add_record(0, 1, page.clone(), record, &conn);
}
#[test]
@@ -9334,21 +9334,21 @@ mod tests {
let page = page.get();
defragment(page.get_contents());
defragment(page.get_contents());
insert(0, page.get_contents());
insert(0, page.clone());
drop(0, page.get_contents());
insert(0, page.get_contents());
insert(0, page.clone());
drop(0, page.get_contents());
insert(0, page.get_contents());
insert(0, page.clone());
defragment(page.get_contents());
defragment(page.get_contents());
drop(0, page.get_contents());
defragment(page.get_contents());
insert(0, page.get_contents());
insert(0, page.clone());
drop(0, page.get_contents());
insert(0, page.get_contents());
insert(1, page.get_contents());
insert(1, page.get_contents());
insert(0, page.get_contents());
insert(0, page.clone());
insert(1, page.clone());
insert(1, page.clone());
insert(0, page.clone());
drop(3, page.get_contents());
drop(2, page.get_contents());
compute_free_space(page.get_contents(), usable_space);
@@ -9379,7 +9379,7 @@ mod tests {
run_until_done(
|| {
fill_cell_payload(
page.get().get_contents(),
page.get(),
Some(0),
&mut payload,
0,
@@ -9393,11 +9393,11 @@ mod tests {
)
.unwrap();
let page = page.get();
insert(0, page.get_contents());
insert(0, page.clone());
defragment(page.get_contents());
insert(0, page.get_contents());
insert(0, page.clone());
defragment(page.get_contents());
insert(0, page.get_contents());
insert(0, page.clone());
drop(2, page.get_contents());
drop(0, page.get_contents());
let free = compute_free_space(page.get_contents(), usable_space);
@@ -9465,7 +9465,7 @@ mod tests {
run_until_done(
|| {
fill_cell_payload(
page.get().get_contents(),
page.get(),
Some(0),
&mut payload,
0,
@@ -9817,7 +9817,7 @@ mod tests {
while compute_free_space(page.get_contents(), pager.usable_space())
>= size as usize + 10
{
insert_cell(i, size, page.get_contents(), pager.clone());
insert_cell(i, size, page.clone(), pager.clone());
i += 1;
size = (rng.next_u64() % 1024) as u16;
}
@@ -9868,15 +9868,16 @@ mod tests {
}
}
fn insert_cell(cell_idx: u64, size: u16, contents: &mut PageContent, pager: Rc<Pager>) {
fn insert_cell(cell_idx: u64, size: u16, page: PageRef, pager: Rc<Pager>) {
let mut payload = Vec::new();
let regs = &[Register::Value(Value::Blob(vec![0; size as usize]))];
let record = ImmutableRecord::from_registers(regs, regs.len());
let mut fill_cell_payload_state = FillCellPayloadState::Start;
let contents = page.get_contents();
run_until_done(
|| {
fill_cell_payload(
contents,
page.clone(),
Some(cell_idx as i64),
&mut payload,
cell_idx as usize,