unimock 0.6.7

A versatile and developer-friendly trait mocking library
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
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

use core::any::Any;
use once_cell::sync::OnceCell;

use crate::alloc::Box;

/// A collection that can store values, but never remove them until dropped.
///
/// This allows retaining shared references to inserted values.
#[derive(Default)]
pub struct ValueChain {
    root: OnceCell<Node>,
}

impl ValueChain {
    pub fn push<T: Any + Send + Sync>(&self, value: T) -> &T {
        self.push_value(Value::Send(Box::new(value)))
            .downcast_ref::<T>()
            .unwrap()
    }

    pub fn push_mut<T: Any + Send + Sync>(&mut self, value: T) -> &mut T {
        self.push_value_mut(Value::Send(Box::new(value)))
            .downcast_mut::<T>()
            .unwrap()
    }
}

#[cfg(feature = "fragile")]
impl ValueChain {
    pub fn push_fragile<T: Any>(&self, value: T) -> &T {
        self.push_value(Value::Fragile(fragile::Fragile::new(Box::new(value))))
            .downcast_ref::<T>()
            .unwrap()
    }

    pub fn push_fragile_mut<T: Any>(&mut self, value: T) -> &mut T {
        self.push_value_mut(Value::Fragile(fragile::Fragile::new(Box::new(value))))
            .downcast_mut::<T>()
            .unwrap()
    }
}

impl ValueChain {
    fn push_value(&self, value: Value) -> &Value {
        let node = self.push_node(Node::new(value));

        &node.value
    }

    fn push_value_mut(&mut self, value: Value) -> &mut Value {
        // note: There is no need for keeping the old chain.
        // All those references are out of scope when add_mut is called.
        self.root = Node::new(value).into();

        &mut self.root.get_mut().unwrap().value
    }

    fn push_node(&self, mut new_node: Node) -> &Node {
        let mut cell = &self.root;
        loop {
            match cell.try_insert(new_node) {
                Ok(new_node) => {
                    return new_node;
                }
                Err((parent_node, node)) => {
                    new_node = node;
                    cell = &parent_node.next;
                }
            }
        }
    }
}

impl Drop for ValueChain {
    fn drop(&mut self) {
        if let Some(node) = self.root.take() {
            drop(node.value);
            let mut cell = node.next;

            while let Some(node) = cell.take() {
                drop(node.value);
                cell = node.next;
            }
        }
    }
}

struct Node {
    value: Value,
    next: Box<OnceCell<Node>>,
}

impl Node {
    fn new(value: Value) -> Self {
        Self {
            value,
            next: Default::default(),
        }
    }
}

enum Value {
    Send(Box<dyn Any + Send + Sync>),
    #[cfg(feature = "fragile")]
    Fragile(fragile::Fragile<Box<dyn Any>>),
}

impl Value {
    fn downcast_ref<T: 'static>(&self) -> Option<&T> {
        match self {
            Self::Send(any) => any.downcast_ref::<T>(),
            #[cfg(feature = "fragile")]
            Self::Fragile(fragile) => fragile.get().downcast_ref::<T>(),
        }
    }

    fn downcast_mut<T: 'static>(&mut self) -> Option<&mut T> {
        match self {
            Self::Send(any) => any.downcast_mut::<T>(),
            #[cfg(feature = "fragile")]
            Self::Fragile(fragile) => fragile.get_mut().downcast_mut::<T>(),
        }
    }
}

#[test]
fn it_works() {
    let value_chain = ValueChain::default();
    let first = value_chain.push(1);
    let second = value_chain.push("");
    let third = value_chain.push(42.0);

    assert_eq!(&1, first);
    assert_eq!(&"", second);
    assert_eq!(&42.0, third);
}

#[test]
fn it_works_mut() {
    let mut value_chain = ValueChain::default();
    let first = value_chain.push_mut(1);
    *first += 1;
}