1 use crossbeam_deque::Steal::Success;
2 use crossbeam_deque::{Injector, Worker};
3
4 #[test]
steal_fifo()5 fn steal_fifo() {
6 let w = Worker::new_fifo();
7 for i in 1..=3 {
8 w.push(i);
9 }
10
11 let s = w.stealer();
12 assert_eq!(s.steal(), Success(1));
13 assert_eq!(s.steal(), Success(2));
14 assert_eq!(s.steal(), Success(3));
15 }
16
17 #[test]
steal_lifo()18 fn steal_lifo() {
19 let w = Worker::new_lifo();
20 for i in 1..=3 {
21 w.push(i);
22 }
23
24 let s = w.stealer();
25 assert_eq!(s.steal(), Success(1));
26 assert_eq!(s.steal(), Success(2));
27 assert_eq!(s.steal(), Success(3));
28 }
29
30 #[test]
steal_injector()31 fn steal_injector() {
32 let q = Injector::new();
33 for i in 1..=3 {
34 q.push(i);
35 }
36
37 assert_eq!(q.steal(), Success(1));
38 assert_eq!(q.steal(), Success(2));
39 assert_eq!(q.steal(), Success(3));
40 }
41
42 #[test]
steal_batch_fifo_fifo()43 fn steal_batch_fifo_fifo() {
44 let w = Worker::new_fifo();
45 for i in 1..=4 {
46 w.push(i);
47 }
48
49 let s = w.stealer();
50 let w2 = Worker::new_fifo();
51
52 assert_eq!(s.steal_batch(&w2), Success(()));
53 assert_eq!(w2.pop(), Some(1));
54 assert_eq!(w2.pop(), Some(2));
55 }
56
57 #[test]
steal_batch_lifo_lifo()58 fn steal_batch_lifo_lifo() {
59 let w = Worker::new_lifo();
60 for i in 1..=4 {
61 w.push(i);
62 }
63
64 let s = w.stealer();
65 let w2 = Worker::new_lifo();
66
67 assert_eq!(s.steal_batch(&w2), Success(()));
68 assert_eq!(w2.pop(), Some(2));
69 assert_eq!(w2.pop(), Some(1));
70 }
71
72 #[test]
steal_batch_fifo_lifo()73 fn steal_batch_fifo_lifo() {
74 let w = Worker::new_fifo();
75 for i in 1..=4 {
76 w.push(i);
77 }
78
79 let s = w.stealer();
80 let w2 = Worker::new_lifo();
81
82 assert_eq!(s.steal_batch(&w2), Success(()));
83 assert_eq!(w2.pop(), Some(1));
84 assert_eq!(w2.pop(), Some(2));
85 }
86
87 #[test]
steal_batch_lifo_fifo()88 fn steal_batch_lifo_fifo() {
89 let w = Worker::new_lifo();
90 for i in 1..=4 {
91 w.push(i);
92 }
93
94 let s = w.stealer();
95 let w2 = Worker::new_fifo();
96
97 assert_eq!(s.steal_batch(&w2), Success(()));
98 assert_eq!(w2.pop(), Some(2));
99 assert_eq!(w2.pop(), Some(1));
100 }
101
102 #[test]
steal_batch_injector_fifo()103 fn steal_batch_injector_fifo() {
104 let q = Injector::new();
105 for i in 1..=4 {
106 q.push(i);
107 }
108
109 let w2 = Worker::new_fifo();
110 assert_eq!(q.steal_batch(&w2), Success(()));
111 assert_eq!(w2.pop(), Some(1));
112 assert_eq!(w2.pop(), Some(2));
113 }
114
115 #[test]
steal_batch_injector_lifo()116 fn steal_batch_injector_lifo() {
117 let q = Injector::new();
118 for i in 1..=4 {
119 q.push(i);
120 }
121
122 let w2 = Worker::new_lifo();
123 assert_eq!(q.steal_batch(&w2), Success(()));
124 assert_eq!(w2.pop(), Some(1));
125 assert_eq!(w2.pop(), Some(2));
126 }
127
128 #[test]
steal_batch_and_pop_fifo_fifo()129 fn steal_batch_and_pop_fifo_fifo() {
130 let w = Worker::new_fifo();
131 for i in 1..=6 {
132 w.push(i);
133 }
134
135 let s = w.stealer();
136 let w2 = Worker::new_fifo();
137
138 assert_eq!(s.steal_batch_and_pop(&w2), Success(1));
139 assert_eq!(w2.pop(), Some(2));
140 assert_eq!(w2.pop(), Some(3));
141 }
142
143 #[test]
steal_batch_and_pop_lifo_lifo()144 fn steal_batch_and_pop_lifo_lifo() {
145 let w = Worker::new_lifo();
146 for i in 1..=6 {
147 w.push(i);
148 }
149
150 let s = w.stealer();
151 let w2 = Worker::new_lifo();
152
153 assert_eq!(s.steal_batch_and_pop(&w2), Success(3));
154 assert_eq!(w2.pop(), Some(2));
155 assert_eq!(w2.pop(), Some(1));
156 }
157
158 #[test]
steal_batch_and_pop_fifo_lifo()159 fn steal_batch_and_pop_fifo_lifo() {
160 let w = Worker::new_fifo();
161 for i in 1..=6 {
162 w.push(i);
163 }
164
165 let s = w.stealer();
166 let w2 = Worker::new_lifo();
167
168 assert_eq!(s.steal_batch_and_pop(&w2), Success(1));
169 assert_eq!(w2.pop(), Some(2));
170 assert_eq!(w2.pop(), Some(3));
171 }
172
173 #[test]
steal_batch_and_pop_lifo_fifo()174 fn steal_batch_and_pop_lifo_fifo() {
175 let w = Worker::new_lifo();
176 for i in 1..=6 {
177 w.push(i);
178 }
179
180 let s = w.stealer();
181 let w2 = Worker::new_fifo();
182
183 assert_eq!(s.steal_batch_and_pop(&w2), Success(3));
184 assert_eq!(w2.pop(), Some(2));
185 assert_eq!(w2.pop(), Some(1));
186 }
187
188 #[test]
steal_batch_and_pop_injector_fifo()189 fn steal_batch_and_pop_injector_fifo() {
190 let q = Injector::new();
191 for i in 1..=6 {
192 q.push(i);
193 }
194
195 let w2 = Worker::new_fifo();
196 assert_eq!(q.steal_batch_and_pop(&w2), Success(1));
197 assert_eq!(w2.pop(), Some(2));
198 assert_eq!(w2.pop(), Some(3));
199 }
200
201 #[test]
steal_batch_and_pop_injector_lifo()202 fn steal_batch_and_pop_injector_lifo() {
203 let q = Injector::new();
204 for i in 1..=6 {
205 q.push(i);
206 }
207
208 let w2 = Worker::new_lifo();
209 assert_eq!(q.steal_batch_and_pop(&w2), Success(1));
210 assert_eq!(w2.pop(), Some(2));
211 assert_eq!(w2.pop(), Some(3));
212 }
213