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::>() + 2 * size_of::()) 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::>(); 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::>(); 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::>(); 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); }