libitofin 0.52.1

//! Piecewise-bootstrapped credit term structure.
//!
//! Port of `ql/termstructures/credit/piecewisedefaultcurve.hpp:53`. A
//! [`PiecewiseDefaultCurve`] is built from a set of
//! [`DefaultProbabilityHelper`]s whose maturities mark the segment boundaries;
//! each node is solved so the helper reprices its quote off the curve, by the
//! same [`IterativeBootstrap`] the yield side runs.
//!
//! This is the credit twin of
//! [`PiecewiseYieldCurve`](crate::termstructures::yields::PiecewiseYieldCurve)
//! and mirrors it field for field: the laziness contract, the pre-set
//! `calculated` flag, the observer registration on every helper and the
//! [`PiecewiseCurve`] surface the bootstrap drives are all the same.
//!
//! ## Laziness and bootstrap re-entrancy
//!
//! C++ derives from `Traits::curve<Interpolator>::type` *and* `LazyObject`
//! (`:53-60`), and its `survivalProbabilityImpl` / `defaultDensityImpl` /
//! `hazardRateImpl` each call `calculate()` before delegating to the base curve
//! (`:259-276`). Rust has no inheritance, so the node storage lives here and the
//! reads delegate to [`CreditBootstrapTraits`], sharing the same node
//! conversions as the corresponding interpolated credit curves.
//!
//! The pre-set `calculated` flag ([`LazyObject::new(true)`](LazyObject::new)) is
//! what breaks the bootstrap cycle, and the cycle here is tighter than on the
//! yield side: mid-bootstrap a
//! [`SpreadCdsHelper`](crate::termstructures::credit::defaultprobabilityhelpers::SpreadCdsHelper)
//! reprices its contract, whose engine reads *this* curve, which re-enters
//! [`calculate`](PiecewiseDefaultCurve::calculate). The re-entrant call finds
//! the calculation already running, returns immediately, and the read answers
//! off the partially solved node prefix - which is exactly what the bootstrap
//! needs, since a helper only ever reads up to its own pillar.
//!
//! ## Supported curve conventions
//!
//! [`HazardRate`], [`SurvivalProbability`] and [`DefaultDensity`] share the bootstrap driver; their
//! [`CreditBootstrapTraits`] implementations interpret the solved nodes.
//!
//! ## Constructors and deferrals
//!
//! - [`new`](PiecewiseDefaultCurve::new) is the reference-date constructor and
//!   [`moving`](PiecewiseDefaultCurve::moving) the settlement-days one
//!   (`piecewisedefaultcurve.hpp:106,121,135`), whose reference date follows the
//!   evaluation date of an explicit [`Settings`] (D5). A date change invalidates
//!   the bootstrap, as C++'s moving-aware `update()` does (`:248-258`).
//! - Jump quotes (`jumps`/`jumpDates`) are taken by
//!   [`with_jumps`](PiecewiseDefaultCurve::with_jumps) and
//!   [`moving_with_jumps`](PiecewiseDefaultCurve::moving_with_jumps). The
//!   quotes register with the curve's own updater, so a jump change
//!   re-bootstraps: helpers price off the jump-adjusted survival probability,
//!   as in C++. The C, Go and Python bindings expose both.
//! - Jump times are calculated on demand against the current reference date
//!   (the [`defaulttermstructure`](crate::termstructures::credit::defaulttermstructure)
//!   divergence), so a rolled moving curve's jump times follow the new
//!   reference date while the jump dates stay fixed. C++ `update()`
//!   (`piecewisedefaultcurve.hpp:248-258`) skips
//!   `DefaultProbabilityTermStructure::update`, the only re-caller of
//!   `setJumps` (`defaulttermstructure.hpp:243-247`), so a rolled C++ moving
//!   curve keeps its construction-time `jumpTimes_`.
//! - The moving constructor is exposed through the C, Go and Python bindings; a
//!   binding caller passes the same [`Settings`] instance the helpers carry.

use std::cell::RefCell;
use std::marker::PhantomData;
use std::rc::Weak;

use crate::errors::QlResult;
use crate::handle::Handle;
use crate::math::interpolations::Interpolator;
use crate::patterns::lazyobject::LazyObject;
use crate::patterns::observable::{AsObservable, Observable, Observer};
use crate::quotes::Quote;
use crate::require;
use crate::settings::Settings;
use crate::shared::{Shared, SharedMut, shared_mut};
use crate::termstructures::bootstraptraits::CurveData;
use crate::termstructures::credit::defaultdensitystructure::DefaultDensityStructure;
use crate::termstructures::credit::defaultprobabilityhelpers::DefaultProbabilityHelper;
use crate::termstructures::credit::defaulttermstructure::{
    DefaultProbabilityJumps, DefaultProbabilityTermStructure,
};
use crate::termstructures::credit::hazardratestructure::HazardRateStructure;
use crate::termstructures::credit::interpolatedhazardratecurve::hazard_rate_from_nodes;
use crate::termstructures::credit::probabilitytraits::{
    CreditBootstrapTraits, DefaultDensity, HazardRate, SurvivalProbability,
};
use crate::termstructures::credit::survivalprobabilitystructure::SurvivalProbabilityStructure;
use crate::termstructures::iterativebootstrap::{IterativeBootstrap, PiecewiseCurve};
use crate::termstructures::{TermStructure, TermStructureBase};
use crate::time::calendar::Calendar;
use crate::time::date::Date;
use crate::time::daycounter::DayCounter;
use crate::types::{Natural, Probability, Rate, Real, Time};

/// Feeds a helper-quote, discount-curve or evaluation-date notification into
/// the curve's lazy core: it invalidates the bootstrap cache and re-broadcasts
/// to the curve's own observers (the port of `registerWithObservables` +
/// `LazyObject::update`), as the yield curve's own updater does.
struct CurveUpdater {
    lazy: SharedMut<LazyObject>,
}

impl Observer for CurveUpdater {
    fn update(&mut self) {
        if let Some(update) = LazyObject::deferred_update(&self.lazy) {
            update.notify_observers();
        }
    }
}

/// Default-probability term structure bootstrapped from credit helpers.
///
/// `T` is the node convention ([`HazardRate`], [`SurvivalProbability`] or [`DefaultDensity`])
/// and `I` the interpolation factory. The node data lives in a `RefCell` the bootstrap
/// mutates and the survival/hazard lookups read back.
pub struct PiecewiseDefaultCurve<T: CreditBootstrapTraits, I: Interpolator> {
    base: TermStructureBase,
    instruments: Vec<Shared<dyn DefaultProbabilityHelper>>,
    interpolator: I,
    data: RefCell<CurveData<I>>,
    lazy: SharedMut<LazyObject>,
    observable: Shared<Observable>,
    updater: SharedMut<CurveUpdater>,
    jumps: Option<DefaultProbabilityJumps>,
    bootstrap: IterativeBootstrap,
    accuracy: Real,
    self_weak: Weak<dyn DefaultProbabilityTermStructure>,
    _traits: PhantomData<fn() -> T>,
}

impl<T: CreditBootstrapTraits + 'static, I: Interpolator + 'static> PiecewiseDefaultCurve<T, I> {
    /// Builds a curve over `instruments` with a fixed `reference_date` (the C++
    /// reference-date constructor, `piecewisedefaultcurve.hpp:68-79`).
    /// Construction is cheap; the bootstrap runs on first use.
    ///
    /// # Errors
    ///
    /// Rejects an empty helper set.
    pub fn new(
        reference_date: Date,
        instruments: Vec<Shared<dyn DefaultProbabilityHelper>>,
        day_counter: DayCounter,
        interpolator: I,
    ) -> QlResult<Shared<PiecewiseDefaultCurve<T, I>>> {
        Self::with_jumps(
            reference_date,
            instruments,
            day_counter,
            interpolator,
            Vec::new(),
            Vec::new(),
        )
    }

    /// The reference-date constructor with multiplicative survival jumps (the
    /// C++ `jumps`/`jumpDates` arguments, `piecewisedefaultcurve.hpp:68-79`).
    ///
    /// Empty `jump_dates` generates consecutive year-end dates from the
    /// reference year.
    ///
    /// # Errors
    ///
    /// Rejects an empty helper set, or returns a [`DefaultProbabilityJumps`]
    /// construction error.
    pub fn with_jumps(
        reference_date: Date,
        instruments: Vec<Shared<dyn DefaultProbabilityHelper>>,
        day_counter: DayCounter,
        interpolator: I,
        jumps: Vec<Handle<dyn Quote>>,
        jump_dates: Vec<Date>,
    ) -> QlResult<Shared<PiecewiseDefaultCurve<T, I>>> {
        Self::build(
            TermStructureBase::with_reference_date(reference_date, None, Some(day_counter)),
            instruments,
            interpolator,
            jumps,
            jump_dates,
        )
    }

    /// Builds a curve whose reference date moves with the evaluation date,
    /// advanced by `settlement_days` business days on `calendar` (the C++
    /// settlement-days constructors, `piecewisedefaultcurve.hpp:106-146`). An
    /// unset evaluation date surfaces as an `Err` on the first read, never a
    /// system-clock fallback.
    ///
    /// The curve's own [`CurveUpdater`] is registered on the evaluation-date
    /// observable, so a date change invalidates the bootstrap even when no
    /// helper observes the evaluation date.
    ///
    /// # Errors
    ///
    /// Rejects an empty helper set.
    pub fn moving(
        settlement_days: Natural,
        calendar: Calendar,
        instruments: Vec<Shared<dyn DefaultProbabilityHelper>>,
        day_counter: DayCounter,
        interpolator: I,
        settings: Shared<Settings<Date>>,
    ) -> QlResult<Shared<PiecewiseDefaultCurve<T, I>>> {
        Self::moving_with_jumps(
            settlement_days,
            calendar,
            instruments,
            day_counter,
            interpolator,
            settings,
            Vec::new(),
            Vec::new(),
        )
    }

    /// The settlement-days constructor with multiplicative survival jumps
    /// (`piecewisedefaultcurve.hpp:106-118`).
    ///
    /// Empty `jump_dates` generates year-end dates from the reference year at
    /// construction, so the evaluation date must already be set.
    ///
    /// # Errors
    ///
    /// Rejects an empty helper set, or returns a [`DefaultProbabilityJumps`]
    /// construction error.
    #[allow(clippy::too_many_arguments)]
    pub fn moving_with_jumps(
        settlement_days: Natural,
        calendar: Calendar,
        instruments: Vec<Shared<dyn DefaultProbabilityHelper>>,
        day_counter: DayCounter,
        interpolator: I,
        settings: Shared<Settings<Date>>,
        jumps: Vec<Handle<dyn Quote>>,
        jump_dates: Vec<Date>,
    ) -> QlResult<Shared<PiecewiseDefaultCurve<T, I>>> {
        let curve = Self::build(
            TermStructureBase::moving(
                settlement_days,
                calendar,
                Some(day_counter),
                Shared::clone(&settings),
            ),
            instruments,
            interpolator,
            jumps,
            jump_dates,
        )?;
        settings.register_eval_date_observer(
            &(SharedMut::clone(&curve.updater) as SharedMut<dyn Observer>),
        );
        Ok(curve)
    }

    fn build(
        base: TermStructureBase,
        instruments: Vec<Shared<dyn DefaultProbabilityHelper>>,
        interpolator: I,
        jumps: Vec<Handle<dyn Quote>>,
        jump_dates: Vec<Date>,
    ) -> QlResult<Shared<PiecewiseDefaultCurve<T, I>>> {
        require!(!instruments.is_empty(), "no bootstrap helpers given");

        let lazy = shared_mut(LazyObject::new(true));
        let observable = lazy.borrow().observable_handle();
        let updater = shared_mut(CurveUpdater {
            lazy: SharedMut::clone(&lazy),
        });
        let jumps = if jumps.is_empty() && jump_dates.is_empty() {
            None
        } else {
            let observer = SharedMut::clone(&updater) as SharedMut<dyn Observer>;
            Some(DefaultProbabilityJumps::with_observer(
                &base, &observer, jumps, jump_dates,
            )?)
        };
        let curve = Shared::new_cyclic(|weak: &Weak<PiecewiseDefaultCurve<T, I>>| {
            let self_weak: Weak<dyn DefaultProbabilityTermStructure> = weak.clone();
            PiecewiseDefaultCurve {
                base,
                instruments,
                interpolator,
                data: RefCell::new(CurveData::new()),
                lazy,
                observable,
                updater,
                jumps,
                bootstrap: IterativeBootstrap::new(),
                accuracy: 1.0e-12,
                self_weak,
                _traits: PhantomData,
            }
        });

        let observer = SharedMut::clone(&curve.updater) as SharedMut<dyn Observer>;
        for helper in &curve.instruments {
            helper.observable().register_observer(&observer);
        }
        Ok(curve)
    }

    /// Runs the bootstrap if the cache is stale, caching the result
    /// (`performCalculations`, `piecewisedefaultcurve.hpp:279-283`). The lazy
    /// core is not borrowed while the bootstrap runs, so a helper reading the
    /// curve mid-bootstrap re-enters here and returns on the pre-set flag.
    pub fn calculate(&self) -> QlResult<()> {
        if self.lazy.borrow().is_calculated() {
            return Ok(());
        }
        if !self.lazy.borrow_mut().start_calculation() {
            return Ok(());
        }
        let result = self.bootstrap.calculate(self);
        self.lazy.borrow_mut().finish_calculation(&result);
        result
    }

    /// The node times, after bootstrapping.
    pub fn times(&self) -> QlResult<Vec<Time>> {
        self.calculate()?;
        Ok(self.data.borrow().times().to_vec())
    }

    /// The node dates, after bootstrapping.
    pub fn dates(&self) -> QlResult<Vec<Date>> {
        self.calculate()?;
        Ok(self.data.borrow().dates().to_vec())
    }

    /// The node values, after bootstrapping.
    pub fn data(&self) -> QlResult<Vec<Real>> {
        self.calculate()?;
        Ok(self.data.borrow().data().to_vec())
    }

    /// The (date, value) nodes, after bootstrapping.
    pub fn nodes(&self) -> QlResult<Vec<(Date, Real)>> {
        self.calculate()?;
        Ok(self.data.borrow().nodes())
    }

    /// Registers a downstream observer of the curve's notifications.
    pub fn register_observer(&self, observer: &SharedMut<dyn Observer>) -> bool {
        self.observable.register_observer(observer)
    }
}

impl<T: CreditBootstrapTraits, I: Interpolator> AsObservable for PiecewiseDefaultCurve<T, I> {
    fn observable(&self) -> &Observable {
        &self.observable
    }
}

impl<T: CreditBootstrapTraits + 'static, I: Interpolator + 'static> TermStructure
    for PiecewiseDefaultCurve<T, I>
{
    fn base(&self) -> &TermStructureBase {
        &self.base
    }

    /// The curve's inputs are its helpers and jump quotes, the same set its
    /// own [`CurveUpdater`] observes, plus the evaluation date for a moving
    /// curve, as C++ `registerWithObservables` includes
    /// `Settings::evaluationDate()`.
    fn register_upstream(&self, observer: &SharedMut<dyn Observer>) {
        for helper in &self.instruments {
            helper.observable().register_observer(observer);
        }
        if let Some(jumps) = &self.jumps {
            jumps.register_observer(observer);
        }
        if let Some(settings) = self.base.moving_settings() {
            settings.register_eval_date_observer(observer);
        }
    }

    fn max_date(&self) -> Date {
        // Trigger the bootstrap so the maximum reflects the solved curve; a
        // bootstrap failure is surfaced by the reads, so fall back here.
        let _ = self.calculate();
        self.data
            .borrow()
            .max_date()
            .or_else(|| self.base.reference_date().ok())
            .unwrap_or_else(Date::null)
    }
}

impl<I: Interpolator + 'static> HazardRateStructure for PiecewiseDefaultCurve<HazardRate, I> {
    fn hazard_rate_curve_impl(&self, t: Time) -> QlResult<Rate> {
        self.calculate()?;
        let data = self.data.borrow();
        hazard_rate_from_nodes(data.interpolation()?, t)
    }
}

impl<I: Interpolator + 'static> DefaultDensityStructure
    for PiecewiseDefaultCurve<DefaultDensity, I>
{
}

impl<T: CreditBootstrapTraits + 'static, I: Interpolator + 'static> DefaultProbabilityTermStructure
    for PiecewiseDefaultCurve<T, I>
{
    /// Opts the bootstrapped curve into the downcast seam, for the same reason
    /// its yield-side twin does
    /// ([`PiecewiseYieldCurve`](crate::termstructures::yields::PiecewiseYieldCurve)):
    /// C++ casts a `PiecewiseDefaultCurve<HazardRate, BackwardFlat>` to its
    /// `InterpolatedHazardRateCurve<BackwardFlat>` base
    /// (`isdacdsengine.cpp:137-141`), which composition cannot reproduce.
    fn as_any(&self) -> Option<&dyn std::any::Any> {
        Some(self)
    }

    fn jumps(&self) -> Option<&DefaultProbabilityJumps> {
        self.jumps.as_ref()
    }

    fn survival_probability_impl(&self, t: Time) -> QlResult<Probability> {
        self.calculate()?;
        let data = self.data.borrow();
        T::survival(data.interpolation()?, t)
    }

    fn default_density_impl(&self, t: Time) -> QlResult<Real> {
        self.calculate()?;
        T::density(self.data.borrow().interpolation()?, t)
    }

    fn hazard_rate_impl(&self, t: Time) -> QlResult<Rate> {
        self.calculate()?;
        T::hazard(self.data.borrow().interpolation()?, t)
    }
}

impl<T: CreditBootstrapTraits + 'static, I: Interpolator + 'static> PiecewiseCurve
    for PiecewiseDefaultCurve<T, I>
{
    type Traits = T;
    type Interp = I;
    type TS = dyn DefaultProbabilityTermStructure;
    type Helper = dyn DefaultProbabilityHelper;

    fn instruments(&self) -> &[Shared<dyn DefaultProbabilityHelper>] {
        &self.instruments
    }

    fn interpolator(&self) -> &I {
        &self.interpolator
    }

    fn curve_data(&self) -> &RefCell<CurveData<I>> {
        &self.data
    }

    fn accuracy(&self) -> Real {
        self.accuracy
    }

    fn reference_date(&self) -> QlResult<Date> {
        self.base.reference_date()
    }

    fn time_from_reference(&self, date: Date) -> QlResult<Time> {
        TermStructure::time_from_reference(self, date)
    }

    fn term_structure_shared(&self) -> QlResult<Shared<dyn DefaultProbabilityTermStructure>> {
        match self.self_weak.upgrade() {
            Some(curve) => Ok(curve),
            None => crate::fail!("curve dropped before bootstrap"),
        }
    }
}

impl<I: Interpolator + 'static> SurvivalProbabilityStructure
    for PiecewiseDefaultCurve<SurvivalProbability, I>
{
}

#[cfg(test)]
mod tests {
    //! Oracle: `defaultprobabilitycurves.cpp` `testFlatHazardConsistency`
    //! (`:320`) through `testBootstrapFromSpread<HazardRate, BackwardFlat>`
    //! (`:152-224`) and `testBootstrapFromUpfront<HazardRate, BackwardFlat>`
    //! (`:230-317`), `testSingleInstrumentBootstrap` (`:344-378`) and
    //! `testUpfrontBootstrap` (`:380-395`).
    //!
    //! The round trip is self-consistent - every helper's own contract is
    //! rebuilt and repriced off the bootstrapped curve and must reproduce its
    //! input spread - so there are no external numbers to transcribe.
    //!
    //! Two deliberate departures from the C++ fixture, both from D5:
    //!
    //! - C++ takes `today` from `Settings::instance().evaluationDate()`, which
    //!   the test suite's global fixture sets from the clock. Each test here
    //!   owns its `Settings`, so the evaluation date is a fixed TARGET business
    //!   day, asserted rather than assumed.
    //! - The `SavedSettings` guard around the `includeTodaysCashFlows` write
    //!   (`:196-198`) is not ported: the flag lives on a `Settings` this test
    //!   owns outright, so there is no global to restore.

    use super::*;
    use crate::handle::Handle;
    use crate::indexes::ibor::euribor::Euribor;
    use crate::instrument::Instrument;
    use crate::instruments::{CdsTerms, CreditDefaultSwap, ProtectionSide, cds_maturity};
    use crate::interestrate::Compounding;
    use crate::math::interpolations::flat::BackwardFlat;
    use crate::math::interpolations::loglinear::LogLinear;
    use crate::pricingengine::PricingEngine;
    use crate::pricingengines::credit::{MidPointCdsEngine, isda_node_grid};
    use crate::quotes::{Quote, SimpleQuote};
    use crate::settings::Settings;
    use crate::shared::shared;
    use crate::termstructures::RateHelper;
    use crate::termstructures::bootstraptraits::Discount;
    use crate::termstructures::credit::defaultprobabilityhelpers::{
        CdsHelperTerms, DefaultProbabilityHelperBase, SpreadCdsHelper, UpfrontCdsHelper,
    };
    use crate::termstructures::yields::{DepositRateHelper, FlatForward, PiecewiseYieldCurve};
    use crate::termstructures::yieldtermstructure::YieldTermStructure;
    use crate::time::businessdayconvention::BusinessDayConvention;
    use crate::time::calendars::target::Target;
    use crate::time::date::Month;
    use crate::time::dategenerationrule::DateGeneration;
    use crate::time::daycounters::actual360::Actual360;
    use crate::time::daycounters::thirty360::{Convention, Thirty360};
    use crate::time::frequency::Frequency;
    use crate::time::period::Period;
    use crate::time::schedule::Schedule;
    use crate::time::timeunit::TimeUnit;
    use crate::types::{Integer, Natural, Rate};

    const QUOTES: [Real; 4] = [0.005, 0.006, 0.007, 0.009];
    const TENORS: [i32; 4] = [1, 2, 3, 5];
    const RECOVERY_RATE: Real = 0.4;
    const TOLERANCE: Real = 1.0e-6;

    /// The evaluation date, standing in for the C++ global fixture's. A TARGET
    /// business day, and one whose yearly anniversaries miss the IMM twentieths
    /// the schedules roll to - see
    /// [`the_helper_and_the_round_trip_agree_on_the_imm_maturity`].
    fn today() -> Date {
        Date::new(9, Month::June, 2006)
    }

    fn settings_at(evaluation_date: Date) -> Shared<Settings<Date>> {
        let settings = shared(Settings::<Date>::new());
        settings.set_evaluation_date(evaluation_date);
        settings
    }

    fn day_counter() -> DayCounter {
        Thirty360::with_convention(Convention::BondBasis)
    }

    /// `FlatForward(today, 0.06, Actual360())` (`:172-173`), whose C++ defaults
    /// are continuous compounding at annual frequency.
    fn discount_curve(reference_date: Date) -> Handle<dyn YieldTermStructure> {
        Handle::new(shared(FlatForward::with_rate(
            reference_date,
            0.06,
            Actual360::new(),
            Compounding::Continuous,
            Frequency::Annual,
        )) as Shared<dyn YieldTermStructure>)
    }

    fn spread_helper(
        quote: Real,
        tenor: Period,
        settlement_days: Integer,
        discount: &Handle<dyn YieldTermStructure>,
        settings: &Shared<Settings<Date>>,
    ) -> Shared<dyn DefaultProbabilityHelper> {
        SpreadCdsHelper::new(
            Handle::new(shared(SimpleQuote::new(quote)) as Shared<dyn Quote>),
            tenor,
            settlement_days,
            Target::new(),
            Frequency::Quarterly,
            BusinessDayConvention::Following,
            DateGeneration::TwentiethIMM,
            day_counter(),
            RECOVERY_RATE,
            discount.clone(),
            Shared::clone(settings),
        )
        .expect("TwentiethIMM is an accepted date-generation rule")
            as Shared<dyn DefaultProbabilityHelper>
    }

    /// The round-trip contract's schedule (`:203-206`): it starts at the rolled
    /// protection start, as the helper's does, but ends a tenor past `today`
    /// where the helper's ends a tenor past the protection start.
    fn round_trip_schedule(today: Date, tenor: Period) -> Schedule {
        let calendar = Target::new();
        let start_date = calendar.adjust(today + SETTLEMENT_DAYS, BusinessDayConvention::Following);
        Schedule::new(
            start_date,
            today + tenor,
            Period::try_from(Frequency::Quarterly).expect("a quarterly period"),
            calendar,
            BusinessDayConvention::Following,
            BusinessDayConvention::Unadjusted,
            DateGeneration::TwentiethIMM,
            false,
            Date::null(),
            Date::null(),
        )
    }

    fn rolled_back_date(schedule: &Schedule) -> Date {
        Target::new().adjust(
            schedule.date(schedule.len() - 1),
            BusinessDayConvention::Following,
        )
    }

    const SETTLEMENT_DAYS: Integer = 1;

    struct Fixture<T: CreditBootstrapTraits = HazardRate, I: Interpolator = BackwardFlat> {
        settings: Shared<Settings<Date>>,
        discount: Handle<dyn YieldTermStructure>,
        helpers: Vec<Shared<dyn DefaultProbabilityHelper>>,
        curve: Shared<PiecewiseDefaultCurve<T, I>>,
    }

    /// The four-pillar fixture of `testBootstrapFromSpread` (`:154-186`).
    fn fixture() -> Fixture {
        fixture_with::<HazardRate, _>(BackwardFlat)
    }

    fn fixture_with<T: CreditBootstrapTraits + 'static, I: Interpolator + 'static>(
        interpolator: I,
    ) -> Fixture<T, I> {
        assert!(
            Target::new().is_business_day(today()),
            "the fixed evaluation date must be a TARGET business day, as the \
             C++ fixture's clock-derived one is rolled to be"
        );
        let settings = settings_at(today());
        // C++ sets this before the first pricing (`:198`); the helpers price
        // their own contracts inside the bootstrap, so it must be in place
        // before any read triggers it.
        settings.set_include_todays_cash_flows(Some(true));
        let discount = discount_curve(today());

        let helpers: Vec<Shared<dyn DefaultProbabilityHelper>> = QUOTES
            .iter()
            .zip(TENORS)
            .map(|(quote, n)| {
                spread_helper(
                    *quote,
                    Period::new(n, TimeUnit::Years),
                    SETTLEMENT_DAYS,
                    &discount,
                    &settings,
                )
            })
            .collect();

        let curve = PiecewiseDefaultCurve::<T, I>::new(
            today(),
            helpers.clone(),
            day_counter(),
            interpolator,
        )
        .unwrap();

        Fixture {
            settings,
            discount,
            helpers,
            curve,
        }
    }

    /// `testBootstrapFromSpread<HazardRate, BackwardFlat>` (`:200-223`): each
    /// pillar's CDS, rebuilt from the market conventions and repriced off the
    /// bootstrapped curve, returns its own input spread to 1e-6.
    #[test]
    fn bootstrapped_curve_reproduces_the_input_cds_spreads() {
        assert_the_spreads_reproduce(&fixture());
    }

    fn assert_the_spreads_reproduce<
        T: CreditBootstrapTraits + 'static,
        I: Interpolator + 'static,
    >(
        fixture: &Fixture<T, I>,
    ) {
        let curve: Handle<dyn DefaultProbabilityTermStructure> = Handle::new(Shared::clone(
            &fixture.curve,
        )
            as Shared<dyn DefaultProbabilityTermStructure>);

        for (quote, n) in QUOTES.iter().zip(TENORS) {
            let tenor = Period::new(n, TimeUnit::Years);
            let protection_start = today() + SETTLEMENT_DAYS;
            let mut cds = CreditDefaultSwap::with_terms(
                ProtectionSide::Buyer,
                1.0,
                *quote,
                round_trip_schedule(today(), tenor),
                BusinessDayConvention::Following,
                day_counter(),
                CdsTerms {
                    protection_start: Some(protection_start),
                    ..CdsTerms::default()
                },
                Shared::clone(&fixture.settings),
            )
            .unwrap();
            let engine = MidPointCdsEngine::new(
                curve.clone(),
                RECOVERY_RATE,
                fixture.discount.clone(),
                None,
                Shared::clone(&fixture.settings),
            );
            cds.base_mut()
                .set_pricing_engine(shared_mut(engine) as SharedMut<dyn PricingEngine>);

            let computed = cds.fair_spread().unwrap();
            assert!(
                (computed - quote).abs() <= TOLERANCE,
                "failed to reproduce the fair spread for the {n}Y credit-default swap: \
                 computed {computed}, input {quote}"
            );
        }
    }

    /// The bootstrapped curve is what the ISDA engine is handed, so it must be
    /// introspectable through the downcast seam
    /// (`isdacdsengine.cpp:137-141`). C++ gets there by inheritance - a
    /// `PiecewiseDefaultCurve<HazardRate, BackwardFlat>` *is* an
    /// `InterpolatedHazardRateCurve<BackwardFlat>` - which this port's
    /// composition cannot reproduce, so the arm is named for the piecewise
    /// curve in its own right. The fixture's discount curve is flat and
    /// contributes nothing, leaving the grid as the solved pillars alone.
    #[test]
    fn bootstrapped_curve_feeds_the_isda_node_grid() {
        let fixture = fixture();
        let curve: Handle<dyn DefaultProbabilityTermStructure> = Handle::new(Shared::clone(
            &fixture.curve,
        )
            as Shared<dyn DefaultProbabilityTermStructure>);

        let pillars = fixture.curve.dates().expect("the bootstrap succeeds");
        assert_eq!(
            pillars.len(),
            TENORS.len() + 1,
            "the reference date plus a pillar per tenor"
        );

        let grid = isda_node_grid(&fixture.discount, &curve, today() + 10_000)
            .expect("a bootstrapped backward-flat hazard-rate curve is an ISDA curve");
        assert_eq!(grid, pillars);
    }

    /// Two *bootstrapped* curves through the seam at once - the path
    /// `testIsdaEngine` drives, and the only test where the union
    /// (`isdacdsengine.cpp:150-151`) has to merge two solved node sets rather
    /// than fold one against a flat curve's empty list.
    ///
    /// The two pillar sets are genuinely distinct: the yield curve's are
    /// deposit maturities a few months out, the credit curve's are the IMM
    /// twentieths of the 1Y/2Y/3Y/5Y helpers, and they share only the common
    /// reference date. The expected grid is rebuilt here from the two curves'
    /// own dates rather than transcribed, so it survives a change of fixture;
    /// the assertions that make it non-degenerate are the exact length
    /// (which pins the single shared date collapsing exactly once), strict
    /// increase, and the presence of a date unique to each curve.
    #[test]
    fn two_bootstrapped_curves_merge_into_one_sorted_grid() {
        let fixture = fixture();
        let credit: Handle<dyn DefaultProbabilityTermStructure> = Handle::new(Shared::clone(
            &fixture.curve,
        )
            as Shared<dyn DefaultProbabilityTermStructure>);

        let deposits: Vec<Shared<dyn RateHelper>> = [(3, TimeUnit::Months), (6, TimeUnit::Months)]
            .iter()
            .map(|(n, units)| {
                let quote = Handle::new(shared(SimpleQuote::new(0.04)) as Shared<dyn Quote>);
                let index = Euribor::new(
                    Period::new(*n, *units),
                    Handle::empty(),
                    Shared::clone(&fixture.settings),
                )
                .expect("the deposit tenor is valid");
                DepositRateHelper::new(quote, &index) as Shared<dyn RateHelper>
            })
            .collect();
        let yield_curve = PiecewiseYieldCurve::<Discount, LogLinear>::new(
            today(),
            deposits,
            Actual360::new(),
            LogLinear,
        )
        .expect("the deposit helpers bootstrap");

        let yield_pillars = yield_curve.dates().expect("the yield bootstrap succeeds");
        let credit_pillars = fixture
            .curve
            .dates()
            .expect("the credit bootstrap succeeds");
        assert_eq!(
            yield_pillars.len(),
            3,
            "the reference date plus two deposits"
        );
        assert_eq!(
            credit_pillars.len(),
            TENORS.len() + 1,
            "the reference date plus a pillar per tenor"
        );

        let grid = isda_node_grid(
            &Handle::new(yield_curve as Shared<dyn YieldTermStructure>),
            &credit,
            today() + 10_000,
        )
        .expect("two bootstrapped ISDA curves are supported");

        let shared_dates = yield_pillars
            .iter()
            .filter(|date| credit_pillars.contains(date))
            .count();
        assert_eq!(
            shared_dates, 1,
            "the two curves share only the reference date"
        );
        assert_eq!(
            grid.len(),
            yield_pillars.len() + credit_pillars.len() - shared_dates,
            "the shared reference date collapses exactly once"
        );
        assert!(
            grid.windows(2).all(|pair| pair[0] < pair[1]),
            "the grid is strictly increasing: {grid:?}"
        );
        assert!(
            grid.contains(&yield_pillars[1]) && grid.contains(&credit_pillars[1]),
            "both curves contribute a pillar of their own"
        );
        for date in yield_pillars.iter().chain(credit_pillars.iter()) {
            assert!(grid.contains(date), "the grid drops the pillar {date:?}");
        }
    }

    /// The maturity the round trip compares on is only the helper's because
    /// `TwentiethIMM` snaps both to the same twentieth: the helper's schedule
    /// ends a tenor past `today + settlementDays` (`defaultprobabilityhelpers
    /// .cpp:90-92`) and the round trip's a tenor past `today` (`:205`).
    ///
    /// `next_twentieth` rolls to the twentieth *on or after* its argument
    /// (`schedule.rs:956-958`), so the two agree everywhere except when
    /// `today + n*Years` lands exactly on an IMM twentieth - there the helper's
    /// one-day-later variant rolls a full quarter and the round trip would
    /// silently compare a three-month-shorter contract against the curve node.
    /// This asserts the agreement instead of documenting it, so a future
    /// evaluation date on that boundary fails loudly.
    #[test]
    fn the_helper_and_the_round_trip_agree_on_the_imm_maturity() {
        let fixture = fixture();
        for (helper, n) in fixture.helpers.iter().zip(TENORS) {
            let schedule = round_trip_schedule(today(), Period::new(n, TimeUnit::Years));
            assert_eq!(
                helper.latest_date(),
                rolled_back_date(&schedule),
                "the {n}Y helper's pillar and the round-trip contract's maturity diverge"
            );
        }
    }

    /// `testSingleInstrumentBootstrap` (`:344-378`): one helper is enough,
    /// because `BackwardFlat` needs a single point (`flat.rs`), so the two nodes
    /// a lone pillar lays down clear the driver's required-points guard
    /// (`iterativebootstrap.rs:153-158`). C++ asserts nothing beyond the
    /// bootstrap completing; the node count is added here to pin what makes it
    /// complete.
    #[test]
    fn a_single_helper_bootstraps() {
        let settings = settings_at(today());
        let discount = discount_curve(today());
        let helper = spread_helper(
            0.005,
            Period::new(2, TimeUnit::Years),
            0,
            &discount,
            &settings,
        );
        let curve = PiecewiseDefaultCurve::<HazardRate, BackwardFlat>::new(
            today(),
            vec![helper],
            day_counter(),
            BackwardFlat,
        )
        .unwrap();

        curve.calculate().unwrap();
        assert_eq!(
            curve.dates().unwrap().len(),
            2,
            "a lone pillar lays down the reference node and its own"
        );
    }

    /// Construction lays down no nodes and runs no solver; the first read
    /// bootstraps; a quote move invalidates the cache and the next read
    /// re-bootstraps to a wider curve (the C++ `LazyObject` contract that keeps
    /// the bootstrap out of the constructor).
    #[test]
    fn the_bootstrap_is_lazy_and_reruns_on_a_quote_change() {
        let settings = settings_at(today());
        let discount = discount_curve(today());
        let quote = shared(SimpleQuote::new(0.005));
        let helper = SpreadCdsHelper::new(
            Handle::new(Shared::clone(&quote) as Shared<dyn Quote>),
            Period::new(5, TimeUnit::Years),
            SETTLEMENT_DAYS,
            Target::new(),
            Frequency::Quarterly,
            BusinessDayConvention::Following,
            DateGeneration::TwentiethIMM,
            day_counter(),
            RECOVERY_RATE,
            discount,
            Shared::clone(&settings),
        )
        .unwrap();
        let curve = PiecewiseDefaultCurve::<HazardRate, BackwardFlat>::new(
            today(),
            vec![Shared::clone(&helper) as Shared<dyn DefaultProbabilityHelper>],
            day_counter(),
            BackwardFlat,
        )
        .unwrap();

        assert!(!curve.lazy.borrow().is_calculated());
        let first = curve
            .survival_probability_date(helper.latest_date(), false)
            .unwrap();
        assert!(curve.lazy.borrow().is_calculated());
        assert!(first < 1.0 && first > 0.0);

        quote.set_value(0.02);
        assert!(!curve.lazy.borrow().is_calculated());
        let second = curve
            .survival_probability_date(helper.latest_date(), false)
            .unwrap();
        assert!(
            second < first,
            "a wider spread must lower the survival probability: {second} vs {first}"
        );
    }

    /// Re-prices `make`'s helper on a dirty curve, the issue #1350 scenario.
    ///
    /// Bootstraps a single-helper curve on `quote_before`, moves the helper's
    /// own quote to `quote_after`, then calls `implied_quote()` directly while
    /// the curve is stale. Returns that value together with `implied_quote()`
    /// of a fresh helper bootstrapped on `quote_after` from the start.
    fn implied_quote_on_dirty_curve(
        quote_before: Real,
        quote_after: Real,
        make: impl Fn(Handle<dyn Quote>) -> Shared<dyn DefaultProbabilityHelper>,
    ) -> (Real, Real) {
        let bootstrap = |quote: &Shared<SimpleQuote>| {
            let helper = make(Handle::new(Shared::clone(quote) as Shared<dyn Quote>));
            let curve = PiecewiseDefaultCurve::<HazardRate, BackwardFlat>::new(
                today(),
                vec![Shared::clone(&helper)],
                day_counter(),
                BackwardFlat,
            )
            .unwrap();
            curve.calculate().unwrap();
            (helper, curve)
        };

        let quote = shared(SimpleQuote::new(quote_before));
        let (helper, _curve) = bootstrap(&quote);
        quote.set_value(quote_after);
        let dirty = helper.implied_quote().unwrap();

        let (fresh_helper, _fresh_curve) = bootstrap(&shared(SimpleQuote::new(quote_after)));
        (dirty, fresh_helper.implied_quote().unwrap())
    }

    /// A direct `implied_quote()` on a dirty curve re-bootstraps first and
    /// prices on the converged curve, as C++ does (`lazyobject.hpp:257-258`),
    /// rather than re-borrowing the contract from inside the nested bootstrap.
    #[test]
    fn spread_implied_quote_on_a_dirty_curve_reprices_the_new_quote() {
        let settings = settings_at(today());
        let discount = discount_curve(today());
        let (dirty, fresh) = implied_quote_on_dirty_curve(0.005, 0.02, |quote| {
            SpreadCdsHelper::new(
                quote,
                Period::new(5, TimeUnit::Years),
                SETTLEMENT_DAYS,
                Target::new(),
                Frequency::Quarterly,
                BusinessDayConvention::Following,
                DateGeneration::TwentiethIMM,
                day_counter(),
                RECOVERY_RATE,
                discount.clone(),
                Shared::clone(&settings),
            )
            .unwrap() as Shared<dyn DefaultProbabilityHelper>
        });
        assert!((dirty - fresh).abs() < 1e-12, "{dirty} vs {fresh}");
        assert!((dirty - 0.02).abs() <= TOLERANCE, "{dirty}");
    }

    #[test]
    fn upfront_implied_quote_on_a_dirty_curve_reprices_the_new_quote() {
        let settings = settings_at(today());
        let discount = discount_curve(today());
        let (dirty, fresh) = implied_quote_on_dirty_curve(0.02, 0.04, |quote| {
            UpfrontCdsHelper::with_terms(
                quote,
                RUNNING_SPREAD,
                Period::new(5, TimeUnit::Years),
                SETTLEMENT_DAYS,
                Target::new(),
                Frequency::Quarterly,
                BusinessDayConvention::ModifiedFollowing,
                DateGeneration::CDS,
                Actual360::new(),
                RECOVERY_RATE,
                discount.clone(),
                UPFRONT_SETTLEMENT_DAYS,
                CdsHelperTerms::default(),
                Shared::clone(&settings),
            )
            .unwrap() as Shared<dyn DefaultProbabilityHelper>
        });
        assert!((dirty - fresh).abs() < 1e-12, "{dirty} vs {fresh}");
        assert!((dirty - 0.04).abs() <= TOLERANCE, "{dirty}");
    }

    const UPFRONT_QUOTES: [Real; 4] = [0.01, 0.02, 0.04, 0.06];
    const UPFRONT_TENORS: [i32; 4] = [2, 3, 5, 7];
    const RUNNING_SPREAD: Rate = 0.05;
    const UPFRONT_SETTLEMENT_DAYS: Natural = 3;

    /// The upfront fixture's conventions (`:234-247`), which differ from the
    /// spread one's in more than the quotation: the contracts roll on
    /// `DateGeneration::CDS` under `ModifiedFollowing`, accrue on `Actual360`
    /// with the last period including its end date, and pay a fixed 5% coupon
    /// while the quote is the upfront.
    fn upfront_helper(
        quote: Real,
        tenor: Period,
        discount: &Handle<dyn YieldTermStructure>,
        settings: &Shared<Settings<Date>>,
    ) -> Shared<dyn DefaultProbabilityHelper> {
        UpfrontCdsHelper::with_terms(
            Handle::new(shared(SimpleQuote::new(quote)) as Shared<dyn Quote>),
            RUNNING_SPREAD,
            tenor,
            SETTLEMENT_DAYS,
            Target::new(),
            Frequency::Quarterly,
            BusinessDayConvention::ModifiedFollowing,
            DateGeneration::CDS,
            Actual360::new(),
            RECOVERY_RATE,
            discount.clone(),
            UPFRONT_SETTLEMENT_DAYS,
            CdsHelperTerms {
                last_period_day_counter: Some(Actual360::with_last_day(true)),
                ..CdsHelperTerms::default()
            },
            Shared::clone(settings),
        )
        .expect("the CDS rule rolls every tenor quoted here")
            as Shared<dyn DefaultProbabilityHelper>
    }

    /// The round-trip contract's schedule (`:290-291`), from the protection
    /// start to the rolled CDS maturity.
    fn upfront_schedule(today: Date, tenor: Period) -> Schedule {
        Schedule::new(
            today + SETTLEMENT_DAYS,
            cds_maturity(today, tenor, DateGeneration::CDS)
                .unwrap()
                .expect("a live CDS maturity"),
            Period::try_from(Frequency::Quarterly).expect("a quarterly period"),
            Target::new(),
            BusinessDayConvention::ModifiedFollowing,
            BusinessDayConvention::Unadjusted,
            DateGeneration::CDS,
            false,
            Date::null(),
            Date::null(),
        )
    }

    /// The four upfront helpers of `testBootstrapFromUpfront` (`:252-266`) and
    /// the curve they bootstrap.
    fn upfront_fixture(settings: &Shared<Settings<Date>>) -> Fixture {
        upfront_fixture_with::<HazardRate, _>(settings, BackwardFlat)
    }

    fn upfront_fixture_with<T: CreditBootstrapTraits + 'static, I: Interpolator + 'static>(
        settings: &Shared<Settings<Date>>,
        interpolator: I,
    ) -> Fixture<T, I> {
        let discount = discount_curve(today());
        let helpers: Vec<Shared<dyn DefaultProbabilityHelper>> = UPFRONT_QUOTES
            .iter()
            .zip(UPFRONT_TENORS)
            .map(|(quote, n)| {
                upfront_helper(*quote, Period::new(n, TimeUnit::Years), &discount, settings)
            })
            .collect();
        let curve = PiecewiseDefaultCurve::<T, I>::new(
            today(),
            helpers.clone(),
            day_counter(),
            interpolator,
        )
        .unwrap();
        Fixture {
            settings: Shared::clone(settings),
            discount,
            helpers,
            curve,
        }
    }

    /// The reprice loop of `testBootstrapFromUpfront` (`:277-315`): each
    /// pillar's contract, rebuilt from the market conventions and priced off
    /// the bootstrapped curve, must return its own input upfront.
    ///
    /// The `includeTodaysCashFlows` write and its unwind are the C++ block's
    /// (`:278-281`), kept around the reprice alone so that what the flag holds
    /// outside it is the caller's business.
    fn assert_the_upfronts_reproduce<
        T: CreditBootstrapTraits + 'static,
        I: Interpolator + 'static,
    >(
        fixture: &Fixture<T, I>,
    ) {
        let curve: Handle<dyn DefaultProbabilityTermStructure> = Handle::new(Shared::clone(
            &fixture.curve,
        )
            as Shared<dyn DefaultProbabilityTermStructure>);
        let restore = fixture.settings.include_todays_cash_flows();
        fixture.settings.set_include_todays_cash_flows(Some(true));

        for (quote, n) in UPFRONT_QUOTES.iter().zip(UPFRONT_TENORS) {
            let tenor = Period::new(n, TimeUnit::Years);
            let mut cds = CreditDefaultSwap::with_upfront_and_terms(
                ProtectionSide::Buyer,
                1.0,
                *quote,
                RUNNING_SPREAD,
                upfront_schedule(today(), tenor),
                BusinessDayConvention::ModifiedFollowing,
                Actual360::new(),
                CdsTerms {
                    protection_start: Some(today() + SETTLEMENT_DAYS),
                    upfront_date: Some(Target::new().advance(
                        today(),
                        UPFRONT_SETTLEMENT_DAYS as Integer,
                        TimeUnit::Days,
                        BusinessDayConvention::ModifiedFollowing,
                        false,
                    )),
                    last_period_day_counter: Some(Actual360::with_last_day(true)),
                    trade_date: Some(today()),
                    ..CdsTerms::default()
                },
                Shared::clone(&fixture.settings),
            )
            .unwrap();
            let engine = MidPointCdsEngine::new(
                curve.clone(),
                RECOVERY_RATE,
                fixture.discount.clone(),
                Some(true),
                Shared::clone(&fixture.settings),
            );
            cds.base_mut()
                .set_pricing_engine(shared_mut(engine) as SharedMut<dyn PricingEngine>);

            let computed = cds.fair_upfront().unwrap();
            assert!(
                (computed - quote).abs() <= TOLERANCE,
                "failed to reproduce the fair upfront for the {n}Y credit-default swap: \
                 computed {computed}, input {quote}"
            );
        }
        fixture.settings.set_include_todays_cash_flows(restore);
    }

    /// `testBootstrapFromUpfront<HazardRate, BackwardFlat>` (`:230-317`).
    #[test]
    fn bootstrapped_curve_reproduces_the_input_cds_upfronts() {
        assert_the_upfronts_reproduce(&upfront_fixture(&settings_at(today())));
    }

    /// `testUpfrontBootstrap` (`:380-395`): the bootstrap runs with the
    /// caller's flag switched off and leaves it switched off afterwards.
    ///
    /// The bootstrap is forced before the reprice, which runs under a flag of
    /// its own: a curve first read inside that loop would be bootstrapped under
    /// the loop's `true`, and the assertion below would pin the loop's unwind
    /// rather than the helper's. C++ leaves it to the loop, so this is the
    /// stricter of the two.
    ///
    /// What this pins is the unwind, not the write. The C++ comment claims a
    /// `false` flag "would prevent the upfront from being used", but the flag
    /// only decides flows dated *on* the evaluation date
    /// (`cashflow.rs:94-113`), and this fixture has none: the upfront and its
    /// rebate settle three business days out and the first coupon later still.
    /// Removing the write from `implied_quote` leaves both upfront tests green.
    /// The write is ported for fidelity and pinned for its unwind
    /// (`the_cash_flow_flag_is_restored_when_the_contract_cannot_price`,
    /// defaultprobabilityhelpers.rs); no oracle here discriminates it.
    #[test]
    fn the_upfront_bootstrap_leaves_the_cash_flow_flag_as_it_found_it() {
        let settings = settings_at(today());
        settings.set_include_todays_cash_flows(Some(false));
        let fixture = upfront_fixture(&settings);

        fixture.curve.calculate().unwrap();
        assert_eq!(
            settings.include_todays_cash_flows(),
            Some(false),
            "the helper's own write must be unwound, not left on the caller's settings"
        );
        assert_the_upfronts_reproduce(&fixture);
        assert_eq!(settings.include_todays_cash_flows(), Some(false));
    }

    /// QuantLib `testLogLinearSurvivalConsistency`, defaultprobabilitycurves.cpp:338.
    #[test]
    fn loglinear_survival_reproduces_spread_and_upfront_quotes() {
        let fixture = fixture_with::<SurvivalProbability, _>(LogLinear);
        assert_the_spreads_reproduce(&fixture);
        let upfront =
            upfront_fixture_with::<SurvivalProbability, _>(&settings_at(today()), LogLinear);
        assert_the_upfronts_reproduce(&upfront);
        for curve in [&fixture.curve, &upfront.curve] {
            let data = curve.data().unwrap();
            assert_eq!(data[0], 1.0);
            assert!(
                data.windows(2)
                    .all(|pair| pair[1] > 0.0 && pair[1] <= pair[0])
            );
        }
    }

    #[test]
    fn loglinear_survival_single_helper_recalibrates_after_quote_change() {
        let settings = settings_at(today());
        let discount = discount_curve(today());
        let quote = shared(SimpleQuote::new(0.005));
        let helper = SpreadCdsHelper::new(
            Handle::new(Shared::clone(&quote) as Shared<dyn Quote>),
            Period::new(5, TimeUnit::Years),
            SETTLEMENT_DAYS,
            Target::new(),
            Frequency::Quarterly,
            BusinessDayConvention::Following,
            DateGeneration::TwentiethIMM,
            day_counter(),
            RECOVERY_RATE,
            discount,
            Shared::clone(&settings),
        )
        .unwrap();
        let curve = PiecewiseDefaultCurve::<SurvivalProbability, LogLinear>::new(
            today(),
            vec![Shared::clone(&helper) as Shared<dyn DefaultProbabilityHelper>],
            day_counter(),
            LogLinear,
        )
        .unwrap();
        assert!(!curve.lazy.borrow().is_calculated());
        let first = curve
            .survival_probability_date(helper.latest_date(), false)
            .unwrap();
        assert!(curve.lazy.borrow().is_calculated());
        assert_eq!(curve.dates().unwrap().len(), 2);
        assert!((helper.implied_quote().unwrap() - 0.005).abs() <= TOLERANCE);
        quote.set_value(0.02);
        assert!(!curve.lazy.borrow().is_calculated());
        let second = curve
            .survival_probability_date(helper.latest_date(), false)
            .unwrap();
        assert!(second < first);
        assert!((helper.implied_quote().unwrap() - 0.02).abs() <= TOLERANCE);
        assert_eq!(curve.data().unwrap()[0], 1.0);
        quote.set_value(-0.01);
        assert!(curve.calculate().is_err());
        assert!(!curve.lazy.borrow().is_calculated());
        quote.set_value(0.01);
        curve.calculate().unwrap();
        assert!((helper.implied_quote().unwrap() - 0.01).abs() <= TOLERANCE);
    }

    #[test]
    fn bootstrapped_loglinear_survival_feeds_the_isda_grid() {
        let fixture = fixture_with::<SurvivalProbability, _>(LogLinear);
        let credit = Handle::new(
            Shared::clone(&fixture.curve) as Shared<dyn DefaultProbabilityTermStructure>
        );
        assert_eq!(
            isda_node_grid(&fixture.discount, &credit, today() + 10_000).unwrap(),
            fixture.curve.dates().unwrap()
        );
    }

    const MOVING_SETTLEMENT_DAYS: Natural = 1;

    fn business_days_after(date: Date, days: Integer) -> Date {
        Target::new().advance(
            date,
            days,
            TimeUnit::Days,
            BusinessDayConvention::Following,
            false,
        )
    }

    /// The `testBootstrapFromSpread` helpers (`:154-186`) on `settings`, with
    /// their quotes, so a second curve can be built over its own helpers.
    fn spread_helpers_on(
        settings: &Shared<Settings<Date>>,
        discount: &Handle<dyn YieldTermStructure>,
    ) -> (
        Vec<Shared<SimpleQuote>>,
        Vec<Shared<dyn DefaultProbabilityHelper>>,
    ) {
        let quotes: Vec<_> = QUOTES
            .iter()
            .map(|q| shared(SimpleQuote::new(*q)))
            .collect();
        let helpers = quotes
            .iter()
            .zip(TENORS)
            .map(|(quote, n)| {
                SpreadCdsHelper::new(
                    Handle::new(Shared::clone(quote) as Shared<dyn Quote>),
                    Period::new(n, TimeUnit::Years),
                    SETTLEMENT_DAYS,
                    Target::new(),
                    Frequency::Quarterly,
                    BusinessDayConvention::Following,
                    DateGeneration::TwentiethIMM,
                    day_counter(),
                    RECOVERY_RATE,
                    discount.clone(),
                    Shared::clone(settings),
                )
                .unwrap() as Shared<dyn DefaultProbabilityHelper>
            })
            .collect();
        (quotes, helpers)
    }

    fn moving_settings() -> Shared<Settings<Date>> {
        let settings = settings_at(today());
        settings.set_include_todays_cash_flows(Some(true));
        settings
    }

    fn moving_curve(
        helpers: Vec<Shared<dyn DefaultProbabilityHelper>>,
        settings: &Shared<Settings<Date>>,
    ) -> Shared<PiecewiseDefaultCurve<HazardRate, BackwardFlat>> {
        PiecewiseDefaultCurve::moving(
            MOVING_SETTLEMENT_DAYS,
            Target::new(),
            helpers,
            day_counter(),
            BackwardFlat,
            settings.clone(),
        )
        .unwrap()
    }

    /// A helper quoting the survival probability to a fixed date, which does
    /// not observe the evaluation date.
    struct FixedSurvivalHelper {
        base: DefaultProbabilityHelperBase,
        date: Date,
    }

    impl AsObservable for FixedSurvivalHelper {
        fn observable(&self) -> &Observable {
            self.base.observable()
        }
    }

    impl DefaultProbabilityHelper for FixedSurvivalHelper {
        fn base(&self) -> &DefaultProbabilityHelperBase {
            &self.base
        }

        fn implied_quote(&self) -> QlResult<Real> {
            self.base
                .term_structure()?
                .survival_probability_date(self.date, true)
        }
    }

    fn fixed_survival_helpers() -> Vec<Shared<dyn DefaultProbabilityHelper>> {
        [(1, 0.99), (2, 0.97)]
            .into_iter()
            .map(|(years, probability)| {
                let base = DefaultProbabilityHelperBase::new(Handle::new(shared(SimpleQuote::new(
                    probability,
                ))
                    as Shared<dyn Quote>));
                let date = today() + Period::new(years, TimeUnit::Years);
                base.set_latest_date(date);
                base.set_pillar_date(date);
                shared(FixedSurvivalHelper { base, date }) as Shared<dyn DefaultProbabilityHelper>
            })
            .collect()
    }

    /// After a 15-business-day roll the moving curve's reference date is the
    /// rolled evaluation date advanced by its settlement days, and its nodes
    /// match a curve built fresh with [`new`](PiecewiseDefaultCurve::new) at
    /// that date over its own helpers on the same settings.
    #[test]
    fn rolled_moving_curve_matches_a_fresh_fixed_curve() {
        let settings = moving_settings();
        let discount = discount_curve(today());
        let (_, helpers) = spread_helpers_on(&settings, &discount);
        let curve = moving_curve(helpers, &settings);
        curve.calculate().unwrap();

        let new_today = business_days_after(today(), 15);
        settings.set_evaluation_date(new_today);
        let reference = business_days_after(new_today, MOVING_SETTLEMENT_DAYS as Integer);
        assert_eq!(TermStructure::reference_date(&*curve).unwrap(), reference);

        let (_, fresh_helpers) = spread_helpers_on(&settings, &discount);
        let fresh = PiecewiseDefaultCurve::<HazardRate, BackwardFlat>::new(
            reference,
            fresh_helpers.clone(),
            day_counter(),
            BackwardFlat,
        )
        .unwrap();
        let (rolled_nodes, fresh_nodes) = (curve.nodes().unwrap(), fresh.nodes().unwrap());
        assert_eq!(rolled_nodes.len(), fresh_nodes.len());
        for ((rolled_date, rolled), (fresh_date, value)) in rolled_nodes.iter().zip(&fresh_nodes) {
            assert_eq!(rolled_date, fresh_date);
            assert!((rolled - value).abs() <= 1.0e-10, "{rolled} vs {value}");
        }
        for helper in &fresh_helpers {
            let date = helper.latest_date();
            let rolled = curve.survival_probability_date(date, false).unwrap();
            let value = fresh.survival_probability_date(date, false).unwrap();
            assert!((rolled - value).abs() <= 1.0e-10, "{rolled} vs {value}");
        }
    }

    /// Fixed-date helpers do not observe the evaluation date, so only the
    /// curve's own eval-date registration invalidates it: after a roll the
    /// pillars stay put while the reference date moves.
    #[test]
    fn moving_curve_with_fixed_date_helpers_rebootstraps_on_roll() {
        let settings = moving_settings();
        let curve = moving_curve(fixed_survival_helpers(), &settings);
        let dates = curve.dates().unwrap();
        let data = curve.data().unwrap();
        assert_eq!(dates[0], business_days_after(today(), 1));

        let new_today = business_days_after(today(), 15);
        settings.set_evaluation_date(new_today);
        assert!(!curve.lazy.borrow().is_calculated());

        let new_dates = curve.dates().unwrap();
        assert_eq!(new_dates[0], business_days_after(new_today, 1));
        assert_eq!(new_dates[1..], dates[1..]);
        assert!(curve.data().unwrap()[1] > data[1]);
    }

    /// The evaluation date is an upstream input of a moving curve only: over
    /// fixed-date helpers, an observer wired through `register_upstream` hears
    /// a date roll from the moving curve and not from the fixed one.
    #[test]
    fn register_upstream_includes_the_evaluation_date_only_when_moving() {
        use crate::test_support::{Flag, as_observer};
        let settings = moving_settings();
        let moving = moving_curve(fixed_survival_helpers(), &settings);
        let fixed = PiecewiseDefaultCurve::<HazardRate, BackwardFlat>::new(
            today(),
            fixed_survival_helpers(),
            day_counter(),
            BackwardFlat,
        )
        .unwrap();
        let (moving_flag, fixed_flag) = (Flag::new(), Flag::new());
        moving.register_upstream(&as_observer(&moving_flag));
        fixed.register_upstream(&as_observer(&fixed_flag));

        settings.set_evaluation_date(business_days_after(today(), 15));
        assert!(
            Flag::is_up(&moving_flag),
            "moving curve upstream missed the roll"
        );
        assert!(
            !Flag::is_up(&fixed_flag),
            "fixed curve upstream heard the roll"
        );
    }

    /// `testObservability` (`piecewiseyieldcurve.cpp:832-875`) on the moving
    /// credit curve: a quote change notifies and recalculates, a date change
    /// notifies, and a second date change without an intervening
    /// recalculation does not.
    #[test]
    fn moving_curve_observability() {
        use crate::test_support::{Flag, as_observer};
        let settings = moving_settings();
        let discount = discount_curve(today());
        let (quotes, helpers) = spread_helpers_on(&settings, &discount);
        let curve = moving_curve(helpers.clone(), &settings);
        curve.lazy.borrow_mut().forward_first_notification_only();
        let flag = Flag::new();
        curve.register_observer(&as_observer(&flag));

        for (quote, helper) in quotes.iter().zip(&helpers) {
            let date = helper.latest_date();
            let survival = curve.survival_probability_date(date, false).unwrap();
            Flag::lower(&flag);
            quote.set_value(quote.value().unwrap() * 1.01);
            assert!(Flag::is_up(&flag), "not notified of quote change");
            assert_ne!(
                curve.survival_probability_date(date, false).unwrap(),
                survival,
                "no recalculation"
            );
            quote.set_value(quote.value().unwrap() / 1.01);
        }

        curve.max_date();
        Flag::lower(&flag);
        settings.set_evaluation_date(business_days_after(today(), 15));
        assert!(Flag::is_up(&flag), "not notified of date change");

        Flag::lower(&flag);
        settings.set_evaluation_date(today());
        assert!(
            !Flag::is_up(&flag),
            "notified of date change without an intervening recalculation"
        );
    }

    /// An unset evaluation date is an `Err` on the first read, never a
    /// system-clock fallback (D10).
    #[test]
    fn moving_curve_without_an_evaluation_date_errs() {
        let settings = shared(Settings::<Date>::new());
        let curve = moving_curve(fixed_survival_helpers(), &settings);
        assert!(TermStructure::reference_date(&*curve).is_err());
        assert!(curve.calculate().is_err());
        assert!(curve.survival_probability(1.0, true).is_err());
    }

    const JUMPS: [Real; 2] = [0.999, 0.998];

    fn jump_dates() -> Vec<Date> {
        vec![
            Date::new(31, Month::December, 2006),
            Date::new(31, Month::December, 2007),
        ]
    }

    fn jump_quotes(values: &[Real]) -> (Vec<Shared<SimpleQuote>>, Vec<Handle<dyn Quote>>) {
        let quotes: Vec<_> = values
            .iter()
            .map(|v| shared(SimpleQuote::new(*v)))
            .collect();
        let handles = quotes
            .iter()
            .map(|q| Handle::new(Shared::clone(q) as Shared<dyn Quote>))
            .collect();
        (quotes, handles)
    }

    /// The `testBootstrapFromSpread` fixture over a curve built with jumps.
    fn jumped_fixture(values: &[Real]) -> (Vec<Shared<SimpleQuote>>, Fixture) {
        let settings = moving_settings();
        let discount = discount_curve(today());
        let (_, helpers) = spread_helpers_on(&settings, &discount);
        let (quotes, handles) = jump_quotes(values);
        let curve = PiecewiseDefaultCurve::with_jumps(
            today(),
            helpers.clone(),
            day_counter(),
            BackwardFlat,
            handles,
            jump_dates(),
        )
        .unwrap();
        let fixture = Fixture {
            settings,
            discount,
            helpers,
            curve,
        };
        (quotes, fixture)
    }

    /// The bootstrap prices every helper off the jump-adjusted survival
    /// probability, so a curve with jumps still reproduces its spreads.
    #[test]
    fn a_jumped_curve_reproduces_the_input_cds_spreads() {
        let (_, fixture) = jumped_fixture(&JUMPS);
        assert_the_spreads_reproduce(&fixture);
    }

    /// Unit jumps leave the bootstrap untouched: the curve equals the
    /// jump-free fixture curve.
    #[test]
    fn unit_jumps_reproduce_the_jump_free_curve() {
        let (_, jumped) = jumped_fixture(&[1.0, 1.0]);
        let plain = fixture();
        for t in [0.1, 0.5, 1.0, 1.5, 2.0, 3.0, 4.5] {
            let (a, b) = (
                jumped.curve.survival_probability(t, false).unwrap(),
                plain.curve.survival_probability(t, false).unwrap(),
            );
            assert!((a - b).abs() <= 1.0e-14, "t = {t}: {a} vs {b}");
        }
    }

    /// Survival multiplies in every jump before `t` on top of the
    /// bootstrapped nodes.
    #[test]
    fn survival_applies_the_jumps_over_the_bootstrapped_nodes() {
        let (_, fixture) = jumped_fixture(&JUMPS);
        let curve = &fixture.curve;
        let jump_times: Vec<Time> = jump_dates()
            .into_iter()
            .map(|date| TermStructure::time_from_reference(&**curve, date).unwrap())
            .collect();
        assert!(jump_times[1] < 2.0);
        for t in [0.1, 0.5, 1.0, 1.5, 2.0, 3.0, 4.5] {
            let expected: Real = jump_times
                .iter()
                .zip(JUMPS)
                .filter(|(time, _)| **time < t)
                .map(|(_, jump)| jump)
                .product();
            let ratio = curve.survival_probability(t, false).unwrap()
                / curve.survival_probability_impl(t).unwrap();
            assert!(
                (ratio - expected).abs() <= 1.0e-14 * expected,
                "t = {t}: {ratio} vs {expected}"
            );
        }
    }

    /// A jump quote is a bootstrap input: changing it invalidates the curve
    /// through its own updater, reaches `register_upstream` subscribers, and
    /// re-solves to different nodes that still reproduce the spreads.
    #[test]
    fn a_jump_quote_change_rebootstraps() {
        use crate::test_support::{Flag, as_observer};
        let (quotes, fixture) = jumped_fixture(&JUMPS);
        let curve = &fixture.curve;
        let flag = Flag::new();
        curve.register_upstream(&as_observer(&flag));
        let nodes = curve.data().unwrap();

        quotes[1].set_value(0.996);
        assert!(!curve.lazy.borrow().is_calculated());
        assert!(Flag::is_up(&flag), "upstream subscriber missed the jump");
        let rebuilt = curve.data().unwrap();
        assert_eq!(rebuilt.len(), nodes.len());
        assert!(
            nodes
                .iter()
                .zip(&rebuilt)
                .any(|(a, b)| (a - b).abs() > 1.0e-6),
            "nodes did not move"
        );
        assert_the_spreads_reproduce(&fixture);
    }

    /// After a roll, the moving curve's generated jump dates stay fixed while
    /// its jump times follow the new reference date (a C++ moving curve keeps
    /// its construction-time times, see the module divergence), and it matches
    /// a curve built fresh with the same jumps at the new reference date. The
    /// probe between the old and new first jump time tells the two apart.
    #[test]
    fn a_rolled_moving_jumped_curve_matches_a_fresh_fixed_one() {
        let settings = moving_settings();
        let discount = discount_curve(today());
        let (_, helpers) = spread_helpers_on(&settings, &discount);
        let curve = PiecewiseDefaultCurve::<HazardRate, BackwardFlat>::moving_with_jumps(
            MOVING_SETTLEMENT_DAYS,
            Target::new(),
            helpers,
            day_counter(),
            BackwardFlat,
            settings.clone(),
            jump_quotes(&JUMPS).1,
            Vec::new(),
        )
        .unwrap();
        assert_eq!(curve.jump_dates(), jump_dates());
        let old_reference = TermStructure::reference_date(&*curve).unwrap();
        let times = curve.jump_times().unwrap();
        curve.calculate().unwrap();

        settings.set_evaluation_date(business_days_after(today(), 15));
        assert!(!curve.lazy.borrow().is_calculated());
        let reference = TermStructure::reference_date(&*curve).unwrap();
        assert_eq!(curve.jump_dates(), jump_dates());
        let new_times = curve.jump_times().unwrap();
        for ((old, new), date) in times.iter().zip(&new_times).zip(jump_dates()) {
            assert!((old - day_counter().year_fraction(old_reference, date)).abs() <= 1.0e-14);
            assert!((new - day_counter().year_fraction(reference, date)).abs() <= 1.0e-14);
        }
        assert!(new_times[0] < times[0]);

        let (_, fresh_helpers) = spread_helpers_on(&settings, &discount);
        let fresh = PiecewiseDefaultCurve::<HazardRate, BackwardFlat>::with_jumps(
            reference,
            fresh_helpers,
            day_counter(),
            BackwardFlat,
            jump_quotes(&JUMPS).1,
            jump_dates(),
        )
        .unwrap();
        let probe = 0.5 * (times[0] + new_times[0]);
        for t in [probe, 0.1, 1.0, 1.5, 2.0, 3.0, 4.5] {
            let (a, b) = (
                curve.survival_probability(t, false).unwrap(),
                fresh.survival_probability(t, false).unwrap(),
            );
            assert!((a - b).abs() <= 1.0e-10, "t = {t}: {a} vs {b}");
        }
    }
}

#[cfg(test)]
#[path = "isdahelper_tests.rs"]
mod isdahelper_tests;