// NEW tests appended to the byte-bound frozen22 integration fixture.
// Hardware/SP/root/register/clock progression remains MODELED_ONLY.
unsafe impl turkos_os_k1080_wait_main::bridge::K1080MainBackend for B {
    fn k1080_execution(&self) -> os_k1060_context::Execution {
        self.bank
            .handoff()
            .bank()
            .with_backend_observation(os_k1060_context::Backend::execution)
    }
    fn k1080_target_wire(
        &self,
        p: &Self::Prepared,
    ) -> Result<(os_k1060_context::Image, u64), wait::Error> {
        let before = <Self as os_k1060_queue::Backend>::execution(self);
        if before.cpu != 0 || !before.masked || before.in_irq || before.thread.is_some() {
            return Err(wait::Error::Context);
        }
        let t = p.handoff.as_ref().ok_or(wait::Error::State)?;
        if p.arrived || p.nonce == 0 || p.nonce != t.nonce() {
            return Err(wait::Error::State);
        }
        let image = self
            .bank
            .handoff()
            .target_image(t)
            .map_err(|_| wait::Error::Stale)?;
        self.bank.handoff().bank().with_backend_observation(|d| {
            let drift = d.cpu.borrow().main_wire_drift;
            if drift == 1 {
                d.inner.hardware.borrow_mut().cpu = 1;
                core::mem::forget(d.inner.table.borrow_mut());
            }
            if drift == 3 {
                d.root.set(d.root.get() + 4096);
                core::mem::forget(d.inner.table.borrow_mut());
            }
        });
        Ok((image, t.nonce()))
    }
    fn k1080_bootstrap_wire(
        &self,
        p: &Self::ReturnPrepared,
    ) -> Result<os_k1060_context::Cooperative, wait::Error> {
        let e = <Self as os_k1060_queue::Backend>::execution(self);
        if e.cpu != 0
            || !e.masked
            || e.in_irq
            || e.thread.is_some()
            || p.nonce == 0
            || p.observed
            || p.token.is_none()
        {
            return Err(wait::Error::Context);
        }
        let result = self
            .bank
            .with_return_observation(|r| {
                r.map(|r| {
                    let mut f = os_k1060_context::Cooperative::EMPTY;
                    f.sp = r.expected.sp;
                    f.x19_x30 = r.expected.x19_x30;
                    f.q = r.expected.q;
                    f.fpcr = r.expected.fpcr;
                    f.fpsr = r.expected.fpsr;
                    f
                })
            })
            .ok_or(wait::Error::State);
        self.bank.handoff().bank().with_backend_observation(|d| {
            if d.cpu.borrow().main_wire_drift == 2 {
                d.inner.hardware.borrow_mut().cpu = 1;
                core::mem::forget(d.inner.table.borrow_mut());
            }
            if d.cpu.borrow().main_wire_drift == 4 {
                d.root.set(d.root.get() + 4096);
                core::mem::forget(d.inner.table.borrow_mut());
            }
        });
        result
    }
}
fn main_capture(s: &System) -> os_k1060_context::Capture {
    s.waits
        .with_backend_observation(|b| b.with_queue_observation(capture))
}
fn main_physical(s: &mut System, image: os_k1060_context::Image, nonce: u64) {
    s.waits.with_backend_observation(|bridge| {
        bridge.with_queue_observation(|q| {
            q.queue().with_retained_observation(|p| {
                q.queue().with_backend_observation(|b| {
                    model::physical_step(b.bank.handoff(), p.unwrap().handoff.as_ref().unwrap());
                })
            });
        })
    });
    let sp = s.hardware.borrow().sp;
    let candidates = s.waits.with_backend_observation(|bridge| {
        bridge.with_queue_observation(|q| {
            q.queue().with_backend_observation(|b| {
                b.bank.handoff().bank().with_backend_observation(|d| {
                    s.ids
                        .iter()
                        .filter(|id| {
                            let l = d.inner.table.borrow().record(**id).unwrap().layout;
                            sp >= l.usable_bottom() && sp <= l.usable_top()
                        })
                        .copied()
                        .collect::<Vec<_>>()
                })
            })
        })
    });
    assert_eq!(candidates.len(), 1);
    let target = candidates[0];
    s.hardware.borrow_mut().current = Some(target);
    let ordinal = s.ids.iter().position(|id| *id == target).unwrap();
    assert_eq!(state(s, ordinal), State::Ready); // Actual Table not activated yet.
    s.hardware.borrow_mut().sp = image.sp() - 64;
    s.cpu.borrow_mut().nonce = nonce;
    s.cpu.borrow_mut().registers = Some(model::saved::Backend::expected(image));
}
fn main_cooperate(s: &mut System) -> os_k1060_queue::Handle {
    if s.hardware.borrow().current.is_some() {
        main_capture(s);
    }
    let token = s.waits.os_k1080_main_select().unwrap();
    let (token, image, nonce) = s.waits.os_k1080_main_depart(token).ok().unwrap();
    main_physical(s, image, nonce);
    assert!(
        s.waits
            .os_k1080_physical_execution()
            .unwrap()
            .current
            .is_some()
    );
    s.waits.os_k1080_main_landed(token).ok().unwrap()
}
fn main_return(s: &mut System) {
    let capture = main_capture(s);
    let token = s.waits.os_k1080_main_return(capture).unwrap();
    let (token, frame) = s.waits.os_k1080_main_return_depart(token).ok().unwrap();
    assert_eq!(frame.sp, model::bootstrap().sp);
    s.waits
        .with_backend_observation(|b| b.with_queue_observation(returned));
    s.waits.os_k1080_main_return_landed(token).ok().unwrap();
}
#[test]
fn main_owned_selection_rejects_old_physical_target_and_retries_same_token() {
    let mut s = system();
    main_capture(&s);
    let token = s.waits.os_k1080_main_select().unwrap();
    let (token, image, nonce) = s.waits.os_k1080_main_depart(token).ok().unwrap();
    let inventory = s
        .waits
        .with_backend_observation(|b| b.with_queue_observation(ownership));
    assert!(s.waits.os_k1080_physical_execution().is_err());
    let token = match s.waits.os_k1080_main_landed(token) {
        Err(os_k1060_queue::HandoffSelectionError::Before(_, t)) => t,
        _ => panic!("old physical landing admitted"),
    };
    assert_eq!(
        s.waits
            .with_backend_observation(|b| b.with_queue_observation(ownership)),
        inventory
    );
    main_physical(&mut s, image, nonce);
    let target = s.hardware.borrow().current.unwrap();
    assert_eq!(
        s.waits.os_k1080_physical_execution().unwrap().current,
        Some(target)
    );
    let h = s.waits.os_k1080_main_landed(token).ok().unwrap();
    assert_eq!(
        s.waits
            .with_backend_observation(|b| b.with_queue_observation(|q| q
                .queue()
                .record(h)
                .unwrap()
                .thread)),
        target
    );
    assert_eq!(state(&s, 0), State::Ready);
}
#[test]
fn main_stage_blocks_other_selection_without_discarding_exact_wait_prepared() {
    let mut s = system();
    let token = arm(&mut s, 0, 1, None);
    let records = s.waits.records();
    let pins = s.ledger.pins.get();
    assert!(matches!(
        s.waits.os_k1080_main_select(),
        Err(wait::Error::Pending)
    ));
    assert_eq!(s.waits.records(), records);
    assert_eq!(s.ledger.pins.get(), pins);
    signal(&mut s, 101);
    let wait::Departure::Ready(token) = s.waits.depart(token).ok().unwrap() else {
        panic!()
    };
    s.waits.retire(token).ok().unwrap();
    assert_eq!(main_cooperate(&mut s), s.handles[1]);
}
#[test]
fn main_pure_cpu_mask_irq_gates_precede_poisoned_real_table_loan() {
    for bad in 0..3 {
        let mut s = system();
        s.waits.with_backend_observation(|b| {
            b.with_queue_observation(|q| {
                q.queue().with_backend_observation(|b| {
                    b.bank.handoff().bank().with_backend_observation(|d| {
                        core::mem::forget(d.inner.table.borrow_mut())
                    });
                })
            })
        });
        match bad {
            0 => s.hardware.borrow_mut().cpu = 1,
            1 => s.hardware.borrow_mut().daif = 0,
            _ => s.hardware.borrow_mut().in_irq = true,
        }
        assert!(s.waits.os_k1080_main_select().is_err());
        assert!(s.waits.os_k1080_thread(0).is_err());
        assert!(s.waits.os_k1080_landing_bounds().is_err());
        assert_eq!(s.ledger.pins.get(), 0);
    }
}
#[test]
fn main_two_owned_sleeps_allow_third_progress_and_ready_cooperation_after_one_cancel() {
    let mut s = system();
    let a = sleep(&mut s, 0, 1, None);
    let b = sleep(&mut s, 1, 2, None);
    assert_eq!(s.cpu.borrow().wait_takes, 2);
    assert_eq!(s.ledger.pins.get(), 2);
    assert_eq!(state(&s, 0), State::Sleeping);
    assert_eq!(state(&s, 1), State::Sleeping);
    assert_eq!(state(&s, 2), State::Running);
    let mut progress = 0u64;
    for i in 1..=32 {
        progress = progress.checked_add(i * i).unwrap();
    }
    assert_eq!(progress, 11440);
    s.waits.cancel(&b).unwrap();
    assert_eq!(main_cooperate(&mut s), s.handles[1]);
    assert_eq!(state(&s, 0), State::Sleeping);
    assert_eq!(s.ledger.pins.get(), 2);
    s.waits.retire(b).ok().unwrap();
    s.waits.cancel(&a).unwrap();
    s.waits.retire(a).ok().unwrap();
    assert_eq!(s.cpu.borrow().wait_resolves, 2);
    assert_eq!(s.ledger.pins.get(), 0);
}
#[test]
fn main_bootstrap_return_refuses_real_terminal_pin_until_actual_retirement() {
    let mut s = system();
    let token = arm(&mut s, 0, 1, None);
    signal(&mut s, 101);
    let wait::Departure::Ready(token) = s.waits.depart(token).ok().unwrap() else {
        panic!()
    };
    let capture = main_capture(&s);
    let inventory = s
        .waits
        .with_backend_observation(|b| b.with_queue_observation(ownership));
    assert!(matches!(
        s.waits.os_k1080_main_return(capture),
        Err(wait::Error::Pending)
    ));
    assert_eq!(
        s.waits
            .with_backend_observation(|b| b.with_queue_observation(ownership)),
        inventory
    );
    assert_eq!(s.ledger.pins.get(), 1);
    s.waits.retire(token).ok().unwrap();
    s.waits.service(&mut s.ingress).unwrap();
    main_return(&mut s);
    assert_eq!(state(&s, 0), State::Dead);
    assert_eq!(s.hardware.borrow().current, None);
    assert_eq!(s.ledger.pins.get(), 0);
}
#[test]
fn main_cleanup_retires_exact_real_members_and_all_twelve_modeled_stack_pages() {
    let mut s = system();
    main_return(&mut s);
    for _ in 0..2 {
        main_cooperate(&mut s);
        main_return(&mut s);
    }
    assert!(s.waits.os_k1080_cleanup_ready().is_err());
    for ordinal in 0..3 {
        match s.waits.os_k1080_main_retire(ordinal) {
            Ok(()) => {}
            Err((e, actual)) => panic!(
                "retire {ordinal}: {e:?}, member retained={}",
                actual.is_some()
            ),
        }
    }
    s.waits.os_k1080_cleanup_ready().unwrap();
    assert_eq!(
        s.waits
            .with_backend_observation(|b| b.with_queue_observation(ownership)),
        (0, 0, 0)
    );
    assert_eq!(s.ledger.dropped.get(), 0);
}
#[test]
fn main_successful_wire_callback_drift_keeps_actual_lookup_before_poisoned_owner_read() {
    let mut s = system();
    main_capture(&s);
    let token = s.waits.os_k1080_main_select().unwrap();
    let nonce = token.nonce();
    s.cpu.borrow_mut().main_wire_drift = 1;
    assert!(matches!(
        s.waits.os_k1080_main_depart(token),
        Err(os_k1060_queue::HandoffSelectionError::Quarantined(_))
    ));
    assert_eq!(s.hardware.borrow().cpu, 1);
    assert!(s.waits.with_backend_observation(|b| b.retained_failure()));
    assert_eq!(
        s.waits
            .with_backend_observation(|b| b.os_k1080_retained_selection_nonce()),
        Some(nonce)
    );
    assert_eq!(s.hardware.borrow().pins, 3);
    assert_eq!(s.hardware.borrow().stack_pages, 12);
}
#[test]
fn main_successful_bootstrap_wire_drift_keeps_actual_after_lookup_before_poisoned_owner_read() {
    let mut s = system();
    let capture = main_capture(&s);
    let token = s.waits.os_k1080_main_return(capture).unwrap();
    s.cpu.borrow_mut().main_wire_drift = 2;
    let actual = match s.waits.os_k1080_main_return_depart(token) {
        Err(turkos_os_k1080_wait_main::bridge::K1080MainReturnFailure::After(
            wait::Error::Context,
            actual,
        )) => actual,
        _ => panic!("bootstrap drift admitted or falsely called before"),
    };
    assert!(actual.nonce() > 0);
    assert_eq!(s.hardware.borrow().cpu, 1);
    assert!(s.waits.with_backend_observation(|b| b.retained_failure()));
    assert_eq!(s.hardware.borrow().pins, 3);
    assert_eq!(s.hardware.borrow().stack_pages, 12);
}
#[test]
fn main_inert_old_lookup_refuses_reused_generation_without_resurrecting_consumed_token() {
    let mut s = system();
    let token = arm(&mut s, 0, 1, None);
    let old = s.waits.os_k1080_inert_lookup(&token).unwrap();
    signal(&mut s, 101);
    let wait::Departure::Ready(token) = s.waits.depart(token).ok().unwrap() else {
        panic!()
    };
    let generation = token.generation();
    s.waits.retire(token).ok().unwrap();
    s.waits.service(&mut s.ingress).unwrap();
    let token = arm(&mut s, 0, 1, None);
    assert!(token.generation() > generation);
    let records = s.waits.records();
    let pins = s.ledger.pins.get();
    assert_eq!(
        s.waits.os_k1080_check_old_lookup(&old),
        Err(wait::Error::Stale)
    );
    assert_eq!(s.waits.records(), records);
    assert_eq!(s.ledger.pins.get(), pins);
    s.waits.cancel(&token).unwrap();
    s.waits.retire(token).ok().unwrap();
}
#[test]
fn main_successful_target_root_drift_is_checked_even_when_authority_cpu_mask_current_match() {
    let mut s = system();
    main_capture(&s);
    let token = s.waits.os_k1080_main_select().unwrap();
    let nonce = token.nonce();
    s.cpu.borrow_mut().main_wire_drift = 3;
    assert!(matches!(
        s.waits.os_k1080_main_depart(token),
        Err(os_k1060_queue::HandoffSelectionError::Quarantined(_))
    ));
    assert_eq!(s.hardware.borrow().cpu, 0);
    assert_eq!(s.hardware.borrow().daif, 0x3c0);
    assert_eq!(
        s.waits
            .with_backend_observation(|b| b.os_k1080_retained_selection_nonce()),
        Some(nonce)
    );
    assert_eq!(s.hardware.borrow().pins, 3);
    assert_eq!(s.hardware.borrow().stack_pages, 12);
}
#[test]
fn main_successful_bootstrap_root_drift_keeps_after_lookup_even_when_authority_matches() {
    let mut s = system();
    let capture = main_capture(&s);
    let token = s.waits.os_k1080_main_return(capture).unwrap();
    let nonce = token.nonce();
    s.cpu.borrow_mut().main_wire_drift = 4;
    let actual = match s.waits.os_k1080_main_return_depart(token) {
        Err(turkos_os_k1080_wait_main::bridge::K1080MainReturnFailure::After(
            wait::Error::Context,
            actual,
        )) => actual,
        _ => panic!("bootstrap root drift admitted"),
    };
    assert_eq!(actual.nonce(), nonce);
    assert_eq!(s.hardware.borrow().cpu, 0);
    assert_eq!(s.hardware.borrow().daif, 0x3c0);
    assert!(s.waits.with_backend_observation(|b| b.retained_failure()));
    assert_eq!(s.hardware.borrow().pins, 3);
    assert_eq!(s.hardware.borrow().stack_pages, 12);
}