flurry 0.5.2

Rust port of Java's ConcurrentHashMap
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

use flurry::*;
use std::sync::Arc;

// These tests all use `K = String` and `Q = str` for `Borrow`-based lookups

#[test]
fn get_empty() {
    let map = HashMap::<String, usize>::new();

    {
        let guard = map.guard();
        let e = map.get("foo", &guard);
        assert!(e.is_none());
    }
}

#[test]
fn remove_empty() {
    let map = HashMap::<String, usize>::new();

    {
        let guard = map.guard();
        let old = map.remove("foo", &guard);
        assert!(old.is_none());
    }
}

#[test]
fn insert_and_remove() {
    let map = HashMap::<String, usize>::new();

    {
        let guard = map.guard();
        map.insert("foo".to_string(), 0, &guard);
        let old = map.remove("foo", &guard).unwrap();
        assert_eq!(old, &0);
        assert!(map.get("foo", &guard).is_none());
    }
}

#[test]
fn insert_and_get() {
    let map = HashMap::<String, usize>::new();

    map.insert("foo".to_string(), 0, &map.guard());
    {
        let guard = map.guard();
        let e = map.get("foo", &guard).unwrap();
        assert_eq!(e, &0);
    }
}

#[test]
fn update() {
    let map = HashMap::<String, usize>::new();

    let guard = map.guard();
    map.insert("foo".to_string(), 0, &guard);
    let old = map.insert("foo".to_string(), 1, &guard);
    assert_eq!(old, Some(&0));
    {
        let guard = map.guard();
        let e = map.get("foo", &guard).unwrap();
        assert_eq!(e, &1);
    }
}

#[test]
#[cfg_attr(miri, ignore)]
fn concurrent_insert() {
    let map = Arc::new(HashMap::<String, usize>::new());
    let keys = Arc::new((0..64).map(|i| i.to_string()).collect::<Vec<_>>());

    let map1 = map.clone();
    let keys1 = keys.clone();
    let t1 = std::thread::spawn(move || {
        for key in keys1.iter() {
            map1.insert(key.clone(), 0, &map1.guard());
        }
    });
    let map2 = map.clone();
    let keys2 = keys.clone();
    let t2 = std::thread::spawn(move || {
        for key in keys2.iter() {
            map2.insert(key.clone(), 1, &map2.guard());
        }
    });

    t1.join().unwrap();
    t2.join().unwrap();

    let guard = map.guard();
    for key in keys.iter() {
        let v = map.get(key.as_str(), &guard).unwrap();
        assert!(v == &0 || v == &1);
    }
}

#[test]
#[cfg_attr(miri, ignore)]
fn concurrent_remove() {
    let map = Arc::new(HashMap::<String, usize>::new());
    let keys = Arc::new((0..64).map(|i| i.to_string()).collect::<Vec<_>>());

    {
        let guard = map.guard();
        for (i, key) in keys.iter().enumerate() {
            map.insert(key.clone(), i, &guard);
        }
    }

    let map1 = map.clone();
    let keys1 = keys.clone();
    let t1 = std::thread::spawn(move || {
        let guard = map1.guard();
        for (i, key) in keys1.iter().enumerate() {
            if let Some(v) = map1.remove(key.as_str(), &guard) {
                assert_eq!(v, &i);
            }
        }
    });
    let map2 = map.clone();
    let keys2 = keys.clone();
    let t2 = std::thread::spawn(move || {
        let guard = map2.guard();
        for (i, key) in keys2.iter().enumerate() {
            if let Some(v) = map2.remove(key.as_str(), &guard) {
                assert_eq!(v, &i);
            }
        }
    });

    t1.join().unwrap();
    t2.join().unwrap();

    // after joining the threads, the map should be empty
    let guard = map.guard();
    for key in keys.iter() {
        assert!(map.get(key.as_str(), &guard).is_none());
    }
}