rust-cc 0.6.2

A cycle collector for Rust programs
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

#![cfg(not(miri))] // This test leaks memory, so it can't be run by Miri
#![cfg(all(feature = "weak-ptrs", feature = "derive"))]
//! This module tests that `Weak::upgrade` returns None when called in destructors while collecting.

use std::cell::RefCell;
use std::panic::{AssertUnwindSafe, catch_unwind};
use rust_cc::*;
use rust_cc::weak::*;

use test_case::test_case;

struct Ignored<T: Trace + 'static> {
    weak: Weak<T>,
    should_panic: bool,
}

impl<T: Trace> Drop for Ignored<T> {
    fn drop(&mut self) {
        // This is safe to implement
        assert!(self.weak.upgrade().is_none());

        assert!(!self.should_panic, "Expected panic");
    }
}

#[test_case(false)]
#[test_case(true)]
fn acyclic_upgrade(should_panic: bool) {
    #[derive(Trace, Finalize)]
    struct Allocated {
        #[rust_cc(ignore)]
        _ignored: Ignored<Allocated>,
    }

    let cc = Cc::new_cyclic(|weak| Allocated {
        _ignored: Ignored {
            weak: weak.clone(),
            should_panic,
        },
    });

    let weak = cc.downgrade();

    let res = catch_unwind(AssertUnwindSafe(|| {
        drop(cc);
    }));

    assert_eq!(should_panic, res.is_err());

    assert!(weak.upgrade().is_none());
}

#[test_case(false)]
#[test_case(true)]
fn cyclic_upgrade(should_panic: bool) {
    #[derive(Trace, Finalize)]
    struct Allocated {
        #[rust_cc(ignore)]
        _ignored: Ignored<Allocated>,
        cyclic: RefCell<Option<Cc<Self>>>,
    }

    let cc1 = Cc::new_cyclic(|weak| Allocated {
        _ignored: Ignored {
            weak: weak.clone(),
            should_panic,
        },
        cyclic: RefCell::new(None),
    });
    let cc2 = Cc::new_cyclic(|weak| Allocated {
        _ignored: Ignored {
            weak: weak.clone(),
            should_panic,
        },
        cyclic: RefCell::new(None),
    });
    let cc3 = Cc::new_cyclic(|weak| Allocated {
        _ignored: Ignored {
            weak: weak.clone(),
            should_panic,
        },
        cyclic: RefCell::new(None),
    });

    *cc1.cyclic.borrow_mut() = Some(cc2.clone());
    *cc2.cyclic.borrow_mut() = Some(cc3.clone());
    *cc3.cyclic.borrow_mut() = Some(cc1.clone());

    let weak1 = cc1.downgrade();
    let weak2 = cc2.downgrade();
    let weak3 = cc3.downgrade();

    drop(cc1);
    drop(cc2);
    drop(cc3);

    let res = catch_unwind(AssertUnwindSafe(|| {
        collect_cycles();
    }));

    assert_eq!(should_panic, res.is_err());

    assert!(weak1.upgrade().is_none());
    assert!(weak2.upgrade().is_none());
    assert!(weak3.upgrade().is_none());
}