1 package io.atlassian.fugue.extensions.step;
2
3 import io.atlassian.fugue.Either;
4 import io.atlassian.fugue.Unit;
5 import org.junit.Test;
6
7 import java.util.function.Supplier;
8
9 import static io.atlassian.fugue.Either.left;
10 import static io.atlassian.fugue.Either.right;
11 import static io.atlassian.fugue.Unit.Unit;
12 import static io.atlassian.fugue.extensions.step.TestUtils.alwaysFalse;
13 import static io.atlassian.fugue.extensions.step.TestUtils.alwaysFalse2;
14 import static io.atlassian.fugue.extensions.step.TestUtils.alwaysFalse3;
15 import static io.atlassian.fugue.extensions.step.TestUtils.alwaysFalse4;
16 import static io.atlassian.fugue.extensions.step.TestUtils.alwaysFalse5;
17 import static io.atlassian.fugue.extensions.step.TestUtils.alwaysFalse6;
18 import static io.atlassian.fugue.extensions.step.TestUtils.alwaysTrue;
19 import static io.atlassian.fugue.extensions.step.TestUtils.alwaysTrue2;
20 import static io.atlassian.fugue.extensions.step.TestUtils.alwaysTrue3;
21 import static io.atlassian.fugue.extensions.step.TestUtils.alwaysTrue4;
22 import static io.atlassian.fugue.extensions.step.TestUtils.alwaysTrue5;
23 import static io.atlassian.fugue.extensions.step.TestUtils.alwaysTrue6;
24 import static io.atlassian.fugue.hamcrest.EitherMatchers.isLeft;
25 import static io.atlassian.fugue.hamcrest.EitherMatchers.isRight;
26 import static org.hamcrest.CoreMatchers.is;
27 import static org.junit.Assert.assertThat;
28
29 public class TestEitherSteps {
30
31 private static final String STRING = "123456";
32 private static final String STRING_UPPERED = "QWERTY";
33 private static final String STRING_LOWERED = "qwerty";
34 private static final Long LONG = 123456L;
35 private static final Long LONGLONG = 123456123456L;
36 private static final Supplier<AnError> filterAnErrorFunction = () -> AnError.FILTER;
37
38 @Test public void test_1_step_success() {
39 Either<AnError, Long> stepped = Steps.begin(ok(STRING)).yield(Long::new);
40
41 assertThat(stepped, isRight(is(LONG)));
42 }
43
44 @Test public void test_1_step_failure() {
45 Either<AnError, Unit> stepped = Steps.begin(error(AnError.FIRST)).yield(value1 -> Unit());
46
47 assertThat(stepped, isLeft(is(AnError.FIRST)));
48 }
49
50 @Test public void test_1_step_filter_success() {
51 Either<AnError, Long> stepped = Steps.begin(ok(STRING)).filter(alwaysTrue(), filterAnErrorFunction).yield(Long::new);
52
53 assertThat(stepped, isRight(is(LONG)));
54 }
55
56 @Test public void test_1_step_filter_failure() {
57 Either<AnError, Long> stepped = Steps.begin(ok(STRING)).filter(alwaysFalse(), filterAnErrorFunction).yield(Long::new);
58
59 assertThat(stepped, isLeft(is(AnError.FILTER)));
60 }
61
62 @Test public void test_2_step_success_functor() {
63 Either<AnError, Long> stepped = Steps.begin(ok(STRING)).then((firstValue) -> ok(STRING)).yield((value1, value2) -> new Long(value1 + value2));
64
65 assertThat(stepped, isRight(is(LONGLONG)));
66 }
67
68 @Test public void test_2_step_success_supplier() {
69 Either<AnError, Long> stepped = Steps.begin(ok(STRING)).then(() -> ok(STRING)).yield((value1, value2) -> new Long(value1 + value2));
70
71 assertThat(stepped, isRight(is(LONGLONG)));
72 }
73
74 @Test public void test_2_step_failure_functor() {
75 Either<AnError, Long> stepped = Steps.begin(ok(STRING)).then(v -> error(AnError.SECOND)).yield((value1, value2) -> new Long(value1));
76
77 assertThat(stepped, isLeft(is(AnError.SECOND)));
78 }
79
80 @Test public void test_2_step_failure_supplier() {
81 Either<AnError, Long> stepped = Steps.begin(ok(STRING)).then(() -> error(AnError.SECOND)).yield((value1, value2) -> new Long(value1));
82
83 assertThat(stepped, isLeft(is(AnError.SECOND)));
84 }
85
86 @Test public void test_2_step_failure_1() {
87 Either<AnError, Long> stepped = Steps.begin(error(AnError.FIRST)).then(() -> ok(9)).yield((value1, value2) -> new Long(value2));
88
89 assertThat(stepped, isLeft(is(AnError.FIRST)));
90 }
91
92 @Test public void test_2_step_filter_success() {
93 Either<AnError, Long> stepped = Steps.begin(ok(STRING)).then(() -> ok(LONG)).filter(alwaysTrue2(), filterAnErrorFunction).yield((v1, v2) -> v2);
94
95 assertThat(stepped, isRight(is(LONG)));
96 }
97
98 @Test public void test_2_step_filter_failure() {
99 Either<AnError, Long> stepped = Steps.begin(ok(STRING)).then(() -> ok(LONG)).filter(alwaysFalse2(), filterAnErrorFunction).yield((v1, v2) -> v2);
100
101 assertThat(stepped, isLeft(is(AnError.FILTER)));
102 }
103
104 @Test public void test_2_step_filter_failure_1() {
105 Either<AnError, Long> stepped = Steps.begin(ok(STRING)).filter(alwaysFalse(), filterAnErrorFunction).then(() -> ok(LONG)).yield((v1, v2) -> v2);
106
107 assertThat(stepped, isLeft(is(AnError.FILTER)));
108 }
109
110 @Test public void test_3_step_success_functor() {
111 Either<AnError, Long> stepped = Steps.begin(ok(STRING)).then(v -> ok(STRING)).then((v1, v2) -> ok(88))
112 .yield((value1, value2, value3) -> new Long(value1 + value2));
113
114 assertThat(stepped, isRight(is(LONGLONG)));
115 }
116
117 @Test public void test_3_step_success_supplier() {
118 Either<AnError, Long> stepped = Steps.begin(ok(STRING)).then(() -> ok(STRING)).then(() -> ok(88))
119 .yield((value1, value2, value3) -> new Long(value1 + value2));
120
121 assertThat(stepped, isRight(is(LONGLONG)));
122 }
123
124 @Test public void test_3_step_failure_functor() {
125 Either<AnError, Long> stepped = Steps.begin(ok(STRING)).then(v -> ok(STRING)).then((v1, v2) -> error(AnError.THIRD))
126 .yield((value1, value2, value3) -> new Long(value1));
127
128 assertThat(stepped, isLeft(is(AnError.THIRD)));
129 }
130
131 @Test public void test_3_step_failure_supplier() {
132 Either<AnError, Long> stepped = Steps.begin(ok(STRING)).then(() -> ok(STRING)).then(() -> error(AnError.THIRD))
133 .yield((value1, value2, value3) -> new Long(value1));
134
135 assertThat(stepped, isLeft(is(AnError.THIRD)));
136 }
137
138 @Test public void test_3_step_failure_1() {
139 Either<AnError, Long> stepped = Steps.begin(error(AnError.FIRST)).then(() -> ok(STRING)).then((v1, v2) -> ok(LONG))
140 .yield((value1, value2, value3) -> value3);
141
142 assertThat(stepped, isLeft(is(AnError.FIRST)));
143 }
144
145 @Test public void test_3_step_failure_2() {
146 Either<AnError, Long> stepped = Steps.begin(ok(STRING)).then(() -> error(AnError.SECOND)).then((v1, v2) -> ok(LONG))
147 .yield((value1, value2, value3) -> new Long(value1));
148
149 assertThat(stepped, isLeft(is(AnError.SECOND)));
150 }
151
152 @Test public void test_3_step_filter_success() {
153 Either<AnError, Long> stepped = Steps.begin(ok(STRING)).then(() -> ok(LONG)).then(() -> ok(STRING_LOWERED))
154 .filter(alwaysTrue3(), filterAnErrorFunction).yield((v1, v2, v3) -> v2);
155
156 assertThat(stepped, isRight(is(LONG)));
157 }
158
159 @Test public void test_3_step_filter_failure() {
160 Either<AnError, Long> stepped = Steps.begin(ok(STRING)).then(() -> ok(LONG)).then(() -> ok(STRING_LOWERED))
161 .filter(alwaysFalse3(), filterAnErrorFunction).yield((v1, v2, v3) -> v2);
162
163 assertThat(stepped, isLeft(is(AnError.FILTER)));
164 }
165
166 @Test public void test_3_step_filter_failure_1() {
167 Either<AnError, Long> stepped = Steps.begin(ok(STRING)).filter(alwaysFalse(), filterAnErrorFunction).then(() -> ok(LONG))
168 .then(() -> ok(STRING_LOWERED)).yield((v1, v2, v3) -> v2);
169
170 assertThat(stepped, isLeft(is(AnError.FILTER)));
171 }
172
173 @Test public void test_3_step_filter_failure_2() {
174 Either<AnError, Long> stepped = Steps.begin(ok(STRING)).then(() -> ok(LONG)).filter(alwaysFalse2(), filterAnErrorFunction)
175 .then(() -> ok(STRING_LOWERED)).yield((v1, v2, v3) -> v2);
176
177 assertThat(stepped, isLeft(is(AnError.FILTER)));
178 }
179
180 @Test public void test_4_step_success_functor() {
181 Either<AnError, Long> stepped = Steps.begin(ok(STRING)).then(v -> ok(STRING)).then((first, second) -> ok(first + second))
182 .then((v1, v2, v3) -> ok(STRING)).yield((value1, value2, value3, value4) -> new Long(value3));
183
184 assertThat(stepped, isRight(is(LONGLONG)));
185 }
186
187 @Test public void test_4_step_success_supplier() {
188 Either<AnError, Long> stepped = Steps.begin(ok(STRING)).then(() -> ok(STRING)).then(() -> ok(STRING + STRING)).then(() -> ok(STRING))
189 .yield((value1, value2, value3, value4) -> new Long(value3));
190
191 assertThat(stepped, isRight(is(LONGLONG)));
192 }
193
194 @Test public void test_4_step_failure_functor() {
195 Either<AnError, Long> stepped = Steps.begin(ok(STRING)).then(v -> ok(STRING)).then((s, s2) -> ok(STRING))
196 .then((s, s2, s3) -> error(AnError.FOURTH)).yield((value1, value2, value3, value4) -> new Long(value1));
197
198 assertThat(stepped, isLeft(is(AnError.FOURTH)));
199 }
200
201 @Test public void test_4_step_failure_supplier() {
202 Either<AnError, Long> stepped = Steps.begin(ok(STRING)).then(() -> ok(STRING)).then(() -> ok(STRING)).then(() -> error(AnError.FOURTH))
203 .yield((value1, value2, value3, value4) -> new Long(value1));
204
205 assertThat(stepped, isLeft(is(AnError.FOURTH)));
206 }
207
208 @Test public void test_4_step_failure_1() {
209 Either<AnError, Long> stepped = Steps.begin(error(AnError.FIRST)).then(() -> ok(STRING)).then(() -> ok(STRING + STRING)).then(() -> ok(STRING))
210 .yield((value1, value2, value3, value4) -> new Long(value3));
211
212 assertThat(stepped, isLeft(is(AnError.FIRST)));
213 }
214
215 @Test public void test_4_step_failure_2() {
216 Either<AnError, Long> stepped = Steps.begin(ok(STRING)).then(() -> error(AnError.SECOND)).then(() -> ok(STRING + STRING)).then(() -> ok(STRING))
217 .yield((value1, value2, value3, value4) -> new Long(value3));
218
219 assertThat(stepped, isLeft(is(AnError.SECOND)));
220 }
221
222 @Test public void test_4_step_failure_3() {
223 Either<AnError, Long> stepped = Steps.begin(ok(STRING)).then(() -> ok(STRING)).then(() -> error(AnError.THIRD)).then(() -> ok(STRING))
224 .yield((value1, value2, value3, value4) -> new Long(value4));
225
226 assertThat(stepped, isLeft(is(AnError.THIRD)));
227 }
228
229 @Test public void test_4_step_filter_success() {
230 Either<AnError, Long> stepped = Steps.begin(ok(STRING)).then(() -> ok(LONG)).then(() -> ok(STRING_LOWERED)).then(() -> ok(true))
231 .filter(alwaysTrue4(), filterAnErrorFunction).yield((v1, v2, v3, v4) -> v2);
232
233 assertThat(stepped, isRight(is(LONG)));
234 }
235
236 @Test public void test_4_step_filter_failure() {
237 Either<AnError, Long> stepped = Steps.begin(ok(STRING)).then(() -> ok(LONG)).then(() -> ok(STRING_LOWERED)).then(() -> ok(true))
238 .filter(alwaysFalse4(), filterAnErrorFunction).yield((v1, v2, v3, v4) -> v2);
239
240 assertThat(stepped, isLeft(is(AnError.FILTER)));
241 }
242
243 @Test public void test_4_step_filter_failure_1() {
244 Either<AnError, Long> stepped = Steps.begin(ok(STRING)).filter(alwaysFalse(), filterAnErrorFunction).then(() -> ok(LONG))
245 .then(() -> ok(STRING_LOWERED)).then(() -> ok(true)).yield((v1, v2, v3, v4) -> v2);
246
247 assertThat(stepped, isLeft(is(AnError.FILTER)));
248 }
249
250 @Test public void test_4_step_filter_failure_2() {
251 Either<AnError, Long> stepped = Steps.begin(ok(STRING)).then(() -> ok(LONG)).filter(alwaysFalse2(), filterAnErrorFunction)
252 .then(() -> ok(STRING_LOWERED)).then(() -> ok(true)).yield((v1, v2, v3, v4) -> v2);
253
254 assertThat(stepped, isLeft(is(AnError.FILTER)));
255 }
256
257 @Test public void test_4_step_filter_failure_3() {
258 Either<AnError, Long> stepped = Steps.begin(ok(STRING)).then(() -> ok(LONG)).then(() -> ok(STRING_LOWERED))
259 .filter(alwaysFalse3(), filterAnErrorFunction).then(() -> ok(true)).yield((v1, v2, v3, v4) -> v2);
260
261 assertThat(stepped, isLeft(is(AnError.FILTER)));
262 }
263
264 @Test public void test_5_step_success_functor() {
265 Either<AnError, Long> stepped = Steps.begin(ok(STRING)).then(v -> ok(STRING)).then((first, second) -> ok(first + second))
266 .then((v1, v2, v3) -> ok(STRING)).then((v1, v2, v3, v4) -> ok(STRING)).yield((value1, value2, value3, value4, value5) -> new Long(value3));
267
268 assertThat(stepped, isRight(is(LONGLONG)));
269 }
270
271 @Test public void test_5_step_success_supplier() {
272 Either<AnError, Long> stepped = Steps.begin(ok(STRING)).then(() -> ok(STRING)).then(() -> ok(STRING + STRING)).then(() -> ok(STRING))
273 .then(() -> ok(STRING)).yield((value1, value2, value3, value4, value5) -> new Long(value3));
274
275 assertThat(stepped, isRight(is(LONGLONG)));
276 }
277
278 @Test public void test_5_step_failure_functor() {
279 Either<AnError, Long> stepped = Steps.begin(ok(STRING)).then(v -> ok(STRING)).then((first, second) -> ok(first + second))
280 .then((v1, v2, v3) -> ok(STRING)).then((v1, v2, v3, v4) -> error(AnError.FIFTH))
281 .yield((value1, value2, value3, value4, value5) -> new Long(value3));
282
283 assertThat(stepped, isLeft(is(AnError.FIFTH)));
284 }
285
286 @Test public void test_5_step_failure_supplier() {
287 Either<AnError, Long> stepped = Steps.begin(ok(STRING)).then(() -> ok(STRING)).then(() -> ok(STRING + STRING)).then(() -> ok(STRING))
288 .then(() -> error(AnError.FIFTH)).yield((value1, value2, value3, value4, value5) -> new Long(value3));
289
290 assertThat(stepped, isLeft(is(AnError.FIFTH)));
291 }
292
293 @Test public void test_5_step_failure_1() {
294 Either<AnError, Long> stepped = Steps.begin(error(AnError.FIRST)).then(() -> ok(STRING)).then(() -> ok(STRING + STRING)).then(() -> ok(STRING))
295 .then(() -> ok(STRING_LOWERED)).yield((value1, value2, value3, value4, value5) -> new Long(value3));
296
297 assertThat(stepped, isLeft(is(AnError.FIRST)));
298 }
299
300 @Test public void test_5_step_failure_2() {
301 Either<AnError, Long> stepped = Steps.begin(ok(STRING)).then(() -> error(AnError.SECOND)).then(() -> ok(STRING + STRING)).then(() -> ok(STRING))
302 .then(() -> ok(STRING_LOWERED)).yield((value1, value2, value3, value4, value5) -> new Long(value3));
303
304 assertThat(stepped, isLeft(is(AnError.SECOND)));
305 }
306
307 @Test public void test_5_step_failure_3() {
308 Either<AnError, Long> stepped = Steps.begin(ok(STRING)).then(() -> ok(STRING)).then(() -> error(AnError.THIRD)).then(() -> ok(STRING))
309 .then(() -> ok(STRING_LOWERED)).yield((value1, value2, value3, value4, value5) -> new Long(value2));
310
311 assertThat(stepped, isLeft(is(AnError.THIRD)));
312 }
313
314 @Test public void test_5_step_failure_4() {
315 Either<AnError, Long> stepped = Steps.begin(ok(STRING)).then(() -> ok(STRING)).then(() -> ok(STRING + STRING)).then(() -> error(AnError.FOURTH))
316 .then(() -> ok(STRING_LOWERED)).yield((value1, value2, value3, value4, value5) -> new Long(value3));
317
318 assertThat(stepped, isLeft(is(AnError.FOURTH)));
319 }
320
321 @Test public void test_5_step_filter_success() {
322 Either<AnError, Long> stepped = Steps.begin(ok(STRING)).then(v -> ok(STRING)).then((first, second) -> ok(first + second))
323 .then((v1, v2, v3) -> ok(STRING)).then((v1, v2, v3, v4) -> ok(STRING)).filter(alwaysTrue5(), filterAnErrorFunction)
324 .yield((value1, value2, value3, value4, value5) -> new Long(value3));
325
326 assertThat(stepped, isRight(is(LONGLONG)));
327 }
328
329 @Test public void test_5_step_filter_failure() {
330 Either<AnError, Long> stepped = Steps.begin(ok(STRING)).then(v -> ok(STRING)).then((first, second) -> ok(first + second))
331 .then((v1, v2, v3) -> ok(STRING)).then((v1, v2, v3, v4) -> ok(STRING)).filter(alwaysFalse5(), filterAnErrorFunction)
332 .yield((value1, value2, value3, value4, value5) -> new Long(value3));
333
334 assertThat(stepped, isLeft(is(AnError.FILTER)));
335 }
336
337 @Test public void test_5_step_filter_failure_1() {
338 Either<AnError, Long> stepped = Steps.begin(ok(STRING)).filter(alwaysFalse(), filterAnErrorFunction).then(v -> ok(STRING))
339 .then((first, second) -> ok(first + second)).then((v1, v2, v3) -> ok(STRING)).then((v1, v2, v3, v4) -> ok(STRING))
340 .yield((value1, value2, value3, value4, value5) -> new Long(value3));
341
342 assertThat(stepped, isLeft(is(AnError.FILTER)));
343 }
344
345 @Test public void test_5_step_filter_failure_2() {
346 Either<AnError, Long> stepped = Steps.begin(ok(STRING)).then(v -> ok(STRING)).filter(alwaysFalse2(), filterAnErrorFunction)
347 .then((first, second) -> ok(first + second)).then((v1, v2, v3) -> ok(STRING)).then((v1, v2, v3, v4) -> ok(STRING))
348 .yield((value1, value2, value3, value4, value5) -> new Long(value3));
349
350 assertThat(stepped, isLeft(is(AnError.FILTER)));
351 }
352
353 @Test public void test_5_step_filter_failure_3() {
354 Either<AnError, Long> stepped = Steps.begin(ok(STRING)).then(v -> ok(STRING)).then((first, second) -> ok(first + second))
355 .filter(alwaysFalse3(), filterAnErrorFunction).then((v1, v2, v3) -> ok(STRING)).then((v1, v2, v3, v4) -> ok(STRING))
356 .yield((value1, value2, value3, value4, value5) -> new Long(value3));
357
358 assertThat(stepped, isLeft(is(AnError.FILTER)));
359 }
360
361 @Test public void test_5_step_filter_failure_4() {
362 Either<AnError, Long> stepped = Steps.begin(ok(STRING)).then(v -> ok(STRING)).then((first, second) -> ok(first + second))
363 .then((v1, v2, v3) -> ok(STRING)).filter(alwaysFalse4(), filterAnErrorFunction).then((v1, v2, v3, v4) -> ok(STRING))
364 .yield((value1, value2, value3, value4, value5) -> new Long(value3));
365
366 assertThat(stepped, isLeft(is(AnError.FILTER)));
367 }
368
369 @Test public void test_6_step_success_functor() {
370 Either<AnError, Long> stepped = Steps.begin(ok(STRING)).then(v -> ok(STRING)).then((first, second) -> ok(first + second))
371 .then((v1, v2, v3) -> ok(STRING)).then((v1, v2, v3, v4) -> ok(STRING_UPPERED))
372 .then((first, second, third, fourth, fifth) -> ok(STRING_LOWERED)).yield((value1, value2, value3, value4, value5, value6) -> new Long(value3));
373
374 assertThat(stepped, isRight(is(LONGLONG)));
375 }
376
377 @Test public void test_6_step_success_supplier() {
378 Either<AnError, String> stepped = Steps.begin(ok(STRING)).then(() -> ok(STRING)).then(() -> ok(STRING + STRING)).then(() -> ok(STRING))
379 .then(() -> ok(STRING_UPPERED)).then(() -> ok(STRING_LOWERED)).yield((value1, value2, value3, value4, value5, value6) -> value6);
380
381 assertThat(stepped, isRight(is(STRING_LOWERED)));
382 }
383
384 @Test public void test_6_step_failure_functor() {
385 Either<AnError, Long> stepped = Steps.begin(ok(STRING)).then(v -> ok(STRING)).then((first, second) -> ok(first + second))
386 .then((v1, v2, v3) -> ok(STRING)).then((v1, v2, v3, v4) -> ok(STRING_UPPERED))
387 .then((first, second, third, fourth, fifth) -> error(AnError.SIXTH))
388 .yield((value1, value2, value3, value4, value5, value6) -> new Long(value3));
389
390 assertThat(stepped, isLeft(is(AnError.SIXTH)));
391 }
392
393 @Test public void test_6_step_failure_supplier() {
394 Either<AnError, String> stepped = Steps.begin(ok(STRING)).then(() -> ok(STRING)).then(() -> ok(STRING + STRING)).then(() -> ok(STRING))
395 .then(() -> ok(STRING_UPPERED)).then(() -> error(AnError.SIXTH)).yield((value1, value2, value3, value4, value5, value6) -> value5);
396
397 assertThat(stepped, isLeft(is(AnError.SIXTH)));
398 }
399
400 @Test public void test_6_step_failure_1() {
401 Either<AnError, String> stepped = Steps.begin(error(AnError.FIRST)).then(() -> ok(STRING)).then(() -> ok(STRING + STRING)).then(() -> ok(STRING))
402 .then(() -> ok(STRING_UPPERED)).then(() -> ok(STRING_LOWERED)).yield((value1, value2, value3, value4, value5, value6) -> value6);
403
404 assertThat(stepped, isLeft(is(AnError.FIRST)));
405 }
406
407 @Test public void test_6_step_failure_2() {
408 Either<AnError, String> stepped = Steps.begin(ok(LONG)).then(() -> error(AnError.SECOND)).then(() -> ok(STRING + STRING)).then(() -> ok(STRING))
409 .then(() -> ok(STRING_UPPERED)).then(() -> ok(STRING_LOWERED)).yield((value1, value2, value3, value4, value5, value6) -> value6);
410
411 assertThat(stepped, isLeft(is(AnError.SECOND)));
412 }
413
414 @Test public void test_6_step_failure_3() {
415 Either<AnError, String> stepped = Steps.begin(ok(LONG)).then(() -> ok(STRING)).then(() -> error(AnError.THIRD)).then(() -> ok(STRING))
416 .then(() -> ok(STRING_UPPERED)).then(() -> ok(STRING_LOWERED)).yield((value1, value2, value3, value4, value5, value6) -> value6);
417
418 assertThat(stepped, isLeft(is(AnError.THIRD)));
419 }
420
421 @Test public void test_6_step_failure_4() {
422 Either<AnError, String> stepped = Steps.begin(ok(LONG)).then(() -> ok(STRING)).then(() -> ok(STRING + STRING)).then(() -> error(AnError.FOURTH))
423 .then(() -> ok(STRING_UPPERED)).then(() -> ok(STRING_LOWERED)).yield((value1, value2, value3, value4, value5, value6) -> value6);
424
425 assertThat(stepped, isLeft(is(AnError.FOURTH)));
426 }
427
428 @Test public void test_6_step_failure_5() {
429 Either<AnError, String> stepped = Steps.begin(ok(LONG)).then(() -> ok(STRING)).then(() -> ok(STRING + STRING)).then(() -> ok(STRING))
430 .then(() -> error(AnError.FIFTH)).then(() -> ok(STRING_LOWERED)).yield((value1, value2, value3, value4, value5, value6) -> value6);
431
432 assertThat(stepped, isLeft(is(AnError.FIFTH)));
433 }
434
435 @Test public void test_6_step_filter_success() {
436 Either<AnError, String> stepped = Steps.begin(ok(STRING)).then(() -> ok(STRING)).then(() -> ok(STRING + STRING)).then(() -> ok(STRING))
437 .then(() -> ok(STRING_UPPERED)).then(() -> ok(STRING_LOWERED)).filter(alwaysTrue6(), filterAnErrorFunction)
438 .yield((value1, value2, value3, value4, value5, value6) -> value6);
439
440 assertThat(stepped, isRight(is(STRING_LOWERED)));
441 }
442
443 @Test public void test_6_step_filter_failure() {
444 Either<AnError, String> stepped = Steps.begin(ok(STRING)).then(() -> ok(STRING)).then(() -> ok(STRING + STRING)).then(() -> ok(STRING))
445 .then(() -> ok(STRING_UPPERED)).then(() -> ok(STRING_LOWERED)).filter(alwaysFalse6(), filterAnErrorFunction)
446 .yield((value1, value2, value3, value4, value5, value6) -> value6);
447
448 assertThat(stepped, isLeft(is(AnError.FILTER)));
449 }
450
451 @Test public void test_6_step_filter_failure_1() {
452 Either<AnError, String> stepped = Steps.begin(ok(STRING)).filter(alwaysFalse(), filterAnErrorFunction).then(() -> ok(STRING))
453 .then(() -> ok(STRING + STRING)).then(() -> ok(STRING)).then(() -> ok(STRING_UPPERED)).then(() -> ok(STRING_LOWERED))
454 .yield((value1, value2, value3, value4, value5, value6) -> value6);
455
456 assertThat(stepped, isLeft(is(AnError.FILTER)));
457 }
458
459 @Test public void test_6_step_filter_failure_2() {
460 Either<AnError, String> stepped = Steps.begin(ok(STRING)).then(() -> ok(STRING)).filter(alwaysFalse2(), filterAnErrorFunction)
461 .then(() -> ok(STRING + STRING)).then(() -> ok(STRING)).then(() -> ok(STRING_UPPERED)).then(() -> ok(STRING_LOWERED))
462 .yield((value1, value2, value3, value4, value5, value6) -> value6);
463
464 assertThat(stepped, isLeft(is(AnError.FILTER)));
465 }
466
467 @Test public void test_6_step_filter_failure_3() {
468 Either<AnError, String> stepped = Steps.begin(ok(STRING)).then(() -> ok(STRING)).then(() -> ok(STRING + STRING))
469 .filter(alwaysFalse3(), filterAnErrorFunction).then(() -> ok(STRING)).then(() -> ok(STRING_UPPERED)).then(() -> ok(STRING_LOWERED))
470 .yield((value1, value2, value3, value4, value5, value6) -> value6);
471
472 assertThat(stepped, isLeft(is(AnError.FILTER)));
473 }
474
475 @Test public void test_6_step_filter_failure_4() {
476 Either<AnError, String> stepped = Steps.begin(ok(STRING)).then(() -> ok(STRING)).then(() -> ok(STRING + STRING)).then(() -> ok(STRING))
477 .filter(alwaysFalse4(), filterAnErrorFunction).then(() -> ok(STRING_UPPERED)).then(() -> ok(STRING_LOWERED))
478 .yield((value1, value2, value3, value4, value5, value6) -> value6);
479
480 assertThat(stepped, isLeft(is(AnError.FILTER)));
481 }
482
483 @Test public void test_6_step_filter_failure_5() {
484 Either<AnError, String> stepped = Steps.begin(ok(STRING)).then(() -> ok(STRING)).then(() -> ok(STRING + STRING)).then(() -> ok(STRING))
485 .then(() -> ok(STRING_UPPERED)).filter(alwaysFalse5(), filterAnErrorFunction).then(() -> ok(STRING_LOWERED))
486 .yield((value1, value2, value3, value4, value5, value6) -> value6);
487
488 assertThat(stepped, isLeft(is(AnError.FILTER)));
489 }
490
491 private static <T> Either<AnError, T> error(AnError anError) {
492 return left(anError);
493 }
494
495 private static <T> Either<AnError, T> ok(T value) {
496 return right(value);
497 }
498
499 public enum AnError {
500
501 FIRST, SECOND, THIRD, FOURTH, FIFTH, SIXTH, FILTER
502
503 }
504
505 }