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}