Skip to main content

neco_expr/
storage.rs

1use alloc::vec::Vec;
2use core::mem::size_of;
3
4use crate::{
5    AbsoluteBits, AtomId, CertifiedF64, ConsumerId, EvalError, ExactValue, ExprId, InsertError,
6    ResolveError, StorageError,
7};
8use neco_algnum::IsolatingInterval;
9
10#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
11pub enum StorageResource {
12    GraphNodes,
13    AtomEntries,
14    PrecisionEntries,
15    AssignmentEntries,
16    EvaluationEntries,
17    IsolationEntries,
18    ResolvedEntries,
19    ProductEntries,
20    ProductResolutionEntries,
21}
22
23#[derive(Debug, Eq, PartialEq)]
24pub struct AtomStore {
25    entries: Vec<(AtomId, ExactValue)>,
26}
27
28#[derive(Debug, Eq, PartialEq)]
29pub struct PrecisionRequirements {
30    entries: Vec<(ConsumerId, AbsoluteBits)>,
31}
32
33#[derive(Debug, Eq, PartialEq)]
34pub struct Assignments {
35    entries: Vec<(ConsumerId, ExprId)>,
36}
37
38#[derive(Debug, Eq, PartialEq)]
39pub struct EvaluationCache {
40    entries: Vec<(ExprId, Result<ExactValue, EvalError>)>,
41}
42
43#[derive(Debug, Eq, PartialEq)]
44pub struct IsolationCache {
45    entries: Vec<((ExprId, AbsoluteBits), IsolatingInterval)>,
46}
47
48#[derive(Debug, Eq, PartialEq)]
49pub struct ResolvedValues {
50    entries: Vec<(ConsumerId, Result<CertifiedF64, ResolveError>)>,
51}
52
53impl AtomStore {
54    pub fn new() -> Self {
55        Self {
56            entries: Vec::new(),
57        }
58    }
59
60    pub fn len(&self) -> usize {
61        self.entries.len()
62    }
63
64    pub fn is_empty(&self) -> bool {
65        self.entries.is_empty()
66    }
67
68    pub fn get(&self, id: AtomId) -> Option<&ExactValue> {
69        get_entry(&self.entries, id)
70    }
71
72    pub fn insert(&mut self, id: AtomId, value: ExactValue) -> Result<(), InsertError> {
73        insert_entry(
74            &mut self.entries,
75            id,
76            value,
77            StorageResource::AtomEntries,
78            id.get(),
79        )
80    }
81
82    pub fn set(&mut self, id: AtomId, value: ExactValue) -> Result<(), InsertError> {
83        set_entry(
84            &mut self.entries,
85            id,
86            value,
87            StorageResource::AtomEntries,
88            id.get(),
89        )
90    }
91
92    pub fn try_clone(&self) -> Result<Self, InsertError> {
93        let mut entries = Vec::new();
94        reserve_entries(
95            &mut entries,
96            self.entries.len(),
97            StorageResource::AtomEntries,
98        )?;
99        for (id, value) in &self.entries {
100            entries.push((*id, value.try_clone().map_err(atom_value_error)?));
101        }
102        Ok(Self { entries })
103    }
104}
105
106impl Default for AtomStore {
107    fn default() -> Self {
108        Self::new()
109    }
110}
111
112fn atom_value_error(error: EvalError) -> InsertError {
113    InsertError::Value(atom_value_payload(error))
114}
115
116fn atom_value_payload(error: EvalError) -> EvalError {
117    error
118}
119
120impl PrecisionRequirements {
121    pub fn new() -> Self {
122        Self {
123            entries: Vec::new(),
124        }
125    }
126
127    pub fn len(&self) -> usize {
128        self.entries.len()
129    }
130
131    pub fn is_empty(&self) -> bool {
132        self.entries.is_empty()
133    }
134
135    pub fn get(&self, id: ConsumerId) -> Option<AbsoluteBits> {
136        get_entry(&self.entries, id).copied()
137    }
138
139    pub fn insert(&mut self, id: ConsumerId, bits: AbsoluteBits) -> Result<(), InsertError> {
140        insert_entry(
141            &mut self.entries,
142            id,
143            bits,
144            StorageResource::PrecisionEntries,
145            id.get(),
146        )
147    }
148
149    pub fn set(&mut self, id: ConsumerId, bits: AbsoluteBits) -> Result<(), InsertError> {
150        set_entry(
151            &mut self.entries,
152            id,
153            bits,
154            StorageResource::PrecisionEntries,
155            id.get(),
156        )
157    }
158
159    pub fn try_clone(&self) -> Result<Self, InsertError> {
160        Ok(Self {
161            entries: try_clone_copy_entries(&self.entries, StorageResource::PrecisionEntries)?,
162        })
163    }
164
165    pub(crate) fn entries(&self) -> &[(ConsumerId, AbsoluteBits)] {
166        &self.entries
167    }
168}
169
170impl Default for PrecisionRequirements {
171    fn default() -> Self {
172        Self::new()
173    }
174}
175
176impl Assignments {
177    pub fn new() -> Self {
178        Self {
179            entries: Vec::new(),
180        }
181    }
182
183    pub fn len(&self) -> usize {
184        self.entries.len()
185    }
186
187    pub fn is_empty(&self) -> bool {
188        self.entries.is_empty()
189    }
190
191    pub fn get(&self, id: ConsumerId) -> Option<ExprId> {
192        get_entry(self.entries(), id).copied()
193    }
194
195    pub fn insert(&mut self, id: ConsumerId, expr: ExprId) -> Result<(), InsertError> {
196        insert_entry(
197            &mut self.entries,
198            id,
199            expr,
200            StorageResource::AssignmentEntries,
201            id.get(),
202        )
203    }
204
205    pub fn set(&mut self, id: ConsumerId, expr: ExprId) -> Result<(), InsertError> {
206        set_entry(
207            &mut self.entries,
208            id,
209            expr,
210            StorageResource::AssignmentEntries,
211            id.get(),
212        )
213    }
214
215    pub fn try_clone(&self) -> Result<Self, InsertError> {
216        Ok(Self {
217            entries: try_clone_copy_entries(&self.entries, StorageResource::AssignmentEntries)?,
218        })
219    }
220
221    pub(crate) fn entries(&self) -> &[(ConsumerId, ExprId)] {
222        &self.entries
223    }
224}
225
226impl Default for Assignments {
227    fn default() -> Self {
228        Self::new()
229    }
230}
231
232impl EvaluationCache {
233    pub(crate) fn new() -> Self {
234        Self {
235            entries: Vec::new(),
236        }
237    }
238
239    pub fn len(&self) -> usize {
240        self.entries.len()
241    }
242
243    pub fn is_empty(&self) -> bool {
244        self.entries.is_empty()
245    }
246
247    pub fn get(&self, id: ExprId) -> Option<&Result<ExactValue, EvalError>> {
248        get_entry(&self.entries, id)
249    }
250
251    pub(crate) fn get_mut(&mut self, id: ExprId) -> Option<&mut Result<ExactValue, EvalError>> {
252        self.entries
253            .binary_search_by(|(candidate, _)| candidate.cmp(&id))
254            .ok()
255            .map(|index| &mut self.entries[index].1)
256    }
257
258    pub(crate) fn insert(
259        &mut self,
260        id: ExprId,
261        value: Result<ExactValue, EvalError>,
262    ) -> Result<(), StorageError> {
263        let index = match find_key(&self.entries, &id) {
264            Ok(_) => return Ok(()),
265            Err(index) => index,
266        };
267        let required = required_elements(self.entries.len(), StorageResource::EvaluationEntries)?;
268        reserve_entries(
269            &mut self.entries,
270            required,
271            StorageResource::EvaluationEntries,
272        )?;
273        self.entries.insert(index, (id, value));
274        Ok(())
275    }
276}
277
278impl IsolationCache {
279    pub(crate) fn new() -> Self {
280        Self {
281            entries: Vec::new(),
282        }
283    }
284
285    pub fn len(&self) -> usize {
286        self.entries.len()
287    }
288
289    pub fn is_empty(&self) -> bool {
290        self.entries.is_empty()
291    }
292
293    pub fn get(&self, id: ExprId, bits: AbsoluteBits) -> Option<&IsolatingInterval> {
294        get_entry(&self.entries, (id, bits))
295    }
296
297    pub(crate) fn insert(
298        &mut self,
299        id: ExprId,
300        bits: AbsoluteBits,
301        interval: IsolatingInterval,
302    ) -> Result<(), StorageError> {
303        insert_cache_entry(
304            &mut self.entries,
305            (id, bits),
306            interval,
307            StorageResource::IsolationEntries,
308        )
309    }
310}
311
312impl ResolvedValues {
313    pub(crate) fn new() -> Self {
314        Self {
315            entries: Vec::new(),
316        }
317    }
318
319    pub fn len(&self) -> usize {
320        self.entries.len()
321    }
322
323    pub fn is_empty(&self) -> bool {
324        self.entries.is_empty()
325    }
326
327    pub fn get(&self, id: ConsumerId) -> Option<&Result<CertifiedF64, ResolveError>> {
328        get_entry(&self.entries, id)
329    }
330
331    pub(crate) fn insert(
332        &mut self,
333        id: ConsumerId,
334        value: Result<CertifiedF64, ResolveError>,
335    ) -> Result<(), StorageError> {
336        insert_cache_entry(
337            &mut self.entries,
338            id,
339            value,
340            StorageResource::ResolvedEntries,
341        )
342    }
343}
344
345fn insert_cache_entry<K: Ord, V>(
346    entries: &mut Vec<(K, V)>,
347    key: K,
348    value: V,
349    resource: StorageResource,
350) -> Result<(), StorageError> {
351    let index = match find_key(entries, &key) {
352        Ok(_) => return Ok(()),
353        Err(index) => index,
354    };
355    let required = required_elements(entries.len(), resource)?;
356    reserve_entries(entries, required, resource)?;
357    entries.insert(index, (key, value));
358    Ok(())
359}
360
361fn find_key<K: Ord, V>(entries: &[(K, V)], key: &K) -> Result<usize, usize> {
362    entries.binary_search_by(|(candidate, _)| candidate.cmp(key))
363}
364
365fn get_entry<K: Ord, V>(entries: &[(K, V)], key: K) -> Option<&V> {
366    find_key(entries, &key).ok().map(|index| &entries[index].1)
367}
368
369fn insert_entry<K: Ord, V>(
370    entries: &mut Vec<(K, V)>,
371    key: K,
372    value: V,
373    resource: StorageResource,
374    id: u32,
375) -> Result<(), InsertError> {
376    let index = match find_key(entries, &key) {
377        Ok(_) => return Err(InsertError::DuplicateId { resource, id }),
378        Err(index) => index,
379    };
380    let required = required_elements(entries.len(), resource)?;
381    reserve_entries(entries, required, resource)?;
382    entries.insert(index, (key, value));
383    Ok(())
384}
385
386fn set_entry<K: Ord, V>(
387    entries: &mut Vec<(K, V)>,
388    key: K,
389    value: V,
390    resource: StorageResource,
391    id: u32,
392) -> Result<(), InsertError> {
393    match find_key(entries, &key) {
394        Ok(index) => {
395            entries[index].1 = value;
396            Ok(())
397        }
398        Err(_) => insert_entry(entries, key, value, resource, id),
399    }
400}
401
402fn try_clone_copy_entries<K: Copy, V: Copy>(
403    source: &[(K, V)],
404    resource: StorageResource,
405) -> Result<Vec<(K, V)>, InsertError> {
406    let mut entries = Vec::new();
407    reserve_entries(&mut entries, source.len(), resource)?;
408    entries.extend_from_slice(source);
409    Ok(entries)
410}
411
412pub(crate) fn required_elements(
413    current: usize,
414    resource: StorageResource,
415) -> Result<usize, StorageError> {
416    current
417        .checked_add(1)
418        .ok_or(StorageError::CapacityOverflow { resource })
419}
420
421pub(crate) fn reserve_entries<T>(
422    entries: &mut Vec<T>,
423    total_required: usize,
424    resource: StorageResource,
425) -> Result<(), StorageError> {
426    #[cfg(test)]
427    if let Some(error) = injected_failure(resource, total_required) {
428        return Err(error);
429    }
430
431    let maximum = if size_of::<T>() == 0 {
432        usize::MAX
433    } else {
434        (isize::MAX as usize) / size_of::<T>()
435    };
436    if total_required > maximum {
437        return Err(StorageError::CapacityOverflow { resource });
438    }
439    let additional = total_required
440        .checked_sub(entries.len())
441        .ok_or(StorageError::CapacityOverflow { resource })?;
442    entries
443        .try_reserve(additional)
444        .map_err(|_| StorageError::AllocationFailure {
445            resource,
446            requested_elements: total_required,
447        })
448}
449
450#[cfg(test)]
451#[derive(Clone, Copy)]
452pub(crate) enum InjectedFailure {
453    Capacity,
454    Allocation,
455}
456
457#[cfg(test)]
458std::thread_local! {
459    static INJECTED_FAILURE: core::cell::Cell<Option<(StorageResource, InjectedFailure)>> = const { core::cell::Cell::new(None) };
460    static INJECTED_SKIP: core::cell::Cell<usize> = const { core::cell::Cell::new(0) };
461}
462
463#[cfg(test)]
464fn injected_failure(resource: StorageResource, requested_elements: usize) -> Option<StorageError> {
465    INJECTED_FAILURE.with(|configured| {
466        if matches!(configured.get(), Some((expected, _)) if expected == resource)
467            && INJECTED_SKIP.with(|skip| {
468                let remaining = skip.get();
469                skip.set(remaining.saturating_sub(1));
470                remaining > 0
471            })
472        {
473            return None;
474        }
475        let error = match configured.get() {
476            Some((expected, InjectedFailure::Capacity)) if expected == resource => {
477                Some(StorageError::CapacityOverflow { resource })
478            }
479            Some((expected, InjectedFailure::Allocation)) if expected == resource => {
480                Some(StorageError::AllocationFailure {
481                    resource,
482                    requested_elements,
483                })
484            }
485            _ => None,
486        };
487        if error.is_some() {
488            configured.set(None);
489        }
490        error
491    })
492}
493
494#[cfg(test)]
495pub(crate) fn with_injected_failure<R>(
496    resource: StorageResource,
497    failure: InjectedFailure,
498    operation: impl FnOnce() -> R,
499) -> R {
500    with_injected_failure_after(resource, failure, 0, operation)
501}
502
503#[cfg(test)]
504pub(crate) fn with_injected_failure_after<R>(
505    resource: StorageResource,
506    failure: InjectedFailure,
507    skipped_calls: usize,
508    operation: impl FnOnce() -> R,
509) -> R {
510    INJECTED_SKIP.with(|skip| skip.set(skipped_calls));
511    INJECTED_FAILURE.with(|configured| configured.set(Some((resource, failure))));
512    let result = operation();
513    INJECTED_FAILURE.with(|configured| configured.set(None));
514    INJECTED_SKIP.with(|skip| skip.set(0));
515    result
516}
517
518#[cfg(test)]
519mod tests {
520    use alloc::vec;
521    use alloc::vec::Vec;
522
523    use neco_algnum::RealAlgebraic;
524    use neco_formsum::FormSum;
525    use neco_monomial::{Monomial, MonomialErrorKind};
526
527    use super::{
528        required_elements, reserve_entries, with_injected_failure, InjectedFailure, StorageResource,
529    };
530    use crate::value::{with_clone_failure, CloneContact};
531    use crate::{
532        AbsoluteBits, Assignments, AtomId, AtomStore, ConsumerId, EvalError, ExactValue, ExprGraph,
533        ExprNode, GraphError, InsertError, PrecisionRequirements, ResolveError, Resolver,
534        StorageError,
535    };
536
537    const RESOURCES: [StorageResource; 7] = [
538        StorageResource::GraphNodes,
539        StorageResource::AtomEntries,
540        StorageResource::PrecisionEntries,
541        StorageResource::AssignmentEntries,
542        StorageResource::EvaluationEntries,
543        StorageResource::IsolationEntries,
544        StorageResource::ResolvedEntries,
545    ];
546
547    #[test]
548    fn required_total_rejects_capacity_overflow() {
549        for resource in RESOURCES {
550            assert_eq!(
551                required_elements(usize::MAX, resource),
552                Err(StorageError::CapacityOverflow { resource })
553            );
554        }
555    }
556
557    #[test]
558    fn allocation_failure_reports_total_and_preserves_entries() {
559        let mut entries = vec![10_u32];
560        let result = with_injected_failure(
561            StorageResource::PrecisionEntries,
562            InjectedFailure::Allocation,
563            || reserve_entries(&mut entries, 2, StorageResource::PrecisionEntries),
564        );
565        assert_eq!(
566            result,
567            Err(StorageError::AllocationFailure {
568                resource: StorageResource::PrecisionEntries,
569                requested_elements: 2,
570            })
571        );
572        assert_eq!(entries, [10]);
573    }
574
575    #[test]
576    fn capacity_injection_uses_production_reservation_path() {
577        let mut requirements = PrecisionRequirements::new();
578        let result = with_injected_failure(
579            StorageResource::PrecisionEntries,
580            InjectedFailure::Capacity,
581            || requirements.insert(ConsumerId::new(1), AbsoluteBits::new(20)),
582        );
583        assert_eq!(
584            result,
585            Err(InsertError::Storage(StorageError::CapacityOverflow {
586                resource: StorageResource::PrecisionEntries,
587            }))
588        );
589        assert_eq!(requirements.len(), 0);
590    }
591
592    #[test]
593    fn allocation_injection_identifies_every_resource() {
594        for resource in RESOURCES {
595            let mut entries = Vec::<u32>::new();
596            let result = with_injected_failure(resource, InjectedFailure::Allocation, || {
597                reserve_entries(&mut entries, 1, resource)
598            });
599            assert_eq!(
600                result,
601                Err(StorageError::AllocationFailure {
602                    resource,
603                    requested_elements: 1,
604                })
605            );
606            assert!(entries.is_empty());
607        }
608    }
609
610    #[test]
611    fn map_order_duplicate_and_set_are_deterministic() {
612        let mut left = PrecisionRequirements::new();
613        left.insert(ConsumerId::new(2), AbsoluteBits::new(20))
614            .unwrap();
615        left.insert(ConsumerId::new(1), AbsoluteBits::new(10))
616            .unwrap();
617
618        let mut right = PrecisionRequirements::new();
619        right
620            .insert(ConsumerId::new(1), AbsoluteBits::new(10))
621            .unwrap();
622        right
623            .insert(ConsumerId::new(2), AbsoluteBits::new(20))
624            .unwrap();
625        assert_eq!(left, right);
626
627        assert_eq!(
628            left.insert(ConsumerId::new(1), AbsoluteBits::new(99)),
629            Err(InsertError::DuplicateId {
630                resource: StorageResource::PrecisionEntries,
631                id: 1,
632            })
633        );
634        assert_eq!(left.get(ConsumerId::new(1)), Some(AbsoluteBits::new(10)));
635
636        left.set(ConsumerId::new(1), AbsoluteBits::new(30)).unwrap();
637        assert_eq!(left.get(ConsumerId::new(1)), Some(AbsoluteBits::new(30)));
638        assert_eq!(left.len(), 2);
639    }
640
641    #[test]
642    fn graph_storage_failure_is_wrapped_and_preserves_graph() {
643        let mut graph = ExprGraph::new();
644        let result = with_injected_failure(
645            StorageResource::GraphNodes,
646            InjectedFailure::Allocation,
647            || graph.push(ExprNode::Atom(AtomId::new(0))),
648        );
649        assert_eq!(
650            result,
651            Err(GraphError::Storage(StorageError::AllocationFailure {
652                resource: StorageResource::GraphNodes,
653                requested_elements: 1,
654            }))
655        );
656        assert!(graph.is_empty());
657    }
658
659    #[test]
660    fn every_input_map_wraps_allocation_failure_and_preserves_its_value() {
661        let mut atoms = AtomStore::new();
662        let atom_result = with_injected_failure(
663            StorageResource::AtomEntries,
664            InjectedFailure::Allocation,
665            || atoms.insert(AtomId::new(4), ExactValue::Monomial(Monomial::one())),
666        );
667        assert_eq!(
668            atom_result,
669            Err(InsertError::Storage(StorageError::AllocationFailure {
670                resource: StorageResource::AtomEntries,
671                requested_elements: 1,
672            }))
673        );
674        assert_eq!(atoms.len(), 0);
675
676        let mut requirements = PrecisionRequirements::new();
677        let precision_result = with_injected_failure(
678            StorageResource::PrecisionEntries,
679            InjectedFailure::Allocation,
680            || requirements.insert(ConsumerId::new(4), AbsoluteBits::new(20)),
681        );
682        assert_eq!(
683            precision_result,
684            Err(InsertError::Storage(StorageError::AllocationFailure {
685                resource: StorageResource::PrecisionEntries,
686                requested_elements: 1,
687            }))
688        );
689        assert_eq!(requirements.len(), 0);
690
691        let mut assignments = Assignments::new();
692        let assignment_result = with_injected_failure(
693            StorageResource::AssignmentEntries,
694            InjectedFailure::Allocation,
695            || assignments.insert(ConsumerId::new(4), crate::ExprId::new(0)),
696        );
697        assert_eq!(
698            assignment_result,
699            Err(InsertError::Storage(StorageError::AllocationFailure {
700                resource: StorageResource::AssignmentEntries,
701                requested_elements: 1,
702            }))
703        );
704        assert_eq!(assignments.len(), 0);
705    }
706
707    #[test]
708    fn atom_clone_failure_is_value_error_with_the_original_payload() {
709        let mut atoms = AtomStore::new();
710        atoms
711            .insert(AtomId::new(0), ExactValue::Monomial(Monomial::one()))
712            .unwrap();
713        assert_eq!(
714            with_clone_failure(CloneContact::Monomial, || atoms.try_clone()),
715            Err(InsertError::Value(EvalError::Monomial(
716                MonomialErrorKind::AllocationFailure {
717                    requested_elements: 19,
718                }
719            )))
720        );
721        assert_eq!(atoms.len(), 1);
722    }
723
724    #[test]
725    fn evaluation_clone_failure_is_local_and_preserves_the_cache_entry() {
726        let mut graph = ExprGraph::new();
727        let failed = graph.push(ExprNode::Atom(AtomId::new(0))).unwrap();
728        let succeeded = graph.push(ExprNode::Atom(AtomId::new(1))).unwrap();
729        let mut atoms = AtomStore::new();
730        atoms
731            .insert(AtomId::new(0), ExactValue::Monomial(Monomial::one()))
732            .unwrap();
733        atoms
734            .insert(AtomId::new(1), ExactValue::FormSum(FormSum::one().unwrap()))
735            .unwrap();
736        let mut requirements = PrecisionRequirements::new();
737        let mut assignments = Assignments::new();
738        for (consumer, expression) in [
739            (ConsumerId::new(0), failed),
740            (ConsumerId::new(1), succeeded),
741        ] {
742            requirements.insert(consumer, AbsoluteBits::new(0)).unwrap();
743            assignments.insert(consumer, expression).unwrap();
744        }
745        let (evaluation, _, resolved) = with_clone_failure(CloneContact::Monomial, || {
746            Resolver::new().resolve_all(&graph, &atoms, &requirements, &assignments)
747        })
748        .unwrap();
749        let expected = EvalError::Monomial(MonomialErrorKind::AllocationFailure {
750            requested_elements: 19,
751        });
752        assert_eq!(evaluation.get(failed), Some(&Err(expected)));
753        assert_eq!(
754            resolved.get(ConsumerId::new(0)),
755            Some(&Err(ResolveError::Evaluation(EvalError::Monomial(
756                MonomialErrorKind::AllocationFailure {
757                    requested_elements: 19,
758                }
759            ))))
760        );
761        assert!(resolved.get(ConsumerId::new(1)).unwrap().as_ref().is_ok());
762    }
763
764    #[test]
765    fn resolver_reports_evaluation_and_result_storage_failures_globally() {
766        let mut graph = ExprGraph::new();
767        let expr = graph.push(ExprNode::Atom(AtomId::new(0))).unwrap();
768        let mut atoms = AtomStore::new();
769        atoms
770            .insert(AtomId::new(0), ExactValue::Monomial(Monomial::one()))
771            .unwrap();
772        let mut requirements = PrecisionRequirements::new();
773        requirements
774            .insert(ConsumerId::new(0), AbsoluteBits::new(0))
775            .unwrap();
776        let mut assignments = Assignments::new();
777        assignments.insert(ConsumerId::new(0), expr).unwrap();
778
779        for resource in [
780            StorageResource::EvaluationEntries,
781            StorageResource::ResolvedEntries,
782        ] {
783            let result = with_injected_failure(resource, InjectedFailure::Allocation, || {
784                Resolver::new().resolve_all(&graph, &atoms, &requirements, &assignments)
785            });
786            assert_eq!(
787                result,
788                Err(ResolveError::Storage(StorageError::AllocationFailure {
789                    resource,
790                    requested_elements: 1,
791                }))
792            );
793        }
794    }
795
796    #[test]
797    fn resolver_reports_isolation_storage_failure_globally() {
798        let form = FormSum::one().unwrap();
799        let mut graph = ExprGraph::new();
800        let expr = graph.push(ExprNode::Atom(AtomId::new(0))).unwrap();
801        let mut atoms = AtomStore::new();
802        atoms
803            .insert(
804                AtomId::new(0),
805                ExactValue::Algebraic(RealAlgebraic::from_form_sum(&form).unwrap()),
806            )
807            .unwrap();
808        let mut requirements = PrecisionRequirements::new();
809        requirements
810            .insert(ConsumerId::new(0), AbsoluteBits::new(0))
811            .unwrap();
812        let mut assignments = Assignments::new();
813        assignments.insert(ConsumerId::new(0), expr).unwrap();
814
815        let result = with_injected_failure(
816            StorageResource::IsolationEntries,
817            InjectedFailure::Allocation,
818            || Resolver::new().resolve_all(&graph, &atoms, &requirements, &assignments),
819        );
820        assert_eq!(
821            result,
822            Err(ResolveError::Storage(StorageError::AllocationFailure {
823                resource: StorageResource::IsolationEntries,
824                requested_elements: 1,
825            }))
826        );
827    }
828}