feat(vm): add metered shared-string infrastructure for PLN-0176 step 19
This commit is contained in:
@@ -1,7 +1,6 @@
|
||||
use serde::{Deserialize, Serialize};
|
||||
use std::cell::Cell;
|
||||
use std::cmp::Ordering;
|
||||
use std::fmt::Write;
|
||||
use std::sync::Arc;
|
||||
|
||||
thread_local! {
|
||||
@@ -119,24 +118,20 @@ impl Value {
|
||||
}
|
||||
|
||||
pub fn append_to_string(&self, out: &mut String) {
|
||||
self.write_text(out).expect("writing into String is infallible");
|
||||
}
|
||||
|
||||
/// Writes existing Value text without allocating a String, so bounded
|
||||
/// callers can measure and reserve with their own fmt::Write sink.
|
||||
pub fn write_text(&self, out: &mut impl std::fmt::Write) -> std::fmt::Result {
|
||||
match self {
|
||||
Value::Int32(i) => {
|
||||
let _ = write!(out, "{}", i);
|
||||
}
|
||||
Value::Int64(i) => {
|
||||
let _ = write!(out, "{}", i);
|
||||
}
|
||||
Value::Float(f) => {
|
||||
let _ = write!(out, "{}", f);
|
||||
}
|
||||
Value::Boolean(b) => {
|
||||
let _ = write!(out, "{}", b);
|
||||
}
|
||||
Value::String(s) => out.push_str(s),
|
||||
Value::HeapRef(r) => {
|
||||
let _ = write!(out, "[HeapRef {}:{}]", r.index, r.generation);
|
||||
}
|
||||
Value::Null => out.push_str("null"),
|
||||
Value::Int32(i) => write!(out, "{}", i),
|
||||
Value::Int64(i) => write!(out, "{}", i),
|
||||
Value::Float(f) => write!(out, "{}", f),
|
||||
Value::Boolean(b) => write!(out, "{}", b),
|
||||
Value::String(s) => out.write_str(s),
|
||||
Value::HeapRef(r) => write!(out, "[HeapRef {}:{}]", r.index, r.generation),
|
||||
Value::Null => out.write_str("null"),
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -12,6 +12,9 @@ mod roots;
|
||||
#[allow(dead_code)]
|
||||
mod registry_verifier;
|
||||
mod scheduler;
|
||||
// Image/session creation and native provenance consume this in step 19.
|
||||
#[allow(dead_code)]
|
||||
mod string_ledger;
|
||||
// Registry-backed consumers are integrated with executable images in PLN-0176.
|
||||
#[allow(dead_code)]
|
||||
mod typed_storage;
|
||||
|
||||
@@ -441,6 +441,17 @@ impl<T> BudgetVec<T> {
|
||||
pub fn clear(&mut self) {
|
||||
self.data.clear();
|
||||
}
|
||||
pub(crate) fn retain(&mut self, keep: impl FnMut(&T) -> bool) {
|
||||
self.data.retain(keep);
|
||||
}
|
||||
pub(crate) fn extend_from_slice(&mut self, values: &[T]) -> Result<(), ResourceFailure>
|
||||
where
|
||||
T: Clone,
|
||||
{
|
||||
self.reserve(values.len())?;
|
||||
self.data.extend_from_slice(values);
|
||||
Ok(())
|
||||
}
|
||||
pub fn truncate(&mut self, len: usize) {
|
||||
self.data.truncate(len);
|
||||
}
|
||||
|
||||
@@ -0,0 +1,206 @@
|
||||
//! Allocation-identity accounting over ordinary Arc<str> values.
|
||||
//! The ledger never owns string content strongly. Native owners retain an
|
||||
//! explicit provenance lease; guest slots remain Arc<str>, with no drop wrapper.
|
||||
use crate::resource_budget::{
|
||||
BudgetVec, Reservation, ResourceFailure, ResourceReason, RuntimeBudget, RuntimeResource as Q,
|
||||
};
|
||||
use prometeu_bytecode::Value;
|
||||
use std::sync::{Arc, Mutex, MutexGuard, Weak};
|
||||
|
||||
#[derive(Debug)]
|
||||
struct Entry {
|
||||
content: Weak<str>,
|
||||
_bytes: Reservation,
|
||||
_allocation: Reservation,
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
struct Domain {
|
||||
budget: RuntimeBudget,
|
||||
entries: BudgetVec<Entry>,
|
||||
_state: Reservation,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub(crate) struct StringLedger(Arc<Mutex<Domain>>);
|
||||
|
||||
/// Host/tool retention must retain provenance along with the Arc. This is
|
||||
/// boundary metadata, never a replacement for Value::String/StringSlot.
|
||||
#[derive(Debug, Clone)]
|
||||
pub(crate) struct StringLease {
|
||||
content: Arc<str>,
|
||||
domain: StringLedger,
|
||||
}
|
||||
impl StringLease {
|
||||
pub(crate) fn content(&self) -> &Arc<str> {
|
||||
&self.content
|
||||
}
|
||||
pub(crate) fn domain(&self) -> &StringLedger {
|
||||
&self.domain
|
||||
}
|
||||
}
|
||||
|
||||
impl StringLedger {
|
||||
pub(crate) fn new(budget: RuntimeBudget) -> Result<Self, ResourceFailure> {
|
||||
let state = budget.reserve(
|
||||
Q::AuxiliaryBytes,
|
||||
budget.bytes::<Mutex<Domain>>(1, Q::AuxiliaryBytes)? + 2 * size_of::<usize>() as u64,
|
||||
)?;
|
||||
let entries = BudgetVec::new(&budget, Q::AuxiliaryBytes);
|
||||
Ok(Self(Arc::new(Mutex::new(Domain { budget, entries, _state: state }))))
|
||||
}
|
||||
fn domain(&self) -> MutexGuard<'_, Domain> {
|
||||
self.0.lock().unwrap_or_else(std::sync::PoisonError::into_inner)
|
||||
}
|
||||
|
||||
/// Safepoint reconciliation is bounded by the accepted allocation count.
|
||||
/// Retain compacts in place; unused capacity remains charged until drop.
|
||||
pub(crate) fn reconcile(&self) -> usize {
|
||||
self.domain().reconcile()
|
||||
}
|
||||
pub(crate) fn tracked_allocations(&self) -> usize {
|
||||
self.domain().entries.len()
|
||||
}
|
||||
pub(crate) fn retains(&self, content: &Arc<str>) -> bool {
|
||||
let address = Arc::as_ptr(content);
|
||||
self.domain().entries.iter().any(|entry| std::ptr::eq(entry.content.as_ptr(), address))
|
||||
}
|
||||
pub(crate) fn lease(&self, content: &Arc<str>) -> Option<StringLease> {
|
||||
self.retains(content)
|
||||
.then(|| StringLease { content: content.clone(), domain: self.clone() })
|
||||
}
|
||||
|
||||
/// Imports always materialize a distinct allocation in the destination
|
||||
/// domain. Assignment/call/storage of existing guest Arcs uses Arc::clone.
|
||||
pub(crate) fn import(&self, text: &str) -> Result<Arc<str>, ResourceFailure> {
|
||||
let mut domain = self.domain();
|
||||
let charges = domain.prepare(text.len())?;
|
||||
// Rust's stable Arc allocation can abort on physical allocator failure;
|
||||
// quotas and fallible ledger/buffer growth are checked before this call.
|
||||
let content: Arc<str> = Arc::from(text);
|
||||
domain.publish(&content, charges);
|
||||
Ok(content)
|
||||
}
|
||||
|
||||
pub(crate) fn concat(&self, left: &str, right: &str) -> Result<Arc<str>, ResourceFailure> {
|
||||
let mut domain = self.domain();
|
||||
let len = left.len().checked_add(right.len()).ok_or_else(|| {
|
||||
domain.budget.failure(Q::StringBytes, ResourceReason::SizeOverflow, u64::MAX)
|
||||
})?;
|
||||
let charges = domain.prepare(len)?;
|
||||
// The temporary buffer and eventual content coexist. Its actual
|
||||
// capacity is accounted independently, not hidden by the final length.
|
||||
let mut buffer = BudgetVec::<u8>::new(&domain.budget, Q::TemporaryBytes);
|
||||
buffer.reserve(len)?;
|
||||
buffer.extend_from_slice(left.as_bytes())?;
|
||||
buffer.extend_from_slice(right.as_bytes())?;
|
||||
let text = std::str::from_utf8(&buffer).expect("concatenating UTF-8 preserves validity");
|
||||
let content: Arc<str> = Arc::from(text);
|
||||
domain.publish(&content, charges);
|
||||
Ok(content)
|
||||
}
|
||||
pub(crate) fn format(&self, value: &Value) -> Result<Arc<str>, ResourceFailure> {
|
||||
self.format_values(&[value])
|
||||
}
|
||||
pub(crate) fn concat_values(
|
||||
&self,
|
||||
left: &Value,
|
||||
right: &Value,
|
||||
) -> Result<Arc<str>, ResourceFailure> {
|
||||
self.format_values(&[left, right])
|
||||
}
|
||||
fn format_values(&self, values: &[&Value]) -> Result<Arc<str>, ResourceFailure> {
|
||||
let mut domain = self.domain();
|
||||
let mut counter = SizeCounter(0);
|
||||
for value in values {
|
||||
value.write_text(&mut counter).map_err(|_| {
|
||||
domain.budget.failure(Q::StringBytes, ResourceReason::SizeOverflow, u64::MAX)
|
||||
})?;
|
||||
}
|
||||
let charges = domain.prepare(counter.0)?;
|
||||
let mut writer =
|
||||
TextBuffer { bytes: BudgetVec::new(&domain.budget, Q::TemporaryBytes), failure: None };
|
||||
writer.bytes.reserve(counter.0)?;
|
||||
for value in values {
|
||||
if value.write_text(&mut writer).is_err() {
|
||||
return Err(writer.failure.expect("bounded writer records its resource failure"));
|
||||
}
|
||||
}
|
||||
let text = std::str::from_utf8(&writer.bytes).expect("Value text is UTF-8");
|
||||
let content: Arc<str> = Arc::from(text);
|
||||
domain.publish(&content, charges);
|
||||
Ok(content)
|
||||
}
|
||||
}
|
||||
|
||||
struct SizeCounter(usize);
|
||||
impl std::fmt::Write for SizeCounter {
|
||||
fn write_str(&mut self, text: &str) -> std::fmt::Result {
|
||||
self.0 = self.0.checked_add(text.len()).ok_or(std::fmt::Error)?;
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
struct TextBuffer {
|
||||
bytes: BudgetVec<u8>,
|
||||
failure: Option<ResourceFailure>,
|
||||
}
|
||||
impl std::fmt::Write for TextBuffer {
|
||||
fn write_str(&mut self, text: &str) -> std::fmt::Result {
|
||||
self.bytes.extend_from_slice(text.as_bytes()).map_err(|failure| {
|
||||
self.failure = Some(failure);
|
||||
std::fmt::Error
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
struct Charges {
|
||||
bytes: Reservation,
|
||||
allocation: Reservation,
|
||||
}
|
||||
impl Domain {
|
||||
fn reconcile(&mut self) -> usize {
|
||||
let before = self.entries.len();
|
||||
self.entries.retain(|entry| entry.content.strong_count() != 0);
|
||||
before - self.entries.len()
|
||||
}
|
||||
fn reserve_content(&self, len: u64) -> Result<Charges, ResourceFailure> {
|
||||
let bytes = self.budget.reserve(Q::StringBytes, len)?;
|
||||
let allocation = self.budget.reserve(Q::StringAllocations, 1)?;
|
||||
Ok(Charges { bytes, allocation })
|
||||
}
|
||||
fn prepare(&mut self, len: usize) -> Result<Charges, ResourceFailure> {
|
||||
let len = u64::try_from(len).map_err(|_| {
|
||||
self.budget.failure(Q::StringBytes, ResourceReason::SizeOverflow, u64::MAX)
|
||||
})?;
|
||||
self.budget.check(Q::IndividualStringBytes, len)?;
|
||||
let charges = match self.reserve_content(len) {
|
||||
Ok(charges) => charges,
|
||||
Err(failure) if failure.reason == ResourceReason::Limit => {
|
||||
// One bounded pressure pass; never remove a live allocation.
|
||||
self.reconcile();
|
||||
self.reserve_content(len)?
|
||||
}
|
||||
Err(failure) => return Err(failure),
|
||||
};
|
||||
if let Err(failure) = self.entries.reserve(1) {
|
||||
if failure.reason != ResourceReason::Limit {
|
||||
return Err(failure);
|
||||
}
|
||||
self.reconcile();
|
||||
self.entries.reserve(1)?;
|
||||
}
|
||||
Ok(charges)
|
||||
}
|
||||
fn publish(&mut self, content: &Arc<str>, charges: Charges) {
|
||||
self.entries
|
||||
.push(Entry {
|
||||
content: Arc::downgrade(content),
|
||||
_bytes: charges.bytes,
|
||||
_allocation: charges.allocation,
|
||||
})
|
||||
.expect("prepare reserved one ledger record before materialization");
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests;
|
||||
@@ -0,0 +1,219 @@
|
||||
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 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);
|
||||
}
|
||||
Reference in New Issue
Block a user