boundgraph-core 0.1.0

//! Declared spending limits, as data.
//!
//! A [`Budget`] is a *declaration*, not a meter. It says what a node is allowed
//! to consume; it does not track what has been consumed, reserve anything, or
//! decide whether a child fits inside its parent. Those are feature 11's job
//! (US-1101 onward) and the runtime's (US-0504). The type lives here because
//! the Flow IR needs to carry a budget on every node long before anything can
//! enforce one.
//!
//! # Why four units and not one
//!
//! Different owners bound different things. Finance bounds currency, SRE bounds
//! wall time, a provider contract bounds call count, and a context engineer
//! bounds tokens. Collapsing them into one number would force a conversion
//! rate that nobody agrees on, so all four are carried and each is optional.
//!
//! # Why unbounded is spelled out
//!
//! [`Budget::UNBOUNDED`] exists and is the [`Default`], but it is a value you
//! have to write down rather than an absence you can overlook — the same
//! reasoning that makes [`GrantSet::EMPTY`](crate::GrantSet::EMPTY) the default
//! grant. A reviewer reading a flow sees `budget: unbounded` and can object to
//! it; they cannot object to a field that was never there.
//!
//! # How budgets compose
//!
//! Budgets nest, because nodes do, and the rule is *tightening*: a node's
//! effective ceiling in a unit is the smallest bound declared anywhere on the
//! path from the flow root down to it ([`Budget::clamped_to`]). A child that
//! declares less than its parent is narrowing its own allowance, which is
//! always fine. A child that declares more is claiming authority its parent
//! does not have to give, which is not ([`Budget::fits_within`]).
//!
//! Two asymmetries in that rule are deliberate:
//!
//! - **A child may leave a unit unbounded that its parent bounds.** It is not
//!   escaping anything — it inherits the parent's bound and spends against it,
//!   which is exactly what the runtime's buckets do (US-0504): a node that
//!   reserves nothing charges upward until it reaches something that has a
//!   limit.
//! - **A child may bound a unit its parent leaves unbounded.** Tightening
//!   below an unbounded parent is still tightening.
//!
//! So the only thing that fails is a unit both of them bound, where the child
//! asks for more. [`Budget::excesses`] reports every such unit at once rather
//! than the first, because a flow that overruns on both tokens and money has
//! two things wrong with it and a budget owner should see both.
//!
//! # Comparing units that are not numbers
//!
//! The four units have four types — a count, a decimal, a duration, a count —
//! and comparing them needs one space to compare in. [`Budget::amount`]
//! normalises each to a `u64`: currency to micro-dollars, time to
//! milliseconds. That is the same space [`BoundGraphError::BudgetExceeded`] reports
//! in and the same one the runtime meters in, so a figure never changes
//! meaning as it moves between them.
//!
//! [`BoundGraphError::BudgetExceeded`]: crate::BoundGraphError::BudgetExceeded

use std::fmt;
use std::time::Duration;

use rust_decimal::Decimal;
use rust_decimal::prelude::ToPrimitive;
use serde::{Deserialize, Serialize};

/// Micro-dollars per dollar. Six places is more than any provider prices to.
pub const MICROS_PER_USD: u32 = 1_000_000;

/// A decimal amount of dollars as whole micro-dollars.
///
/// An amount that will not fit in a `u64` reads as zero rather than wrapping.
/// Both answers are wrong, and this one is wrong in the direction that shows up
/// as an unexplained budget rather than as silent free spending.
pub fn micros_of_usd(usd: Decimal) -> u64 {
    (usd * Decimal::from(MICROS_PER_USD))
        .round()
        .to_u64()
        .unwrap_or(0)
}

/// Which of a budget's four limits is being talked about.
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum Unit {
    /// Tokens, prompt plus completion.
    Tokens,
    /// Spend, in micro-dollars.
    Usd,
    /// Wall-clock time, in milliseconds.
    Wall,
    /// Model calls.
    Calls,
}

impl Unit {
    /// Every unit, in a stable order.
    pub const ALL: [Self; 4] = [Self::Tokens, Self::Usd, Self::Wall, Self::Calls];

    /// The name [`BoundGraphError::BudgetExceeded`](crate::BoundGraphError::BudgetExceeded)
    /// reports. These strings are API.
    pub const fn name(self) -> &'static str {
        match self {
            Self::Tokens => "tokens",
            Self::Usd => "usd",
            Self::Wall => "wall",
            Self::Calls => "calls",
        }
    }

    /// The unit a [`name`](Self::name) refers to.
    ///
    /// The inverse of `name`, so a unit that crossed a process boundary as a
    /// string arrives back as the same unit.
    pub fn from_name(name: &str) -> Option<Self> {
        Self::ALL.into_iter().find(|u| u.name() == name)
    }

    /// This unit's position in [`ALL`](Self::ALL).
    ///
    /// Public because the runtime stores an amount per unit in a fixed array
    /// and needs the same ordering this crate uses — two orderings would be one
    /// too many.
    pub const fn index(self) -> usize {
        match self {
            Self::Tokens => 0,
            Self::Usd => 1,
            Self::Wall => 2,
            Self::Calls => 3,
        }
    }

    /// How an amount in this unit should be written for a person.
    ///
    /// The inverse of the normalisation [`Budget::amount`] applies, so a
    /// diagnostic reports `$0.50` rather than `500000 usd`.
    ///
    /// Money is shown to at least two places and never fewer, because `$0.5`
    /// reads as a typo where `$0.50` reads as an amount. Sub-cent precision is
    /// kept where it exists — per-million token rates are quoted in millionths,
    /// and rounding them away in a diagnostic about cost would be the wrong
    /// place to lose them.
    pub fn render(self, amount: u64) -> String {
        match self {
            Self::Tokens => format!("{amount} tokens"),
            Self::Usd => {
                let mut usd = (Decimal::from(amount) / Decimal::from(MICROS_PER_USD)).normalize();
                if usd.scale() < 2 {
                    usd.rescale(2);
                }
                format!("${usd}")
            }
            Self::Wall => format!("{:.3}s", amount as f64 / 1_000.0),
            Self::Calls => format!("{amount} calls"),
        }
    }
}

impl fmt::Display for Unit {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.write_str(self.name())
    }
}

/// A unit in which a budget asks for more than it may have.
///
/// Carries both figures, because "over budget" without them sends someone to
/// work out by how much, and by how much is the number that decides what to do
/// about it.
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct Excess {
    /// Which limit.
    pub unit: Unit,
    /// What was asked for, normalised.
    pub declared: u64,
    /// What was available, normalised.
    pub permitted: u64,
}

impl Excess {
    /// How far over the limit this is.
    pub const fn overage(&self) -> u64 {
        self.declared.saturating_sub(self.permitted)
    }
}

impl fmt::Display for Excess {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(
            f,
            "{} against a limit of {}",
            self.unit.render(self.declared),
            self.unit.render(self.permitted)
        )
    }
}

/// What a node is permitted to spend, in whichever units were declared.
///
/// Any subset of the four may be set. A unit left as `None` is unbounded *in
/// that unit* — it does not weaken the units that were declared.
///
/// # Example
///
/// ```
/// use boundgraph_core::Budget;
/// use std::time::Duration;
///
/// let b = Budget::UNBOUNDED
///     .with_usd("0.50".parse().unwrap())
///     .with_wall(Duration::from_secs(30));
///
/// assert!(!b.is_unbounded());
/// assert_eq!(b.tokens, None);      // tokens were never bounded
/// assert_eq!(b.declared_units(), ["usd", "wall"]);
/// ```
#[derive(Clone, Default, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
pub struct Budget {
    /// Total tokens, prompt plus completion.
    pub tokens: Option<u64>,
    /// Spend in US dollars.
    ///
    /// A decimal, never a float: money that round-trips through `f64` stops
    /// being auditable, and the ledger is meant to be audited.
    pub usd: Option<Decimal>,
    /// Wall-clock time.
    pub wall: Option<Duration>,
    /// Number of model calls.
    pub calls: Option<u32>,
}

impl Budget {
    /// No limit in any unit.
    ///
    /// The default, and deliberately something you have to name — see the
    /// module documentation.
    pub const UNBOUNDED: Self = Self {
        tokens: None,
        usd: None,
        wall: None,
        calls: None,
    };

    /// Bound the token count.
    #[must_use]
    pub fn with_tokens(mut self, tokens: u64) -> Self {
        self.tokens = Some(tokens);
        self
    }

    /// Bound the spend.
    ///
    /// The amount is normalised, so `1.50` and `1.5` are the same budget and
    /// therefore encode to the same bytes and the same digest.
    #[must_use]
    pub fn with_usd(mut self, usd: Decimal) -> Self {
        self.usd = Some(usd.normalize());
        self
    }

    /// Bound the wall-clock time.
    #[must_use]
    pub fn with_wall(mut self, wall: Duration) -> Self {
        self.wall = Some(wall);
        self
    }

    /// Bound the number of model calls.
    #[must_use]
    pub fn with_calls(mut self, calls: u32) -> Self {
        self.calls = Some(calls);
        self
    }

    /// Whether nothing at all is bounded.
    pub fn is_unbounded(&self) -> bool {
        *self == Self::UNBOUNDED
    }

    /// What this budget bounds in one unit, normalised to an integer.
    ///
    /// Currency becomes micro-dollars and time becomes milliseconds — see the
    /// module documentation for why there is one space to compare in. `None`
    /// means this budget does not bound that unit, which is not the same as
    /// bounding it at zero.
    pub fn amount(&self, unit: Unit) -> Option<u64> {
        match unit {
            Unit::Tokens => self.tokens,
            Unit::Usd => self.usd.map(micros_of_usd),
            Unit::Wall => self
                .wall
                .map(|w| w.as_millis().min(u128::from(u64::MAX)) as u64),
            Unit::Calls => self.calls.map(u64::from),
        }
    }

    /// Which units this budget bounds, in a stable order.
    pub fn bounded_units(&self) -> Vec<Unit> {
        Unit::ALL
            .into_iter()
            .filter(|u| self.amount(*u).is_some())
            .collect()
    }

    /// Every unit in which this budget asks for more than `parent` permits.
    ///
    /// Only units *both* budgets bound can be exceeded — see the module
    /// documentation for why the two asymmetric cases are legal. Returns them
    /// all rather than the first, in unit order.
    pub fn excesses(&self, parent: &Self) -> Vec<Excess> {
        Unit::ALL
            .into_iter()
            .filter_map(|unit| {
                let declared = self.amount(unit)?;
                let permitted = parent.amount(unit)?;
                (declared > permitted).then_some(Excess {
                    unit,
                    declared,
                    permitted,
                })
            })
            .collect()
    }

    /// Whether this budget can be declared beneath `parent`.
    ///
    /// True when it claims no more than the parent has to give, in every unit
    /// they both bound.
    pub fn fits_within(&self, parent: &Self) -> bool {
        self.excesses(parent).is_empty()
    }

    /// This budget as it is actually enforced beneath `parent`.
    ///
    /// The tighter of the two in every unit, which is the composition rule
    /// itself: an effective ceiling is the smallest bound on the path down to
    /// a node. Applying it to a budget that already
    /// [`fits_within`](Self::fits_within) its parent returns that budget with
    /// the parent's bounds filled in where it declared none.
    ///
    /// Idempotent, and associative down a chain: clamping to a parent and then
    /// to a grandparent gives what clamping straight to the tightest of the
    /// three would.
    #[must_use]
    pub fn clamped_to(&self, parent: &Self) -> Self {
        Self {
            tokens: tighter(self.tokens, parent.tokens),
            // Compared as declared rather than through `amount`, so the
            // surviving value keeps its own scale and the digest of a clamped
            // budget stays the digest of whichever budget won.
            usd: tighter(self.usd, parent.usd),
            wall: tighter(self.wall, parent.wall),
            calls: tighter(self.calls, parent.calls),
        }
    }

    /// Which units this budget actually constrains, in a stable order.
    ///
    /// Useful for diagnostics: "this flow bounds `usd` but not `wall`" is a
    /// reviewable statement.
    pub fn declared_units(&self) -> Vec<&'static str> {
        let mut units = Vec::with_capacity(4);
        if self.tokens.is_some() {
            units.push("tokens");
        }
        if self.usd.is_some() {
            units.push("usd");
        }
        if self.wall.is_some() {
            units.push("wall");
        }
        if self.calls.is_some() {
            units.push("calls");
        }
        units
    }
}

/// The smaller of two optional bounds, where absent means "no bound from this
/// side" rather than zero.
fn tighter<T: Ord>(child: Option<T>, parent: Option<T>) -> Option<T> {
    match (child, parent) {
        (Some(a), Some(b)) => Some(a.min(b)),
        (Some(a), None) => Some(a),
        (None, b) => b,
    }
}

impl fmt::Display for Budget {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        if self.is_unbounded() {
            return f.write_str("unbounded");
        }
        let mut first = true;
        let mut part = |f: &mut fmt::Formatter<'_>, text: &str| {
            let sep = if first { "" } else { ", " };
            first = false;
            write!(f, "{sep}{text}")
        };
        if let Some(t) = self.tokens {
            part(f, &format!("{t} tokens"))?;
        }
        if let Some(u) = self.usd {
            part(f, &format!("${u}"))?;
        }
        if let Some(w) = self.wall {
            part(f, &format!("{:.3}s", w.as_secs_f64()))?;
        }
        if let Some(c) = self.calls {
            part(f, &format!("{c} calls"))?;
        }
        Ok(())
    }
}

impl fmt::Debug for Budget {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "Budget({self})")
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::canonical::Canonical;

    #[test]
    fn the_default_is_unbounded() {
        assert!(Budget::default().is_unbounded());
        assert_eq!(Budget::default(), Budget::UNBOUNDED);
        assert!(Budget::UNBOUNDED.declared_units().is_empty());
    }

    #[test]
    fn units_are_independent() {
        let b = Budget::UNBOUNDED.with_tokens(1_000);
        assert_eq!(b.tokens, Some(1_000));
        assert_eq!(b.usd, None);
        assert_eq!(b.wall, None);
        assert_eq!(b.calls, None);
        assert_eq!(b.declared_units(), ["tokens"]);
    }

    #[test]
    fn all_four_units_can_be_declared_together() {
        let b = Budget::UNBOUNDED
            .with_tokens(10)
            .with_usd(Decimal::new(41, 2))
            .with_wall(Duration::from_millis(1_500))
            .with_calls(3);
        assert_eq!(b.declared_units(), ["tokens", "usd", "wall", "calls"]);
        assert!(!b.is_unbounded());
    }

    /// `1.50` and `1.5` are the same amount of money, so they must be the same
    /// budget — otherwise two equal flows would carry different digests.
    #[test]
    fn currency_scale_does_not_change_identity() {
        let a = Budget::UNBOUNDED.with_usd("1.50".parse().unwrap());
        let b = Budget::UNBOUNDED.with_usd("1.5".parse().unwrap());
        assert_eq!(a, b);
        assert_eq!(a.digest().unwrap(), b.digest().unwrap());
    }

    #[test]
    fn round_trips_through_canonical_cbor() {
        let b = Budget::UNBOUNDED
            .with_tokens(64)
            .with_usd("0.50".parse().unwrap())
            .with_wall(Duration::from_secs(30))
            .with_calls(2);
        let bytes = crate::to_canonical_cbor(&b).unwrap();
        let back: Budget = crate::from_canonical_cbor(&bytes).unwrap();
        assert_eq!(b, back);
    }

    #[test]
    fn display_names_every_declared_unit() {
        assert_eq!(Budget::UNBOUNDED.to_string(), "unbounded");
        let b = Budget::UNBOUNDED
            .with_tokens(100)
            .with_usd("0.41".parse().unwrap());
        assert_eq!(b.to_string(), "100 tokens, $0.41");
    }

    // ── units ───────────────────────────────────────────────────────────────

    /// Every unit round-trips through the name the error reports, so a unit
    /// that crossed a process boundary as a string comes back as itself.
    #[test]
    fn unit_names_round_trip() {
        for unit in Unit::ALL {
            assert_eq!(Unit::from_name(unit.name()), Some(unit));
        }
        assert_eq!(Unit::from_name("furlongs"), None);
    }

    /// The ordering is fixed, because the runtime stores an amount per unit in
    /// an array indexed by it.
    #[test]
    fn unit_indices_are_stable_and_distinct() {
        let indices: Vec<_> = Unit::ALL.iter().map(|u| u.index()).collect();
        assert_eq!(indices, [0, 1, 2, 3]);
    }

    /// A diagnostic reports money as money, not as the integer it was compared
    /// as.
    #[test]
    fn amounts_render_in_the_unit_a_person_reads() {
        assert_eq!(Unit::Tokens.render(1_500), "1500 tokens");
        assert_eq!(Unit::Usd.render(500_000), "$0.50");
        assert_eq!(Unit::Usd.render(2_000_000), "$2.00");
        assert_eq!(
            Unit::Usd.render(3),
            "$0.000003",
            "sub-cent precision survives"
        );
        assert_eq!(Unit::Wall.render(1_500), "1.500s");
        assert_eq!(Unit::Calls.render(3), "3 calls");
    }

    // ── normalisation ───────────────────────────────────────────────────────

    /// The criterion: currency uses a decimal type, never a float — and the
    /// integer it normalises to is exact.
    #[test]
    fn currency_normalises_to_whole_micro_dollars() {
        let b = Budget::UNBOUNDED.with_usd("0.50".parse().unwrap());
        assert_eq!(b.amount(Unit::Usd), Some(500_000));

        // The case a float gets wrong: 0.1 + 0.2 must be exactly 0.3.
        let sum: Decimal = "0.1".parse::<Decimal>().unwrap() + "0.2".parse::<Decimal>().unwrap();
        assert_eq!(
            Budget::UNBOUNDED.with_usd(sum).amount(Unit::Usd),
            Some(300_000)
        );
    }

    #[test]
    fn time_normalises_to_milliseconds() {
        let b = Budget::UNBOUNDED.with_wall(Duration::from_millis(1_500));
        assert_eq!(b.amount(Unit::Wall), Some(1_500));
    }

    /// An unbounded unit is not a zero bound. Confusing the two would turn
    /// "spend what you like" into "spend nothing".
    #[test]
    fn an_unbounded_unit_is_not_a_zero_bound() {
        let unbounded = Budget::UNBOUNDED;
        let zero = Budget::UNBOUNDED.with_tokens(0);

        assert_eq!(unbounded.amount(Unit::Tokens), None);
        assert_eq!(zero.amount(Unit::Tokens), Some(0));
        assert_ne!(unbounded, zero);
    }

    #[test]
    fn bounded_units_reports_only_what_is_declared() {
        let b = Budget::UNBOUNDED.with_tokens(1).with_calls(2);
        assert_eq!(b.bounded_units(), [Unit::Tokens, Unit::Calls]);
        assert!(Budget::UNBOUNDED.bounded_units().is_empty());
    }

    // ── composition ─────────────────────────────────────────────────────────

    /// The criterion: budgets compose hierarchically, with a child never
    /// exceeding its parent.
    #[test]
    fn a_child_asking_for_more_than_its_parent_does_not_fit() {
        let parent = Budget::UNBOUNDED.with_tokens(1_000);
        let ok = Budget::UNBOUNDED.with_tokens(400);
        let greedy = Budget::UNBOUNDED.with_tokens(1_400);

        assert!(ok.fits_within(&parent));
        assert!(!greedy.fits_within(&parent));

        let excesses = greedy.excesses(&parent);
        assert_eq!(excesses.len(), 1);
        assert_eq!(excesses[0].unit, Unit::Tokens);
        assert_eq!(excesses[0].declared, 1_400);
        assert_eq!(excesses[0].permitted, 1_000);
        assert_eq!(excesses[0].overage(), 400);
    }

    /// Asking for exactly the parent's allowance is not an excess. The whole
    /// allowance is a legal thing to claim.
    #[test]
    fn equalling_the_parent_fits() {
        let parent = Budget::UNBOUNDED.with_tokens(1_000);
        assert!(Budget::UNBOUNDED.with_tokens(1_000).fits_within(&parent));
    }

    /// A child that leaves a unit unbounded is inheriting the parent's bound,
    /// not escaping it — which is exactly what the runtime's buckets do.
    #[test]
    fn a_child_may_leave_a_unit_its_parent_bounds_unbounded() {
        let parent = Budget::UNBOUNDED.with_tokens(1_000).with_calls(5);
        let child = Budget::UNBOUNDED.with_tokens(100);

        assert!(child.fits_within(&parent));
        assert_eq!(child.clamped_to(&parent).calls, Some(5), "it inherits");
    }

    /// And a child may bound a unit its parent does not. Tightening below an
    /// unbounded parent is still tightening.
    #[test]
    fn a_child_may_bound_a_unit_its_parent_leaves_open() {
        let parent = Budget::UNBOUNDED.with_tokens(1_000);
        let child = Budget::UNBOUNDED.with_usd("0.10".parse().unwrap());

        assert!(child.fits_within(&parent));
        assert_eq!(
            child.clamped_to(&parent).usd,
            Some("0.10".parse().unwrap()),
            "the child's own bound survives"
        );
    }

    /// Every offending unit is reported, not just the first: a flow over budget
    /// on both tokens and money has two problems.
    #[test]
    fn every_exceeded_unit_is_reported() {
        let parent = Budget::UNBOUNDED
            .with_tokens(100)
            .with_usd("0.10".parse().unwrap())
            .with_calls(10);
        let child = Budget::UNBOUNDED
            .with_tokens(200)
            .with_usd("0.50".parse().unwrap())
            .with_calls(1);

        let units: Vec<_> = child.excesses(&parent).iter().map(|e| e.unit).collect();
        assert_eq!(
            units,
            [Unit::Tokens, Unit::Usd],
            "in unit order, and calls fits"
        );
    }

    /// Clamping takes the tighter of the two in every unit — the composition
    /// rule itself.
    #[test]
    fn clamping_takes_the_tighter_bound_in_every_unit() {
        let parent = Budget::UNBOUNDED.with_tokens(1_000).with_calls(2);
        let child = Budget::UNBOUNDED.with_tokens(4_000).with_calls(1);

        let effective = child.clamped_to(&parent);
        assert_eq!(effective.tokens, Some(1_000), "the parent's is tighter");
        assert_eq!(effective.calls, Some(1), "and here the child's is");
    }

    /// Clamping is idempotent: an effective budget is already effective.
    #[test]
    fn clamping_twice_changes_nothing() {
        let parent = Budget::UNBOUNDED.with_tokens(1_000);
        let child = Budget::UNBOUNDED.with_tokens(4_000).with_calls(3);

        let once = child.clamped_to(&parent);
        assert_eq!(once.clamped_to(&parent), once);
    }

    /// And it composes down a chain: clamping through a parent to a grandparent
    /// gives what clamping straight to the tightest of the three would.
    #[test]
    fn clamping_composes_down_a_chain() {
        let grandparent = Budget::UNBOUNDED.with_tokens(500);
        let parent = Budget::UNBOUNDED.with_tokens(2_000);
        let child = Budget::UNBOUNDED.with_tokens(4_000);

        let stepwise = child.clamped_to(&parent).clamped_to(&grandparent);
        assert_eq!(stepwise.tokens, Some(500));
        assert_eq!(stepwise, child.clamped_to(&grandparent));
    }

    /// Anything fits within an unbounded parent, and clamping to one is a
    /// no-op.
    #[test]
    fn an_unbounded_parent_constrains_nothing() {
        let child = Budget::UNBOUNDED.with_tokens(9_000);
        assert!(child.fits_within(&Budget::UNBOUNDED));
        assert_eq!(child.clamped_to(&Budget::UNBOUNDED), child);
    }

    /// An excess prints both figures in the unit a person reads, because "over
    /// budget" without them is not actionable.
    #[test]
    fn an_excess_names_both_figures() {
        let parent = Budget::UNBOUNDED.with_usd("0.10".parse().unwrap());
        let child = Budget::UNBOUNDED.with_usd("0.50".parse().unwrap());

        let excess = child.excesses(&parent).pop().unwrap();
        let printed = excess.to_string();
        assert!(printed.contains("$0.5"), "{printed}");
        assert!(printed.contains("$0.1"), "{printed}");
    }
}