Skip to main content

zumen_base/
cx.rs

1//! 予算・診断・中断の合図を運ぶ文脈(決定 0008)。
2
3use crate::budget::{Budget, Exceeded, Kind, Limit};
4use crate::cancel::CancelToken;
5use crate::codes;
6use crate::diag::{Diagnostic, DiagnosticEvents, Diagnostics, EventCapture};
7
8/// 作業をする関数すべてに、明示的に渡す文脈。thread_local の上限の代わり
9#[derive(Debug)]
10pub struct Cx<'a> {
11    /// 予算
12    pub budget: &'a mut Budget,
13    /// 診断
14    pub diag: &'a mut Diagnostics,
15    /// 中断の合図
16    pub cancel: &'a CancelToken,
17}
18
19/// 処理を止める理由
20#[derive(Clone, Copy, Debug, PartialEq, Eq)]
21pub enum Stop {
22    /// 予算の上限を超えた
23    Exceeded(Exceeded),
24    /// 中断の合図を受けた
25    Cancelled,
26    /// 時間の上限に達した。止まる所は環境で変わる(決定 0010)
27    TimedOut,
28}
29
30impl Stop {
31    /// この理由を表す診断
32    pub fn to_diagnostic(&self) -> Diagnostic {
33        match self {
34            Stop::Exceeded(exceeded) => exceeded.to_diagnostic(),
35            Stop::Cancelled => Diagnostic::new(codes::CALL_REQUEST_CANCELLED),
36            Stop::TimedOut => Diagnostic::new(codes::BUDGET_TIME_EXCEEDED),
37        }
38    }
39}
40
41impl From<Exceeded> for Stop {
42    fn from(exceeded: Exceeded) -> Self {
43        Stop::Exceeded(exceeded)
44    }
45}
46
47impl<'a> Cx<'a> {
48    /// 文脈を作る
49    pub fn new(budget: &'a mut Budget, diag: &'a mut Diagnostics, cancel: &'a CancelToken) -> Self {
50        Self {
51            budget,
52            diag,
53            cancel,
54        }
55    }
56
57    /// コードの決まった所で呼ぶ。中断の合図を確かめてから、予算を使う
58    pub fn check(&mut self, kind: Kind, amount: u64) -> Result<(), Stop> {
59        if let Some(stop) = self.diag.collection_stop() {
60            return Err(stop);
61        }
62        if let Some(stop) = self.cancel.stop() {
63            return Err(stop);
64        }
65        self.budget.spend(kind, amount).map_err(Stop::from)
66    }
67
68    /// 入れ子に 1 つ入る
69    pub fn enter(&mut self) -> Result<(), Stop> {
70        self.check(Kind::Depth, 1)
71    }
72
73    /// 入れ子を 1 つ出る
74    pub fn leave(&mut self) {
75        self.budget.leave(1);
76    }
77
78    /// 診断を足す
79    pub fn report(&mut self, diagnostic: Diagnostic) {
80        if self.diag.collection_stop().is_some() {
81            return;
82        }
83        if let Err(stop) = self
84            .diag
85            .preflight_event(&diagnostic, self.budget, self.cancel)
86        {
87            self.diag.stop_record_order(stop, diagnostic);
88            return;
89        }
90        if let Some(amount) = self.diag.record_order_work(&diagnostic)
91            && let Err(stop) = self.check(Kind::Work, amount)
92        {
93            self.diag.stop_record_order(stop, diagnostic);
94            return;
95        }
96        self.diag.record_event(&diagnostic);
97        self.diag.report(diagnostic);
98    }
99
100    /// 処理中に報告した診断を、集約前の明細と場所を持たない集計として受け取る。
101    ///
102    /// [`Cx::report`] の報告を捕捉し、`diag` の `max_places` によらず元の値と場所を保つ。
103    /// 明細は入力位置順の先頭 `limit` 件とし、同じ位置は報告順にする。
104    /// 集計の代表値はもっとも早い入力位置の報告から採り、発生件数は診断の `count` を足す。
105    /// 入れ子の呼び出しでは、内外がそれぞれの処理中の報告を捕捉する。
106    /// 深さ・収集・整列・確保を予算で数え、明細の上限に達しても集計と中断の確認を続ける。
107    /// 停止は処理の最後に報告された場合も返す。集約済みの診断の転送は重ねて捕捉しない。
108    pub fn with_diagnostic_events<T, E: From<Stop>>(
109        &mut self,
110        limit: u64,
111        operation: impl FnOnce(&mut Cx<'_>) -> Result<T, E>,
112    ) -> Result<(T, DiagnosticEvents), E> {
113        if let Err(stop) = self.enter() {
114            if self.diag.collection_stop().is_none() {
115                self.diag.stop_record_order(stop, stop.to_diagnostic());
116            }
117            return Err(stop.into());
118        }
119        let allocation = self.check(Kind::DecodedBytes, EventCapture::LOGICAL_BYTES);
120        if let Err(stop) = allocation {
121            self.leave();
122            if self.diag.collection_stop().is_none() {
123                self.diag.stop_record_order(stop, stop.to_diagnostic());
124            }
125            return Err(stop.into());
126        }
127        let parent = self.diag.events.take();
128        self.diag.events = Some(Box::new(EventCapture::new(limit, parent)));
129        let result = operation(self);
130        let stop = self.diag.collection_stop();
131        let capture = self.diag.events.take();
132        self.leave();
133        let Some(mut capture) = capture else {
134            // 処理が収集先そのものを置き換えた場合にも、パニックしない。
135            return result.map(|value| (value, DiagnosticEvents::default()));
136        };
137        self.diag.events = capture.parent.take();
138        if let Some(stop) = stop {
139            return Err(stop.into());
140        }
141        let value = result?;
142        match capture.finish(self.budget, self.cancel) {
143            Ok(events) => Ok((value, events)),
144            Err(stop) => {
145                self.diag.stop_record_order(stop, stop.to_diagnostic());
146                Err(stop.into())
147            }
148        }
149    }
150
151    /// 処理中の診断を、レコードの入力順でまとめてから届ける(決定 0009)。
152    ///
153    /// 診断は [`Cx::report`] で足す。処理中の `diag.iter()` は届いた順になる。
154    /// 入れ子は同じ収集先を使い、もっとも外側の呼び出しが返すときに入力順で届ける。
155    /// レコード番号のある診断はその番号順、バイト範囲だけの診断はその後に開始位置順、位置のない診断は最後にする。
156    /// 同じ位置では届いた順にする。値も先頭の診断から採る。
157    /// 場所は収集中も `max_places` 件までにし、0 件でも診断の順を保つ。
158    /// 収集・場所の移動・最後の整列と転送を Work に数える。途中で止まっても、収集済みの診断は届ける。
159    pub fn with_diagnostics_in_record_order<T, E: From<Stop>>(
160        &mut self,
161        operation: impl FnOnce(&mut Cx<'_>) -> Result<T, E>,
162    ) -> Result<T, E> {
163        if let Some(stop) = self.diag.collection_stop() {
164            return Err(stop.into());
165        }
166        if self.diag.is_collecting_in_record_order() {
167            let result = operation(self);
168            return match self.diag.collection_stop() {
169                Some(stop) => Err(stop.into()),
170                None => result,
171            };
172        }
173        let mut diagnostics = Diagnostics::in_record_order(self.diag.max_places());
174        diagnostics.events = self.diag.events.take();
175        let result = operation(&mut Cx::new(self.budget, &mut diagnostics, self.cancel));
176        let stop = diagnostics.collection_stop();
177        let events = diagnostics.events.take();
178        for diagnostic in diagnostics.into_vec() {
179            // 収集と転送の予算は支払ってあり、元の報告もすでに捕捉している。
180            self.diag.report(diagnostic);
181        }
182        self.diag.events = events;
183        match stop {
184            Some(stop) => Err(stop.into()),
185            None => result,
186        }
187    }
188}
189
190/// 一度最後まで通した処理が、予算と診断に及ぼした作用の記録(`docs/live.md`)。
191///
192/// [`Cx::record`] で作り、[`Cx::replay`] で、同じ処理をもう一度通したときと同じ作用を当てる。
193/// 常駐させた結果を使い回しても、使った予算と届く診断を、毎回作り直したときとそろえるために使う。
194/// 持つのは、単位ごとに使った量・深さの余裕・集約した診断で、処理の大きさではなく診断の種類の数に比例する。
195#[derive(Clone, Debug)]
196pub struct Replay {
197    /// 単位ごとに使った量([`Kind::ALL`] の順)。深さは出入りが釣り合ったときだけ記録するので 0 になる
198    spent: [u64; Kind::ALL.len()],
199    /// 記録したときの深さの余裕。上限がなかったときは `None`。途中の最も深い所は数えないので、
200    /// 当てるときにこれ以上の余裕があれば、同じ処理が深さの上限で止まらないと分かる
201    depth_room: Option<u64>,
202    /// 処理が届けた診断。届いた順にまとめ、場所は記録したときの `max_places` 件まで持つ
203    diagnostics: Diagnostics,
204}
205
206/// 単位の残り。上限がなければ `None`
207fn room(budget: &Budget, kind: Kind) -> Option<u64> {
208    match budget.limits().get(kind) {
209        Limit::Finite(limit) => Some(limit.saturating_sub(budget.used(kind))),
210        Limit::Unlimited => None,
211    }
212}
213
214impl Cx<'_> {
215    /// 診断を、届いた順にそのまままとめる収集先か。入力順の収集と明細の捕捉は、予算の使い方が収集先で変わる
216    fn plain(&self) -> bool {
217        !self.diag.is_collecting_in_record_order() && self.diag.events.is_none()
218    }
219
220    /// 処理を通し、最後まで通せたら、その作用を [`Replay`] に記録する。
221    ///
222    /// 処理は同じ予算と中断の合図で、空の別の収集先(`max_places` は同じ)に診断を集め、終わったら成否によらず
223    /// 届いた順に `diag` へ移す。届いた順にまとめる収集先では、まとめたものを移しても、元の報告を 1 件ずつ
224    /// 足したのと同じ件数・場所・値・順になる。移すのに予算は使わない(そのような収集先への報告は予算を使わない)。
225    ///
226    /// 記録は、処理が成功し、予算が止まっておらず、深さの出入りが釣り合い、使った量が上限の値で飽和して
227    /// いないときだけ返す。入力順の収集や明細の捕捉の中では記録せず、処理をそのまま通す。
228    /// 記録する処理は、予算の残りや収集先の中身を読んで動きを変えないものに限る。
229    pub fn record<T, E>(
230        &mut self,
231        operation: impl FnOnce(&mut Cx<'_>) -> Result<T, E>,
232    ) -> (Result<T, E>, Option<Replay>) {
233        if !self.plain() {
234            return (operation(self), None);
235        }
236        let before = Kind::ALL.map(|kind| self.budget.used(kind));
237        let depth_room = room(self.budget, Kind::Depth);
238        let mut diagnostics = Diagnostics::with_max_places(self.diag.max_places());
239        let result = operation(&mut Cx::new(self.budget, &mut diagnostics, self.cancel));
240        for diagnostic in diagnostics.iter() {
241            self.diag.report(diagnostic.clone());
242        }
243        let after = Kind::ALL.map(|kind| self.budget.used(kind));
244        let mut spent = [0; Kind::ALL.len()];
245        let mut recordable = result.is_ok() && self.budget.exceeded().is_none();
246        for (index, kind) in Kind::ALL.into_iter().enumerate() {
247            let (Some(&before), Some(&after), Some(slot)) =
248                (before.get(index), after.get(index), spent.get_mut(index))
249            else {
250                recordable = false;
251                break;
252            };
253            if after < before || after == u64::MAX || (kind == Kind::Depth && after != before) {
254                recordable = false;
255                break;
256            }
257            *slot = after - before;
258        }
259        let replay = recordable.then_some(Replay {
260            spent,
261            depth_room,
262            diagnostics,
263        });
264        (result, replay)
265    }
266
267    /// 記録した作用を当てる。当てたら `true`、当てられなければ何も変えずに `false` を返す。
268    ///
269    /// 同じ処理がこの予算で最後まで通ると分かるときだけ当てる。単位ごとの残りが使った量以上で、深さの余裕が
270    /// 記録したとき以上で、予算がまだ止まっておらず、中断の合図がなく、収集先が届いた順にまとめる同じ
271    /// `max_places` のものであることが条件。当てると、単位ごとに使った量を一度に使い、記録した診断を届いた順に足す。
272    /// 処理を通したときと同じ量を使い、同じ診断が届く。
273    ///
274    /// `false` のときは、呼び出す側が処理をそのまま通す。予算が足りないときの止まる所と、止まる前の診断は、
275    /// そうして処理を通したときのものになる。中断の合図は当てる前に一度だけ確かめる。
276    pub fn replay(&mut self, replay: &Replay) -> bool {
277        if !self.plain()
278            || self.diag.max_places() != replay.diagnostics.max_places()
279            || self.cancel.stop().is_some()
280            || self.budget.exceeded().is_some()
281        {
282            return false;
283        }
284        let depth = match (replay.depth_room, room(self.budget, Kind::Depth)) {
285            (Some(recorded), Some(now)) => now >= recorded,
286            (_, None) => true,
287            (None, Some(_)) => false,
288        };
289        if !depth {
290            return false;
291        }
292        let fits = Kind::ALL
293            .into_iter()
294            .zip(replay.spent)
295            .all(|(kind, spent)| room(self.budget, kind).is_none_or(|room| spent <= room));
296        if !fits {
297            return false;
298        }
299        for (kind, spent) in Kind::ALL.into_iter().zip(replay.spent) {
300            if spent > 0 && self.budget.spend(kind, spent).is_err() {
301                // 上で残りを確かめたので、ここには来ない。来ても、使った量は処理を通した場合を超えない
302                return false;
303            }
304        }
305        for diagnostic in replay.diagnostics.iter() {
306            self.diag.report(diagnostic.clone());
307        }
308        true
309    }
310}
311
312#[cfg(test)]
313mod tests {
314    use super::*;
315    use crate::budget::{Limit, Limits};
316    use crate::{Ref, Value};
317
318    fn event_at(record: u64) -> Diagnostic {
319        Diagnostic::new(codes::ZIP_PATH_UNSAFE)
320            .with("name", record.to_string())
321            .at(Ref::at_record(record))
322    }
323
324    fn capture_events(limit: u64, records: &[u64]) -> DiagnosticEvents {
325        let mut budget = Budget::default();
326        let mut diag = Diagnostics::with_max_places(0);
327        let cancel = CancelToken::new();
328        Cx::new(&mut budget, &mut diag, &cancel)
329            .with_diagnostic_events(limit, |cx| {
330                for &record in records {
331                    cx.report(event_at(record));
332                }
333                Ok::<(), Stop>(())
334            })
335            .unwrap()
336            .1
337    }
338
339    #[test]
340    fn event_limits_only_cut_details_and_preserve_the_earliest_summary_without_places() {
341        let full = capture_events(10, &[9, 3, 1, 3]);
342        assert_eq!(full.total, 4);
343        assert_eq!(full.counts.len(), 1);
344        assert_eq!(full.counts[0].count(), 4);
345        assert_eq!(full.counts[0].param("name"), Some(&Value::from("1")));
346        assert!(full.counts[0].places().is_empty());
347        assert!(!full.truncated);
348        for limit in [0, 1, 2] {
349            let events = capture_events(limit, &[9, 3, 1, 3]);
350            assert_eq!(events.total, full.total);
351            assert_eq!(events.counts, full.counts);
352            assert_eq!(events.details, full.details[..limit as usize]);
353            assert!(events.truncated);
354        }
355    }
356
357    #[test]
358    fn events_preserve_raw_places_and_same_place_reports_in_input_order() {
359        let mut budget = Budget::default();
360        let mut diag = Diagnostics::with_max_places(0);
361        let cancel = CancelToken::new();
362        let (_, events) = Cx::new(&mut budget, &mut diag, &cancel)
363            .with_diagnostic_events(8, |cx| {
364                cx.report(Diagnostic::new(codes::SXF_CODE_MISSING));
365                cx.report(Diagnostic::new(codes::ZIP_PATH_UNSAFE).at(Ref::at_bytes(2, 5)));
366                cx.report(
367                    event_at(5)
368                        .at(Ref::at_record(2).with_id("first"))
369                        .at(Ref::at_bytes(1, 3)),
370                );
371                cx.report(
372                    Diagnostic::new(codes::SXF_P21_INSTANCE_DROPPED)
373                        .with("id", 2_u64)
374                        .at(Ref::at_record(2).with_id("first")),
375                );
376                Ok::<(), Stop>(())
377            })
378            .unwrap();
379        assert_eq!(events.total, 4);
380        assert_eq!(events.details.len(), 4);
381        assert_eq!(events.details[0].places().len(), 3);
382        assert_eq!(events.details[0].places()[0].record(), Some(5));
383        assert_eq!(events.details[0].places()[1].id(), Some("first"));
384        assert_eq!(events.details[1].code(), codes::SXF_P21_INSTANCE_DROPPED);
385        assert_eq!(events.details[2].places()[0].bytes().unwrap().start, 2);
386        assert_eq!(events.details[3].code(), codes::SXF_CODE_MISSING);
387        assert!(events.details[3].fidelity().is_none());
388        assert!(events.counts.iter().all(|entry| entry.places().is_empty()));
389        let codes: Vec<_> = events
390            .counts
391            .iter()
392            .map(|entry| entry.code().name())
393            .collect();
394        assert!(codes.windows(2).all(|pair| pair[0] <= pair[1]));
395        assert!(diag.iter().all(|entry| entry.places().is_empty()));
396    }
397
398    #[test]
399    fn nested_event_scopes_capture_each_raw_report_once_through_record_order() {
400        for max_places in [0, 1] {
401            let mut budget = Budget::default();
402            let mut diag = Diagnostics::with_max_places(max_places);
403            let cancel = CancelToken::new();
404            let (inner, outer) = Cx::new(&mut budget, &mut diag, &cancel)
405                .with_diagnostic_events(10, |cx| {
406                    cx.report(event_at(9));
407                    let inner = cx.with_diagnostics_in_record_order(|cx| {
408                        cx.report(event_at(8));
409                        let (_, inner) = cx.with_diagnostic_events(10, |cx| {
410                            cx.report(event_at(5));
411                            cx.with_diagnostics_in_record_order(|cx| {
412                                cx.report(event_at(1));
413                                Ok::<(), Stop>(())
414                            })
415                        })?;
416                        cx.report(event_at(7));
417                        Ok::<_, Stop>(inner)
418                    })?;
419                    cx.report(event_at(6));
420                    Ok::<_, Stop>(inner)
421                })
422                .unwrap();
423            assert_eq!(outer.total, 6);
424            assert_eq!(outer.counts[0].count(), 6);
425            assert_eq!(outer.details.len(), 6);
426            assert_eq!(inner.total, 2);
427            assert_eq!(inner.counts[0].count(), 2);
428            assert_eq!(inner.details.len(), 2);
429            assert_eq!(diag.iter().next().unwrap().count(), 6);
430            assert_eq!(budget.used(Kind::Depth), 0);
431        }
432    }
433
434    #[test]
435    fn capture_inside_record_order_is_not_charged_for_reports_outside_the_scope() {
436        let mut budget = Budget::default();
437        let mut diag = Diagnostics::new();
438        let cancel = CancelToken::new();
439        let events = Cx::new(&mut budget, &mut diag, &cancel)
440            .with_diagnostics_in_record_order(|cx| {
441                cx.report(event_at(8));
442                let (_, events) = cx.with_diagnostic_events(1, |cx| {
443                    cx.report(event_at(2));
444                    Ok::<(), Stop>(())
445                })?;
446                cx.report(event_at(1));
447                Ok::<_, Stop>(events)
448            })
449            .unwrap();
450        assert_eq!(events.total, 1);
451        assert_eq!(events.details[0].places()[0].record(), Some(2));
452        assert_eq!(diag.iter().next().unwrap().count(), 3);
453    }
454
455    #[test]
456    fn event_totals_add_diagnostic_counts_without_inventing_more_detail_rows() {
457        let mut grouped = Diagnostics::new();
458        for _ in 0..3 {
459            grouped.report(event_at(4));
460        }
461        let mut budget = Budget::default();
462        let mut diag = Diagnostics::new();
463        let cancel = CancelToken::new();
464        let (_, events) = Cx::new(&mut budget, &mut diag, &cancel)
465            .with_diagnostic_events(1, |cx| {
466                for diagnostic in grouped.into_vec() {
467                    cx.report(diagnostic);
468                }
469                Ok::<(), Stop>(())
470            })
471            .unwrap();
472        assert_eq!(events.total, 3);
473        assert_eq!(events.details.len(), 1);
474        assert_eq!(events.details[0].count(), 3);
475        assert!(!events.truncated);
476    }
477
478    #[test]
479    fn event_scope_entry_stops_before_allocating_or_running_the_operation() {
480        for (kind, limit, cancelled) in [
481            (Kind::Depth, 0, false),
482            (Kind::DecodedBytes, EventCapture::LOGICAL_BYTES - 1, false),
483            (Kind::Work, 0, true),
484        ] {
485            let mut budget = Budget::new(Limits::default().with(kind, Limit::Finite(limit)));
486            let mut diag = Diagnostics::new();
487            let cancel = CancelToken::new();
488            if cancelled {
489                cancel.cancel();
490            }
491            let mut entered = false;
492            let stop = Cx::new(&mut budget, &mut diag, &cancel)
493                .with_diagnostic_events(1, |_| {
494                    entered = true;
495                    Ok::<(), Stop>(())
496                })
497                .unwrap_err();
498            assert!(!entered);
499            assert!(diag.events.is_none());
500            assert_eq!(diag.len(), 1);
501            assert_eq!(
502                diag.iter().next().unwrap().code(),
503                stop.to_diagnostic().code()
504            );
505            assert_eq!(budget.used(Kind::Depth), 0);
506            assert_eq!(budget.used(Kind::DecodedBytes), 0);
507        }
508    }
509
510    #[test]
511    fn the_last_report_keeps_a_sticky_stop_before_copying_the_event() {
512        for kind in [Kind::Work, Kind::DecodedBytes] {
513            let limit = if kind == Kind::DecodedBytes {
514                EventCapture::LOGICAL_BYTES
515            } else {
516                0
517            };
518            let mut budget = Budget::new(Limits::default().with(kind, Limit::Finite(limit)));
519            let mut diag = Diagnostics::new();
520            let cancel = CancelToken::new();
521            let stop = Cx::new(&mut budget, &mut diag, &cancel)
522                .with_diagnostic_events(1, |cx| {
523                    cx.report(event_at(7));
524                    let stop = cx.check(Kind::Work, 0).unwrap_err();
525                    cx.report(stop.to_diagnostic());
526                    Ok::<(), Stop>(())
527                })
528                .unwrap_err();
529            assert!(matches!(stop, Stop::Exceeded(exceeded) if exceeded.kind == kind));
530            assert_eq!(diag.len(), 1);
531            assert_eq!(diag.iter().next().unwrap().code(), kind.exceeded_code());
532            assert_eq!(diag.iter().next().unwrap().count(), 1);
533            assert_eq!(diag.iter().next().unwrap().places(), [Ref::at_record(7)]);
534            assert_eq!(budget.used(Kind::DecodedBytes), EventCapture::LOGICAL_BYTES);
535        }
536    }
537
538    #[test]
539    fn a_scope_stop_is_returned_even_if_the_operation_ignores_its_inner_result() {
540        let mut budget = Budget::new(Limits::default().with(Kind::Depth, Limit::Finite(1)));
541        let mut diag = Diagnostics::new();
542        let cancel = CancelToken::new();
543        let stop = Cx::new(&mut budget, &mut diag, &cancel)
544            .with_diagnostic_events(1, |cx| {
545                let inner = cx.with_diagnostic_events(1, |_| Ok::<(), Stop>(()));
546                assert!(inner.is_err());
547                Ok::<(), Stop>(())
548            })
549            .unwrap_err();
550        assert!(matches!(stop, Stop::Exceeded(exceeded) if exceeded.kind == Kind::Depth));
551        assert_eq!(diag.len(), 1);
552        assert_eq!(budget.used(Kind::Depth), 0);
553    }
554
555    #[test]
556    fn capture_checks_cancellation_and_work_after_reaching_the_detail_limit() {
557        for limit in [0, 1] {
558            let mut budget = Budget::default();
559            let mut diag = Diagnostics::with_max_places(0);
560            let cancel = CancelToken::new();
561            let stop = Cx::new(&mut budget, &mut diag, &cancel)
562                .with_diagnostic_events(limit, |cx| {
563                    cx.report(event_at(9));
564                    let before = cx.budget.used(Kind::Work);
565                    cx.report(event_at(8));
566                    assert!(cx.budget.used(Kind::Work) > before);
567                    cancel.cancel();
568                    cx.report(event_at(7));
569                    Ok::<(), Stop>(())
570                })
571                .unwrap_err();
572            assert_eq!(stop, Stop::Cancelled);
573            assert_eq!(diag.len(), 2);
574            assert_eq!(diag.iter().next().unwrap().count(), 2);
575        }
576    }
577
578    #[test]
579    fn final_sorting_checks_the_budget_and_reports_its_stop() {
580        let mut before_finish = 0;
581        let mut budget = Budget::default();
582        let mut diag = Diagnostics::new();
583        let cancel = CancelToken::new();
584        Cx::new(&mut budget, &mut diag, &cancel)
585            .with_diagnostic_events(1, |cx| {
586                cx.report(event_at(1));
587                before_finish = cx.budget.used(Kind::Work);
588                Ok::<(), Stop>(())
589            })
590            .unwrap();
591        let mut budget =
592            Budget::new(Limits::default().with(Kind::Work, Limit::Finite(before_finish)));
593        let mut diag = Diagnostics::new();
594        let stop = Cx::new(&mut budget, &mut diag, &cancel)
595            .with_diagnostic_events(1, |cx| {
596                cx.report(event_at(1));
597                Ok::<(), Stop>(())
598            })
599            .unwrap_err();
600        assert!(matches!(stop, Stop::Exceeded(exceeded) if exceeded.kind == Kind::Work));
601        assert_eq!(diag.len(), 2);
602        assert_eq!(
603            diag.iter().last().unwrap().code(),
604            codes::BUDGET_WORK_EXCEEDED
605        );
606    }
607
608    #[test]
609    fn merging_captures_keeps_counts_and_the_earliest_summary_without_recapturing() {
610        for limit in [0, 1, 4] {
611            let first = capture_events(limit, &[9, 5]);
612            let second = capture_events(limit, &[1, 5]);
613            let mut budget = Budget::default();
614            let mut diag = Diagnostics::new();
615            let cancel = CancelToken::new();
616            let (merged, surrounding) = Cx::new(&mut budget, &mut diag, &cancel)
617                .with_diagnostic_events(10, |cx| first.merge(second, limit, cx))
618                .unwrap();
619            assert_eq!(merged.total, 4);
620            assert_eq!(merged.counts[0].count(), 4);
621            assert_eq!(merged.counts[0].param("name"), Some(&Value::from("1")));
622            assert!(merged.counts[0].places().is_empty());
623            assert_eq!(merged.details.len(), (limit as usize).min(4));
624            assert_eq!(merged.truncated, limit < 4);
625            assert_eq!(surrounding.total, 0);
626            assert!(diag.is_empty());
627        }
628    }
629
630    #[test]
631    fn merging_captures_checks_its_budget_before_allocating_and_does_not_restore_cut_details() {
632        let first = capture_events(0, &[9]);
633        let second = capture_events(0, &[1]);
634        let mut budget = Budget::default();
635        let mut diag = Diagnostics::new();
636        let cancel = CancelToken::new();
637        let merged = first
638            .merge(second, 10, &mut Cx::new(&mut budget, &mut diag, &cancel))
639            .unwrap();
640        assert_eq!(merged.total, 2);
641        assert!(merged.details.is_empty());
642        assert!(merged.truncated);
643        let mut budget = Budget::new(Limits::default().with(Kind::DecodedBytes, Limit::Finite(0)));
644        let first = capture_events(1, &[9]);
645        let second = capture_events(1, &[1]);
646        let stop = first
647            .merge(second, 1, &mut Cx::new(&mut budget, &mut diag, &cancel))
648            .unwrap_err();
649        assert!(matches!(stop, Stop::Exceeded(exceeded) if exceeded.kind == Kind::DecodedBytes));
650        assert_eq!(budget.used(Kind::DecodedBytes), 0);
651        assert_eq!(
652            diag.iter().next().unwrap().code(),
653            codes::BUDGET_DECODED_BYTES_EXCEEDED
654        );
655    }
656
657    #[test]
658    fn event_counts_use_catalog_keys_and_input_position_for_representative_values() {
659        let mut budget = Budget::default();
660        let mut diag = Diagnostics::with_max_places(0);
661        let cancel = CancelToken::new();
662        let (_, events) = Cx::new(&mut budget, &mut diag, &cancel)
663            .with_diagnostic_events(0, |cx| {
664                for (kind, code, record, value) in [
665                    ("line", 2_i64, 9, "late"),
666                    ("line", 2, 1, "early"),
667                    ("line", 1, 4, "one"),
668                    ("circle", 4, 5, "circle"),
669                ] {
670                    cx.report(
671                        Diagnostic::new(codes::SXF_CODE_MISSING)
672                            .with("kind", kind)
673                            .with("code", code)
674                            .with("value", value)
675                            .at(Ref::at_record(record)),
676                    );
677                }
678                Ok::<(), Stop>(())
679            })
680            .unwrap();
681        assert_eq!(events.total, 4);
682        assert_eq!(events.counts.len(), 3);
683        assert_eq!(events.counts[0].param("kind"), Some(&Value::from("circle")));
684        assert_eq!(events.counts[1].param("code"), Some(&Value::Int(1)));
685        assert_eq!(events.counts[2].count(), 2);
686        assert_eq!(events.counts[2].param("value"), Some(&Value::from("early")));
687        assert!(events.details.is_empty());
688    }
689
690    #[test]
691    fn merging_same_position_reports_preserves_the_phase_order_and_representative() {
692        let mut budget = Budget::default();
693        let mut diag = Diagnostics::with_max_places(0);
694        let cancel = CancelToken::new();
695        let mut cx = Cx::new(&mut budget, &mut diag, &cancel);
696        let mut phase = |name: &str| {
697            cx.with_diagnostic_events(2, |cx| {
698                cx.report(event_at(1).with("name", name));
699                Ok::<(), Stop>(())
700            })
701            .unwrap()
702            .1
703        };
704        let first = phase("first");
705        let second = phase("second");
706        let merged = first.merge(second, 2, &mut cx).unwrap();
707        assert_eq!(merged.total, 2);
708        assert_eq!(merged.counts[0].count(), 2);
709        assert_eq!(merged.counts[0].param("name"), Some(&Value::from("first")));
710        assert_eq!(merged.details[0].param("name"), Some(&Value::from("first")));
711        assert_eq!(
712            merged.details[1].param("name"),
713            Some(&Value::from("second"))
714        );
715        assert!(!merged.truncated);
716    }
717
718    #[test]
719    fn checks_the_signal_before_the_budget() {
720        let mut budget = Budget::default();
721        let mut diag = Diagnostics::new();
722        let cancel = CancelToken::new();
723        let mut cx = Cx::new(&mut budget, &mut diag, &cancel);
724        assert_eq!(cx.check(Kind::Records, 1), Ok(()));
725        cancel.cancel();
726        assert_eq!(cx.check(Kind::Records, 1), Err(Stop::Cancelled));
727        assert_eq!(budget.used(Kind::Records), 1);
728    }
729
730    #[test]
731    fn nesting_stops_at_the_depth_limit() {
732        let mut budget = Budget::new(Limits::default().with(Kind::Depth, Limit::Finite(1)));
733        let mut diag = Diagnostics::new();
734        let cancel = CancelToken::new();
735        let mut cx = Cx::new(&mut budget, &mut diag, &cancel);
736        assert_eq!(cx.enter(), Ok(()));
737        let stop = cx.enter().unwrap_err();
738        cx.report(stop.to_diagnostic());
739        cx.leave();
740        assert_eq!(
741            diag.iter().next().map(Diagnostic::code),
742            Some(codes::BUDGET_DEPTH_EXCEEDED)
743        );
744    }
745
746    #[test]
747    fn each_stop_has_its_code() {
748        assert_eq!(
749            Stop::Cancelled.to_diagnostic().code(),
750            codes::CALL_REQUEST_CANCELLED
751        );
752        assert_eq!(
753            Stop::TimedOut.to_diagnostic().code(),
754            codes::BUDGET_TIME_EXCEEDED
755        );
756    }
757
758    #[test]
759    fn record_order_keeps_first_places_values_and_stable_ties_even_without_places() {
760        for max_places in [0, 1, 2, 16] {
761            let mut budget = Budget::default();
762            let mut diag = Diagnostics::with_max_places(max_places);
763            let cancel = CancelToken::new();
764            Cx::new(&mut budget, &mut diag, &cancel)
765                .with_diagnostics_in_record_order(|cx| {
766                    cx.report(
767                        Diagnostic::new(codes::ZIP_PATH_UNSAFE)
768                            .with("name", "late")
769                            .at(crate::Ref::at_record(9)),
770                    );
771                    cx.report(
772                        Diagnostic::new(codes::SXF_P21_INSTANCE_DROPPED)
773                            .with("id", 2_u64)
774                            .at(crate::Ref::at_record(4)),
775                    );
776                    cx.report(
777                        Diagnostic::new(codes::ZIP_PATH_UNSAFE)
778                            .with("name", "first")
779                            .at(crate::Ref::at_record(4)),
780                    );
781                    cx.report(
782                        Diagnostic::new(codes::SXF_P21_INSTANCE_DROPPED)
783                            .with("id", 1_u64)
784                            .at(crate::Ref::at_record(4)),
785                    );
786                    cx.report(
787                        Diagnostic::new(codes::ZIP_PATH_UNSAFE)
788                            .with("name", "middle")
789                            .at(crate::Ref::at_record(7)),
790                    );
791                    // 収集中も場所の上限を超えない。
792                    assert!(cx.diag.iter().all(|d| d.places().len() <= max_places));
793                    Ok::<(), Stop>(())
794                })
795                .unwrap();
796            let diagnostics = diag.into_vec();
797            assert_eq!(diagnostics.len(), 3);
798            assert_eq!(diagnostics[0].param("id"), Some(&crate::Value::UInt(2)));
799            assert_eq!(diagnostics[2].param("id"), Some(&crate::Value::UInt(1)));
800            let merged = &diagnostics[1];
801            assert_eq!(merged.code(), codes::ZIP_PATH_UNSAFE);
802            assert_eq!(merged.count(), 3);
803            assert_eq!(merged.param("name"), Some(&crate::Value::from("first")));
804            assert_eq!(
805                merged.places(),
806                &[
807                    crate::Ref::at_record(4),
808                    crate::Ref::at_record(7),
809                    crate::Ref::at_record(9)
810                ][..max_places.min(3)]
811            );
812        }
813    }
814
815    #[test]
816    fn record_order_stops_before_collecting_and_flushes_already_paid_diagnostics() {
817        for cancelled in [false, true] {
818            let mut budget = Budget::new(Limits::default().with(Kind::Work, Limit::Finite(5)));
819            let mut diag = Diagnostics::with_max_places(1);
820            let cancel = CancelToken::new();
821            let result =
822                Cx::new(&mut budget, &mut diag, &cancel).with_diagnostics_in_record_order(|cx| {
823                    cx.report(Diagnostic::new(codes::ZIP_PATH_UNSAFE).at(crate::Ref::at_record(9)));
824                    if cancelled {
825                        cancel.cancel();
826                    }
827                    cx.report(Diagnostic::new(codes::ZIP_PATH_UNSAFE).at(crate::Ref::at_record(3)));
828                    // report で見つけた停止は次の check にも返し、停止の二重報告をしない。
829                    let stop = cx.check(Kind::Work, 0).unwrap_err();
830                    cx.report(stop.to_diagnostic());
831                    Ok::<(), Stop>(())
832                });
833            let stop = result.unwrap_err();
834            assert_eq!(cancelled, stop == Stop::Cancelled);
835            assert_eq!(budget.used(Kind::Work), 5);
836            let diagnostics = diag.into_vec();
837            assert_eq!(diagnostics.len(), 2);
838            assert_eq!(diagnostics[0].code(), stop.to_diagnostic().code());
839            assert_eq!(diagnostics[0].places(), [crate::Ref::at_record(3)]);
840            assert_eq!(diagnostics[1].count(), 1);
841            assert_eq!(diagnostics[1].places(), [crate::Ref::at_record(9)]);
842        }
843    }
844
845    #[test]
846    fn ordinary_reporting_neither_reorders_nor_spends_work() {
847        let mut budget = Budget::new(Limits::default().with(Kind::Work, Limit::Finite(0)));
848        let mut diag = Diagnostics::with_max_places(1);
849        let cancel = CancelToken::new();
850        let mut cx = Cx::new(&mut budget, &mut diag, &cancel);
851        for record in [9, 3] {
852            cx.report(Diagnostic::new(codes::ZIP_PATH_UNSAFE).at(crate::Ref::at_record(record)));
853        }
854        assert_eq!(budget.used(Kind::Work), 0);
855        assert_eq!(
856            diag.iter().next().unwrap().places(),
857            [crate::Ref::at_record(9)]
858        );
859        assert_eq!(diag.iter().next().unwrap().count(), 2);
860    }
861
862    #[test]
863    fn repeated_reports_keep_bounded_storage() {
864        for max_places in [0, 1] {
865            let mut budget = Budget::default();
866            let mut diag = Diagnostics::with_max_places(max_places);
867            let cancel = CancelToken::new();
868            Cx::new(&mut budget, &mut diag, &cancel)
869                .with_diagnostics_in_record_order(|cx| {
870                    for record in (0..1000).rev() {
871                        cx.report(
872                            Diagnostic::new(codes::ZIP_PATH_UNSAFE)
873                                .at(crate::Ref::at_record(record)),
874                        );
875                        assert_eq!(cx.diag.len(), 1);
876                        assert_eq!(cx.diag.iter().next().unwrap().places().len(), max_places);
877                    }
878                    Ok::<(), Stop>(())
879                })
880                .unwrap();
881            let diagnostics = diag.into_vec();
882            assert_eq!(diagnostics[0].count(), 1000);
883            assert_eq!(
884                diagnostics[0].places(),
885                &[crate::Ref::at_record(0)][..max_places]
886            );
887            assert_eq!(budget.used(Kind::Work), 1000 * (4 + max_places as u64));
888        }
889    }
890
891    #[test]
892    fn record_order_preserves_tied_places_and_puts_unlocated_reports_last() {
893        let mut budget = Budget::new(Limits::default().with(Kind::Work, Limit::Finite(22)));
894        let mut diag = Diagnostics::with_max_places(2);
895        let cancel = CancelToken::new();
896        Cx::new(&mut budget, &mut diag, &cancel)
897            .with_diagnostics_in_record_order(|cx| {
898                cx.report(Diagnostic::new(codes::SXF_P21_SHEET_MISSING));
899                cx.report(
900                    Diagnostic::new(codes::ZIP_PATH_UNSAFE)
901                        .at(crate::Ref::at_record(5))
902                        .at(crate::Ref::at_record(2).with_id("first"))
903                        .at(crate::Ref::at_record(2).with_id("second")),
904                );
905                cx.report(
906                    Diagnostic::new(codes::ZIP_PATH_UNSAFE)
907                        .at(crate::Ref::at_record(2).with_id("third")),
908                );
909                Ok::<(), Stop>(())
910            })
911            .unwrap();
912        assert_eq!(budget.used(Kind::Work), 22);
913        let diagnostics = diag.into_vec();
914        assert_eq!(diagnostics[0].count(), 2);
915        assert_eq!(
916            diagnostics[0].places(),
917            [
918                crate::Ref::at_record(2).with_id("first"),
919                crate::Ref::at_record(2).with_id("second")
920            ]
921        );
922        assert_eq!(diagnostics[1].code(), codes::SXF_P21_SHEET_MISSING);
923        assert!(diagnostics[1].places().is_empty());
924    }
925
926    #[test]
927    fn nested_record_order_keeps_positions_values_and_one_work_charge() {
928        for max_places in [0, 1] {
929            let work = 5 * (4 + max_places as u64);
930            let mut budget = Budget::new(Limits::default().with(Kind::Work, Limit::Finite(work)));
931            let mut diag = Diagnostics::with_max_places(max_places);
932            let cancel = CancelToken::new();
933            Cx::new(&mut budget, &mut diag, &cancel)
934                .with_diagnostics_in_record_order(|cx| {
935                    cx.report(
936                        Diagnostic::new(codes::ZIP_PATH_UNSAFE)
937                            .with("name", "late")
938                            .at(crate::Ref::at_record(9)),
939                    );
940                    cx.with_diagnostics_in_record_order(|cx| {
941                        cx.report(
942                            Diagnostic::new(codes::SXF_P21_INSTANCE_DROPPED)
943                                .with("id", 2_u64)
944                                .at(crate::Ref::at_record(4)),
945                        );
946                        cx.with_diagnostics_in_record_order(|cx| {
947                            cx.report(
948                                Diagnostic::new(codes::ZIP_PATH_UNSAFE)
949                                    .with("name", "first")
950                                    .at(crate::Ref::at_record(1)),
951                            );
952                            Ok::<(), Stop>(())
953                        })?;
954                        cx.report(
955                            Diagnostic::new(codes::SXF_P21_INSTANCE_DROPPED)
956                                .with("id", 3_u64)
957                                .at(crate::Ref::at_record(4)),
958                        );
959                        Ok::<(), Stop>(())
960                    })?;
961                    cx.report(
962                        Diagnostic::new(codes::SXF_P21_SHEET_DROPPED)
963                            .with("id", 80_u64)
964                            .at(crate::Ref::at_record(2)),
965                    );
966                    Ok::<(), Stop>(())
967                })
968                .unwrap();
969            assert_eq!(budget.used(Kind::Work), work);
970            let diagnostics = diag.into_vec();
971            assert_eq!(diagnostics.len(), 4);
972            assert_eq!(diagnostics[0].code(), codes::ZIP_PATH_UNSAFE);
973            assert_eq!(diagnostics[0].count(), 2);
974            assert_eq!(
975                diagnostics[0].param("name"),
976                Some(&crate::Value::from("first"))
977            );
978            assert_eq!(diagnostics[1].code(), codes::SXF_P21_SHEET_DROPPED);
979            assert_eq!(diagnostics[2].param("id"), Some(&crate::Value::UInt(2)));
980            assert_eq!(diagnostics[3].param("id"), Some(&crate::Value::UInt(3)));
981            for (diagnostic, record) in diagnostics.iter().zip([1, 2, 4, 4]) {
982                assert_eq!(
983                    diagnostic.places(),
984                    &[crate::Ref::at_record(record)][..max_places]
985                );
986            }
987        }
988    }
989
990    #[test]
991    fn nested_record_order_returns_the_inner_stop_and_keeps_collected_reports() {
992        for (max_places, cancelled) in [(0, false), (1, false), (0, true), (1, true)] {
993            let work = 2 * (4 + max_places as u64);
994            let mut budget = Budget::new(Limits::default().with(Kind::Work, Limit::Finite(work)));
995            let mut diag = Diagnostics::with_max_places(max_places);
996            let cancel = CancelToken::new();
997            let mut inner_stop = None;
998            let result =
999                Cx::new(&mut budget, &mut diag, &cancel).with_diagnostics_in_record_order(|cx| {
1000                    cx.report(Diagnostic::new(codes::ZIP_PATH_UNSAFE).at(crate::Ref::at_record(9)));
1001                    let result = cx.with_diagnostics_in_record_order(|cx| {
1002                        cx.report(
1003                            Diagnostic::new(codes::SXF_P21_INSTANCE_DROPPED)
1004                                .with("id", 2_u64)
1005                                .at(crate::Ref::at_record(3)),
1006                        );
1007                        if cancelled {
1008                            cancel.cancel();
1009                        }
1010                        cx.report(
1011                            Diagnostic::new(codes::SXF_P21_INSTANCE_DROPPED)
1012                                .with("id", 3_u64)
1013                                .at(crate::Ref::at_record(5)),
1014                        );
1015                        Ok::<(), Stop>(())
1016                    });
1017                    let stop = result.unwrap_err();
1018                    inner_stop = Some(stop);
1019                    assert_eq!(cx.check(Kind::Work, 0), Err(stop));
1020                    let mut entered = false;
1021                    let after_stop = cx.with_diagnostics_in_record_order(|_| {
1022                        entered = true;
1023                        Ok::<(), Stop>(())
1024                    });
1025                    assert_eq!(after_stop, Err(stop));
1026                    assert!(!entered);
1027                    // 内側の結果を伝え忘れても、外側も同じ停止を返す。
1028                    Ok::<(), Stop>(())
1029                });
1030            let stop = result.unwrap_err();
1031            assert_eq!(inner_stop, Some(stop));
1032            assert_eq!(cancelled, stop == Stop::Cancelled);
1033            assert_eq!(budget.used(Kind::Work), work);
1034            let diagnostics = diag.into_vec();
1035            assert_eq!(diagnostics.len(), 3);
1036            assert_eq!(diagnostics[0].code(), codes::SXF_P21_INSTANCE_DROPPED);
1037            assert_eq!(diagnostics[0].param("id"), Some(&crate::Value::UInt(2)));
1038            assert_eq!(diagnostics[1].code(), stop.to_diagnostic().code());
1039            assert_eq!(diagnostics[2].code(), codes::ZIP_PATH_UNSAFE);
1040            for (diagnostic, record) in diagnostics.iter().zip([3, 5, 9]) {
1041                assert_eq!(diagnostic.count(), 1);
1042                assert_eq!(
1043                    diagnostic.places(),
1044                    &[crate::Ref::at_record(record)][..max_places]
1045                );
1046            }
1047        }
1048    }
1049
1050    /// 記録と当て直しを試す処理。入れ子・入力順の収集・別の収集先・場所の多い診断を混ぜる
1051    fn mixed(cx: &mut Cx<'_>) -> Result<u32, Stop> {
1052        cx.report(event_at(7));
1053        for record in 0..5 {
1054            cx.check(Kind::Records, 1)?;
1055            cx.report(Diagnostic::new(codes::SXF_CODE_MISSING).at(Ref::at_record(record)));
1056        }
1057        cx.enter()?;
1058        cx.enter()?;
1059        cx.check(Kind::Work, 3)?;
1060        cx.leave();
1061        cx.leave();
1062        cx.with_diagnostics_in_record_order(|cx| {
1063            cx.report(event_at(9));
1064            cx.check(Kind::Work, 2)?;
1065            cx.report(event_at(1));
1066            Ok::<(), Stop>(())
1067        })?;
1068        let mut quiet = Diagnostics::new();
1069        let mut inner = Cx::new(cx.budget, &mut quiet, cx.cancel);
1070        inner.check(Kind::Elements, 4)?;
1071        inner.report(event_at(2));
1072        cx.check(Kind::DecodedBytes, 10)?;
1073        Ok(42)
1074    }
1075
1076    /// 前の報告と予算の使用がある、呼び出しの初めの状態
1077    fn started(limits: Limits, max_places: usize) -> (Budget, Diagnostics) {
1078        let mut budget = Budget::new(limits);
1079        budget.spend(Kind::Work, 5).unwrap();
1080        let mut diag = Diagnostics::with_max_places(max_places);
1081        diag.report(Diagnostic::new(codes::SXF_CODE_MISSING).at(Ref::at_record(100)));
1082        diag.report(event_at(3));
1083        (budget, diag)
1084    }
1085
1086    fn recorded(max_places: usize) -> Replay {
1087        let (mut budget, mut diag) = started(Limits::default(), max_places);
1088        let cancel = CancelToken::new();
1089        let (result, replay) = Cx::new(&mut budget, &mut diag, &cancel).record(mixed);
1090        assert_eq!(result, Ok(42));
1091        replay.unwrap()
1092    }
1093
1094    #[test]
1095    fn recording_and_replaying_match_running_the_operation_again() {
1096        for max_places in [0, 2, Diagnostics::DEFAULT_MAX_PLACES] {
1097            let cancel = CancelToken::new();
1098            let (mut budget, mut diag) = started(Limits::default(), max_places);
1099            assert_eq!(mixed(&mut Cx::new(&mut budget, &mut diag, &cancel)), Ok(42));
1100            let expected = (budget, diag.into_vec());
1101
1102            let (mut budget, mut diag) = started(Limits::default(), max_places);
1103            let (result, replay) = Cx::new(&mut budget, &mut diag, &cancel).record(mixed);
1104            assert_eq!(result, Ok(42));
1105            assert_eq!((budget, diag.into_vec()), expected);
1106
1107            let replay = replay.unwrap();
1108            let (mut budget, mut diag) = started(Limits::default(), max_places);
1109            assert!(Cx::new(&mut budget, &mut diag, &cancel).replay(&replay));
1110            assert_eq!((budget.clone(), diag.clone().into_vec()), expected);
1111            // 続けて当てても、続けて通したのと同じになる
1112            let (mut twice_budget, mut twice_diag) = started(Limits::default(), max_places);
1113            for _ in 0..2 {
1114                let mut cx = Cx::new(&mut twice_budget, &mut twice_diag, &cancel);
1115                assert_eq!(mixed(&mut cx), Ok(42));
1116            }
1117            assert!(Cx::new(&mut budget, &mut diag, &cancel).replay(&replay));
1118            assert_eq!(
1119                (budget, diag.into_vec()),
1120                (twice_budget, twice_diag.into_vec())
1121            );
1122        }
1123    }
1124
1125    #[test]
1126    fn replay_refuses_budgets_that_would_stop_the_operation_and_changes_nothing() {
1127        let replay = recorded(Diagnostics::DEFAULT_MAX_PLACES);
1128        let cancel = CancelToken::new();
1129        // 処理を通して使う量を測る。入力順の収集の分も work に入る。深さは 2 まで
1130        let (mut budget, mut diag) = started(Limits::default(), 16);
1131        let used = Kind::ALL.map(|kind| budget.used(kind));
1132        mixed(&mut Cx::new(&mut budget, &mut diag, &cancel)).unwrap();
1133        assert!(budget.used(Kind::Work) > 5 + 5);
1134        for (kind, used) in Kind::ALL.into_iter().zip(used) {
1135            let spent = budget.used(kind) - used;
1136            if spent == 0 {
1137                continue;
1138            }
1139            for (limit, accepted) in [(used + spent - 1, false), (used + spent, true)] {
1140                let limits = Limits::default().with(kind, Limit::Finite(limit));
1141                let (mut budget, mut diag) = started(limits, 16);
1142                let before = (budget.clone(), diag.clone().into_vec());
1143                let replayed = Cx::new(&mut budget, &mut diag, &cancel).replay(&replay);
1144                assert_eq!(replayed, accepted, "{kind:?} {limit}");
1145                if !accepted {
1146                    assert_eq!((budget, diag.into_vec()), before);
1147                    // 処理を通すと、その単位で止まる
1148                    let (mut budget, mut diag) = started(limits, 16);
1149                    let stop = mixed(&mut Cx::new(&mut budget, &mut diag, &cancel));
1150                    assert!(matches!(stop, Err(Stop::Exceeded(e)) if e.kind == kind));
1151                }
1152            }
1153        }
1154        // 深さは、記録したとき(既定の上限)より余裕が少なければ当てない
1155        for (limit, accepted) in [
1156            (Limit::Finite(255), false),
1157            (Limit::Finite(256), true),
1158            (Limit::Unlimited, true),
1159        ] {
1160            let (mut budget, mut diag) = started(Limits::default().with(Kind::Depth, limit), 16);
1161            let replayed = Cx::new(&mut budget, &mut diag, &cancel).replay(&replay);
1162            assert_eq!(replayed, accepted, "{limit:?}");
1163        }
1164        // 中断の合図・止まった予算・違う max_places では当てない
1165        let cancelled = CancelToken::new();
1166        cancelled.cancel();
1167        let (mut budget, mut diag) = started(Limits::default(), 16);
1168        assert!(!Cx::new(&mut budget, &mut diag, &cancelled).replay(&replay));
1169        assert_eq!(budget.used(Kind::Records), 0);
1170        let (mut budget, mut diag) = started(Limits::default(), 16);
1171        assert!(budget.spend(Kind::Work, u64::MAX).is_err());
1172        assert!(!Cx::new(&mut budget, &mut diag, &cancel).replay(&replay));
1173        let (mut budget, mut diag) = started(Limits::default(), 15);
1174        assert!(!Cx::new(&mut budget, &mut diag, &cancel).replay(&replay));
1175        assert_eq!(diag.len(), 2);
1176    }
1177
1178    #[test]
1179    fn replay_and_record_step_aside_inside_ordered_or_captured_collection() {
1180        let replay = recorded(Diagnostics::DEFAULT_MAX_PLACES);
1181        let cancel = CancelToken::new();
1182        let (mut budget, mut diag) = started(Limits::default(), 16);
1183        let mut cx = Cx::new(&mut budget, &mut diag, &cancel);
1184        cx.with_diagnostics_in_record_order(|cx| {
1185            assert!(!cx.replay(&replay));
1186            let (result, recorded) = cx.record(mixed);
1187            assert_eq!(result, Ok(42));
1188            assert!(recorded.is_none());
1189            Ok::<(), Stop>(())
1190        })
1191        .unwrap();
1192        cx.with_diagnostic_events(4, |cx| {
1193            assert!(!cx.replay(&replay));
1194            assert!(cx.record(mixed).1.is_none());
1195            Ok::<(), Stop>(())
1196        })
1197        .unwrap();
1198    }
1199
1200    #[test]
1201    fn record_keeps_only_operations_that_finish_with_balanced_depth() {
1202        let cancel = CancelToken::new();
1203        // 止まった処理は記録せず、診断と使った量は通したときと同じになる
1204        for work in 5..12 {
1205            let limits = Limits::default().with(Kind::Work, Limit::Finite(work));
1206            let (mut budget, mut diag) = started(limits, 2);
1207            let result = mixed(&mut Cx::new(&mut budget, &mut diag, &cancel));
1208            let expected = (result, budget, diag.into_vec());
1209            let (mut budget, mut diag) = started(limits, 2);
1210            let (result, replay) = Cx::new(&mut budget, &mut diag, &cancel).record(mixed);
1211            assert_eq!(replay.is_some(), result.is_ok());
1212            assert_eq!((result, budget, diag.into_vec()), expected);
1213        }
1214        let (mut budget, mut diag) = started(Limits::default(), 2);
1215        let (result, replay) = Cx::new(&mut budget, &mut diag, &cancel).record(|cx| cx.enter());
1216        assert_eq!(result, Ok(()));
1217        assert!(replay.is_none());
1218    }
1219}