trybox 0.1.2

stable, `no_std`-compatible, fallible heap allocation
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

use core::{
    alloc::{GlobalAlloc, Layout},
    ptr,
    sync::atomic::AtomicBool,
};
use std::{io, sync::atomic::Ordering};

use expect_test::{expect_file, ExpectFile};
use libtest_mimic::{Arguments, Trial};

#[global_allocator]
static ALLOC: FailOrFallback = FailOrFallback::system();

fn main() {
    let mut args = Arguments::from_args();
    args.test_threads = Some(1);
    libtest_mimic::run(
        &args,
        vec![
            error_message(
                "i32-error-message",
                expect_file!["i32-error-message.expected"],
                1i32,
            ),
            error_message(
                "2k-error-message",
                expect_file!["2k-error-message.expected"],
                [0u8; 2048],
            ),
            error_message(
                "2.5k-error-message",
                expect_file!["2.5k-error-message.expected"],
                [0u8; 2500],
            ),
            Trial::test("io-error-kind", || {
                let e: io::Error = fail_alloc(1).into();
                assert_eq!(e.kind(), io::ErrorKind::OutOfMemory);
                let e: io::ErrorKind = fail_alloc(1).into();
                assert_eq!(e, io::ErrorKind::OutOfMemory);
                Ok(())
            }),
        ],
    )
    .exit()
}

fn error_message<T: Send + 'static>(name: &str, file: ExpectFile, x: T) -> Trial {
    Trial::test(name, move || {
        let err = fail_alloc(x).to_string();
        file.assert_eq(&err);
        Ok(())
    })
}

fn fail_alloc<T>(x: T) -> trybox::Error {
    ALLOC.fail();
    let Err(err) = trybox::or_drop(x) else {
        unreachable!("we've made the allocator start failing")
    };
    ALLOC.fallback();
    err
}

#[derive(Debug, Default)]
pub struct FailOrFallback<T = std::alloc::System> {
    fail: AtomicBool,
    fallback: T,
}

impl FailOrFallback {
    /// See [new](FailOrFallback::new).
    pub const fn system() -> Self {
        Self::new(std::alloc::System)
    }
}

impl<T> FailOrFallback<T> {
    /// Create a new allocator, which uses the fallback by default.
    ///
    /// This behaviour allows e.g the rust runtime to initialize when using
    /// `#[global_allocator]`
    pub const fn new(fallback: T) -> Self {
        FailOrFallback {
            fail: AtomicBool::new(false),
            fallback,
        }
    }
    /// Allocations after this call will always fail.
    pub fn fail(&self) {
        self.fail.store(true, Ordering::Release);
    }
    /// Allocations after this call will use the fallback allocator.
    pub fn fallback(&self) {
        self.fail.store(false, Ordering::Release);
    }
}

unsafe impl GlobalAlloc for FailOrFallback {
    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
        match self.fail.load(Ordering::Acquire) {
            true => ptr::null_mut(),
            false => self.fallback.alloc(layout),
        }
    }
    unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
        self.fallback.dealloc(ptr, layout);
    }
}