354 lines
14 KiB
Rust
354 lines
14 KiB
Rust
use super::*;
|
|
use crate::resource_budget::RuntimeLimits;
|
|
|
|
fn fixture(overrides: &[(Q, u64)]) -> (RuntimeBudget, StringLedger) {
|
|
let mut limits = RuntimeLimits::default();
|
|
for &(resource, ceiling) in overrides {
|
|
limits = limits.lowered(resource, ceiling).unwrap();
|
|
}
|
|
let budget = RuntimeBudget::new(limits);
|
|
let ledger = StringLedger::new(budget.clone()).unwrap();
|
|
(budget, ledger)
|
|
}
|
|
|
|
#[test]
|
|
fn clones_share_charge_but_equal_independent_allocations_do_not() {
|
|
let (budget, ledger) = fixture(&[]);
|
|
let first = ledger.import("same").unwrap();
|
|
let cloned = first.clone();
|
|
assert_eq!(budget.used(Q::StringBytes), 4);
|
|
assert_eq!(budget.used(Q::StringAllocations), 1);
|
|
let second = ledger.import("same").unwrap();
|
|
assert!(!Arc::ptr_eq(&first, &second));
|
|
assert_eq!(budget.used(Q::StringBytes), 8);
|
|
assert_eq!(budget.used(Q::StringAllocations), 2);
|
|
drop(first);
|
|
drop(second);
|
|
assert_eq!(ledger.reconcile(), 1);
|
|
assert_eq!(budget.used(Q::StringBytes), 4);
|
|
drop(cloned);
|
|
// The Weak and counters survive the last owner until reconciliation.
|
|
assert_eq!(budget.used(Q::StringBytes), 4);
|
|
assert_eq!(ledger.reconcile(), 1);
|
|
assert_eq!(budget.used(Q::StringBytes), 0);
|
|
assert_eq!(budget.used(Q::StringAllocations), 0);
|
|
}
|
|
|
|
#[test]
|
|
fn native_writer_quota_refusal_happens_before_callback_or_content_materialization() {
|
|
let (budget, ledger) = fixture(&[(Q::StringBytes, 2)]);
|
|
let mut called = false;
|
|
let result = ledger.build(3, &mut |writer| {
|
|
called = true;
|
|
writer.write_str("abc")
|
|
});
|
|
assert!(
|
|
matches!(result,Err(MaterializeError::Resource(error)) if error.resource==Q::StringBytes)
|
|
);
|
|
assert!(!called);
|
|
assert_eq!(budget.used(Q::StringBytes), 0);
|
|
assert_eq!(budget.used(Q::StringAllocations), 0);
|
|
assert_eq!(budget.used(Q::TemporaryBytes), 0);
|
|
}
|
|
|
|
#[test]
|
|
fn native_writer_length_mismatch_cannot_grow_buffer_and_refunds_content_reservations() {
|
|
let (budget, ledger) = fixture(&[]);
|
|
for (length, text) in [(2, "abc"), (4, "abc")] {
|
|
assert!(matches!(
|
|
ledger.build(length, &mut |writer| writer.write_str(text)),
|
|
Err(MaterializeError::InvalidLength)
|
|
));
|
|
assert_eq!(budget.used(Q::StringBytes), 0);
|
|
assert_eq!(budget.used(Q::StringAllocations), 0);
|
|
assert_eq!(budget.used(Q::TemporaryBytes), 0);
|
|
assert_eq!(ledger.tracked_allocations(), 0);
|
|
}
|
|
let content = ledger
|
|
.build(5, &mut |writer| {
|
|
writer.write_str("é")?;
|
|
writer.write_str("猫")
|
|
})
|
|
.ok()
|
|
.unwrap();
|
|
assert_eq!(&*content, "é猫");
|
|
assert_eq!(budget.used(Q::StringBytes), 5);
|
|
assert_eq!(budget.used(Q::StringAllocations), 1);
|
|
}
|
|
|
|
#[test]
|
|
fn empty_strings_still_consume_distinct_allocation_records() {
|
|
let (budget, ledger) = fixture(&[(Q::StringAllocations, 2), (Q::StringBytes, 0)]);
|
|
let first = ledger.import("").unwrap();
|
|
let second = ledger.import("").unwrap();
|
|
assert!(!Arc::ptr_eq(&first, &second));
|
|
assert_eq!(budget.used(Q::StringBytes), 0);
|
|
assert_eq!(budget.used(Q::StringAllocations), 2);
|
|
let e = ledger.import("").unwrap_err();
|
|
assert_eq!((e.resource, e.requested, e.limit), (Q::StringAllocations, 3, 2));
|
|
assert_eq!(ledger.tracked_allocations(), 2);
|
|
}
|
|
|
|
#[test]
|
|
fn content_and_individual_limits_are_checked_before_materialization() {
|
|
let (budget, ledger) = fixture(&[(Q::StringBytes, 4), (Q::IndividualStringBytes, 3)]);
|
|
assert_eq!(ledger.import("1234").unwrap_err().resource, Q::IndividualStringBytes);
|
|
assert_eq!(budget.used(Q::StringBytes), 0);
|
|
assert_eq!(ledger.tracked_allocations(), 0);
|
|
let retained = ledger.import("123").unwrap();
|
|
let err = ledger.import("45").unwrap_err();
|
|
assert_eq!((err.resource, err.requested, err.limit), (Q::StringBytes, 5, 4));
|
|
assert_eq!(budget.used(Q::StringBytes), 3);
|
|
assert_eq!(budget.used(Q::StringAllocations), 1);
|
|
assert_eq!(&*retained, "123");
|
|
}
|
|
|
|
#[test]
|
|
fn pressure_reconciliation_reclaims_only_dead_owners_and_reuses_capacity() {
|
|
let (budget, ledger) = fixture(&[(Q::StringBytes, 3), (Q::StringAllocations, 1)]);
|
|
let content = ledger.import("abc").unwrap();
|
|
let auxiliary = budget.used(Q::AuxiliaryBytes);
|
|
assert!(ledger.import("abc").is_err());
|
|
drop(content);
|
|
let replacement = ledger.import("xyz").unwrap();
|
|
assert_eq!(&*replacement, "xyz");
|
|
assert_eq!(budget.used(Q::StringBytes), 3);
|
|
assert_eq!(budget.used(Q::StringAllocations), 1);
|
|
assert_eq!(budget.used(Q::AuxiliaryBytes), auxiliary);
|
|
assert_eq!(budget.used(Q::TemporaryBytes), 0);
|
|
}
|
|
|
|
#[test]
|
|
fn allocation_count_failure_refunds_provisional_content_charge() {
|
|
let (budget, ledger) = fixture(&[(Q::StringAllocations, 0)]);
|
|
assert_eq!(ledger.import("abc").unwrap_err().resource, Q::StringAllocations);
|
|
assert_eq!(budget.used(Q::StringBytes), 0);
|
|
assert_eq!(ledger.tracked_allocations(), 0);
|
|
}
|
|
|
|
#[test]
|
|
fn ledger_growth_is_fallible_and_keeps_live_records_on_refusal() {
|
|
let state = (size_of::<Mutex<Domain>>() + 2 * size_of::<usize>()) as u64;
|
|
let (budget, ledger) = fixture(&[(Q::AuxiliaryBytes, state)]);
|
|
assert_eq!(ledger.import("abc").unwrap_err().resource, Q::AuxiliaryBytes);
|
|
assert_eq!(budget.used(Q::StringBytes), 0);
|
|
assert_eq!(budget.used(Q::StringAllocations), 0);
|
|
assert_eq!(budget.used(Q::AuxiliaryBytes), state);
|
|
assert_eq!(budget.used(Q::TemporaryBytes), 0);
|
|
assert_eq!(ledger.tracked_allocations(), 0);
|
|
}
|
|
|
|
#[test]
|
|
fn concatenation_accounts_utf8_length_and_temporary_result_coexistence() {
|
|
let (budget, ledger) = fixture(&[(Q::StringBytes, 5), (Q::TemporaryBytes, 5)]);
|
|
let result = ledger.concat("é", "猫").unwrap();
|
|
assert_eq!(&*result, "é猫");
|
|
assert_eq!(budget.used(Q::StringBytes), 5);
|
|
assert_eq!(budget.used(Q::TemporaryBytes), 0);
|
|
assert_eq!(ledger.tracked_allocations(), 1);
|
|
}
|
|
|
|
#[test]
|
|
fn temporary_refusal_leaves_no_published_content_or_content_reservation() {
|
|
let (budget, ledger) = fixture(&[(Q::TemporaryBytes, 2)]);
|
|
let error = ledger.concat("ab", "c").unwrap_err();
|
|
assert_eq!((error.resource, error.requested, error.limit), (Q::TemporaryBytes, 3, 2));
|
|
assert_eq!(budget.used(Q::StringBytes), 0);
|
|
assert_eq!(budget.used(Q::StringAllocations), 0);
|
|
assert_eq!(budget.used(Q::TemporaryBytes), 0);
|
|
assert_eq!(ledger.tracked_allocations(), 0);
|
|
// Direct import does not need a temporary concatenation buffer.
|
|
let imported = ledger.import("abc").unwrap();
|
|
assert_eq!(&*imported, "abc");
|
|
}
|
|
|
|
#[test]
|
|
fn foreign_arc_import_copies_into_destination_without_implicit_session_sharing() {
|
|
let (first_budget, first) = fixture(&[]);
|
|
let (second_budget, second) = fixture(&[]);
|
|
let source = first.import("text").unwrap();
|
|
assert!(first.retains(&source));
|
|
assert!(!second.retains(&source));
|
|
assert!(second.lease(&source).is_none());
|
|
let imported = second.import(&source).unwrap();
|
|
assert!(!Arc::ptr_eq(&source, &imported));
|
|
assert!(second.retains(&imported));
|
|
assert_eq!(first_budget.used(Q::StringBytes), 4);
|
|
assert_eq!(second_budget.used(Q::StringBytes), 4);
|
|
}
|
|
|
|
#[test]
|
|
fn native_provenance_lease_keeps_accounting_domain_alive_after_session_owner() {
|
|
let (budget, ledger) = fixture(&[]);
|
|
let content = ledger.import("kept").unwrap();
|
|
let host = ledger.lease(&content).unwrap();
|
|
let tool = host.clone();
|
|
drop(content);
|
|
drop(ledger);
|
|
assert_eq!(&**host.content(), "kept");
|
|
assert_eq!(host.domain().reconcile(), 0);
|
|
assert_eq!(budget.used(Q::StringBytes), 4);
|
|
drop(host);
|
|
assert_eq!(budget.used(Q::StringAllocations), 1);
|
|
drop(tool);
|
|
assert_eq!(budget.used(Q::StringBytes), 0);
|
|
assert_eq!(budget.used(Q::StringAllocations), 0);
|
|
assert_eq!(budget.used(Q::AuxiliaryBytes), 0);
|
|
}
|
|
|
|
#[test]
|
|
fn shared_domain_survives_one_consumer_and_final_drop_releases_weak_storage() {
|
|
let (budget, ledger) = fixture(&[]);
|
|
let shared = ledger.clone();
|
|
let value = ledger.import("image").unwrap();
|
|
drop(ledger);
|
|
assert!(shared.retains(&value));
|
|
assert_eq!(budget.used(Q::StringBytes), 5);
|
|
drop(value);
|
|
shared.reconcile();
|
|
assert_eq!(budget.used(Q::StringBytes), 0);
|
|
assert!(budget.used(Q::AuxiliaryBytes) > 0);
|
|
drop(shared);
|
|
assert_eq!(budget.used(Q::AuxiliaryBytes), 0);
|
|
}
|
|
|
|
#[test]
|
|
fn domain_construction_refusal_does_not_publish_a_partial_owner() {
|
|
let budget =
|
|
RuntimeBudget::new(RuntimeLimits::default().lowered(Q::AuxiliaryBytes, 0).unwrap());
|
|
assert_eq!(StringLedger::new(budget.clone()).unwrap_err().resource, Q::AuxiliaryBytes);
|
|
assert_eq!(budget.used(Q::AuxiliaryBytes), 0);
|
|
}
|
|
|
|
#[test]
|
|
fn bounded_formatting_preserves_existing_value_text_without_unmetered_string_buffers() {
|
|
let (budget, ledger) = fixture(&[]);
|
|
for value in [
|
|
Value::Int32(i32::MIN),
|
|
Value::Int64(i64::MAX),
|
|
Value::Float(-0.0),
|
|
Value::Float(f64::MAX),
|
|
Value::Float(f64::NAN),
|
|
Value::Boolean(false),
|
|
Value::Null,
|
|
Value::HeapRef(prometeu_bytecode::HeapRef { index: u32::MAX, generation: 7 }),
|
|
Value::String(Arc::from("é猫")),
|
|
] {
|
|
let text = ledger.format(&value).unwrap();
|
|
assert_eq!(&*text, value.to_string());
|
|
assert_eq!(budget.used(Q::TemporaryBytes), 0);
|
|
drop(text);
|
|
ledger.reconcile();
|
|
assert_eq!(budget.used(Q::StringBytes), 0);
|
|
}
|
|
let text = ledger.concat_values(&Value::String(Arc::from("x=")), &Value::Int64(42)).unwrap();
|
|
assert_eq!(&*text, "x=42");
|
|
assert_eq!(budget.used(Q::StringBytes), 4);
|
|
}
|
|
|
|
#[test]
|
|
fn formatting_refuses_result_and_temporary_limits_with_no_content_publication() {
|
|
let (budget, ledger) = fixture(&[(Q::IndividualStringBytes, 2)]);
|
|
assert_eq!(ledger.format(&Value::Int32(123)).unwrap_err().resource, Q::IndividualStringBytes);
|
|
assert_eq!(budget.used(Q::StringBytes), 0);
|
|
assert_eq!(budget.used(Q::StringAllocations), 0);
|
|
assert_eq!(ledger.tracked_allocations(), 0);
|
|
let (budget, ledger) = fixture(&[(Q::TemporaryBytes, 2)]);
|
|
assert_eq!(ledger.format(&Value::Boolean(false)).unwrap_err().resource, Q::TemporaryBytes);
|
|
assert_eq!(budget.used(Q::StringBytes), 0);
|
|
assert_eq!(budget.used(Q::StringAllocations), 0);
|
|
assert_eq!(ledger.tracked_allocations(), 0);
|
|
}
|
|
|
|
#[test]
|
|
fn index_growth_refuses_auxiliary_temporary_and_allocator_before_materialization() {
|
|
for failure in [0, 1, 2] {
|
|
let (budget, ledger) = fixture(&[]);
|
|
let kept = (0..4).map(|_| ledger.import("kept").unwrap()).collect::<Vec<_>>();
|
|
let auxiliary = budget.used(Q::AuxiliaryBytes);
|
|
match failure {
|
|
0 => budget.test_lower_limit(Q::AuxiliaryBytes, auxiliary),
|
|
1 => budget.test_lower_limit(Q::TemporaryBytes, 0),
|
|
_ => crate::resource_budget::FAIL_NEXT_VEC_ALLOCATION.with(|fail| fail.set(true)),
|
|
}
|
|
let mut called = false;
|
|
let result = ledger.build(4, &mut |w| {
|
|
called = true;
|
|
w.write_str("next")
|
|
});
|
|
let Err(MaterializeError::Resource(error)) = result else {
|
|
panic!("expected prepublication refusal")
|
|
};
|
|
assert!(!called);
|
|
assert_eq!(
|
|
error.resource,
|
|
if failure == 1 { Q::TemporaryBytes } else { Q::AuxiliaryBytes }
|
|
);
|
|
assert_eq!(
|
|
error.reason,
|
|
if failure == 2 { ResourceReason::AllocationFailed } else { ResourceReason::Limit }
|
|
);
|
|
assert_eq!(ledger.tracked_allocations(), 4);
|
|
assert_eq!(budget.used(Q::StringBytes), 16);
|
|
assert_eq!(budget.used(Q::StringAllocations), 4);
|
|
assert_eq!(budget.used(Q::AuxiliaryBytes), auxiliary);
|
|
assert_eq!(budget.used(Q::TemporaryBytes), 0);
|
|
for value in &kept {
|
|
assert!(ledger.retains(value));
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn index_initial_allocation_failure_and_rebuild_failure_refund_reservations() {
|
|
let (budget, ledger) = fixture(&[]);
|
|
let initial = budget.used(Q::AuxiliaryBytes);
|
|
crate::resource_budget::FAIL_NEXT_VEC_ALLOCATION.with(|fail| fail.set(true));
|
|
assert_eq!(ledger.import("x").unwrap_err().reason, ResourceReason::AllocationFailed);
|
|
assert_eq!(ledger.tracked_allocations(), 0);
|
|
assert_eq!(budget.used(Q::AuxiliaryBytes), initial);
|
|
assert_eq!(budget.used(Q::StringBytes), 0);
|
|
assert_eq!(budget.used(Q::StringAllocations), 0);
|
|
let mut kept = (0..4).map(|_| ledger.import("same").unwrap()).collect::<Vec<_>>();
|
|
let old = Arc::downgrade(&kept.pop().unwrap());
|
|
assert_eq!(ledger.reconcile(), 1);
|
|
let auxiliary = budget.used(Q::AuxiliaryBytes);
|
|
budget.test_lower_limit(Q::TemporaryBytes, 0);
|
|
assert_eq!(ledger.import("new").unwrap_err().resource, Q::TemporaryBytes);
|
|
assert_eq!(ledger.tracked_allocations(), 3);
|
|
assert_eq!(budget.used(Q::AuxiliaryBytes), auxiliary);
|
|
assert_eq!(budget.used(Q::TemporaryBytes), 0);
|
|
assert_eq!(budget.used(Q::StringBytes), 12);
|
|
for value in &kept {
|
|
assert_eq!(Arc::strong_count(value), 1);
|
|
assert!(ledger.retains(value));
|
|
}
|
|
assert!(old.upgrade().is_none());
|
|
// Rebuild under a restored test budget; no production ceiling changes.
|
|
budget.test_lower_limit(Q::TemporaryBytes, 64 * 1024 * 1024);
|
|
let newer = ledger.import("same").unwrap();
|
|
assert!(ledger.retains(&newer));
|
|
assert!(!ledger.retains(&Arc::from("same")));
|
|
assert!(ledger.lookup_work(&newer).0);
|
|
}
|
|
|
|
#[test]
|
|
fn tombstone_rebuild_allocator_refusal_preserves_live_keys_and_charges() {
|
|
let (budget, ledger) = fixture(&[]);
|
|
let mut owners = (0..4).map(|_| ledger.import("same").unwrap()).collect::<Vec<_>>();
|
|
owners.pop();
|
|
assert_eq!(ledger.reconcile(), 1);
|
|
let auxiliary = budget.used(Q::AuxiliaryBytes);
|
|
crate::resource_budget::FAIL_NEXT_VEC_ALLOCATION.with(|fail| fail.set(true));
|
|
assert_eq!(ledger.import("new").unwrap_err().reason, ResourceReason::AllocationFailed);
|
|
assert_eq!(ledger.tracked_allocations(), 3);
|
|
assert_eq!(budget.used(Q::StringBytes), 12);
|
|
assert_eq!(budget.used(Q::StringAllocations), 3);
|
|
assert_eq!(budget.used(Q::AuxiliaryBytes), auxiliary);
|
|
assert_eq!(budget.used(Q::TemporaryBytes), 0);
|
|
assert!(owners.iter().all(|v| ledger.retains(v)));
|
|
let new = ledger.import("new").unwrap();
|
|
assert!(ledger.retains(&new));
|
|
assert_eq!(budget.used(Q::AuxiliaryBytes), auxiliary);
|
|
}
|