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