View Javadoc
1   package net.secodo.jcircuitbreaker.breakstrategy.impl;
2   
3   import net.secodo.jcircuitbreaker.breaker.execution.ExecutedTask;
4   import net.secodo.jcircuitbreaker.task.Task;
5   import net.secodo.jcircuitbreaker.util.TimeUtil;
6   import org.junit.Test;
7   import net.secodo.jcircuitbreaker.breaker.execution.ExecutionContext;
8   import java.lang.reflect.Field;
9   import java.util.ArrayList;
10  import java.util.Collection;
11  import java.util.Collections;
12  import java.util.stream.IntStream;
13  import static org.hamcrest.core.IsEqual.equalTo;
14  import static org.junit.Assert.assertThat;
15  import static org.mockito.Mockito.mock;
16  import static org.mockito.Mockito.reset;
17  import static org.mockito.Mockito.when;
18  
19  
20  @SuppressWarnings("unchecked")
21  public class LimitedCurrentAverageExecutionTimeStrategyTest {
22    @Test
23    public void shouldNotBreakWhenThereIsNoExecutionYet() throws Exception {
24      //given
25      final Task task = mock(Task.class);
26      final ExecutionContext executionContext = mock(ExecutionContext.class);
27      when(executionContext.getExecutionsInProgress()).thenReturn(Collections.EMPTY_LIST);
28  
29      final LimitedCurrentAverageExecutionTimeStrategy strategy = new LimitedCurrentAverageExecutionTimeStrategy(10000);
30  
31      // when
32      final boolean shouldBreak = strategy.shouldBreak(task, executionContext);
33  
34      // then
35      assertThat(shouldBreak, equalTo(false));
36  
37  
38    }
39  
40    @Test
41    public void shouldNotBreakWhenAverageExecutionTimeIsLessThenMaxTime_1() throws Exception {
42      // given
43      final long maxAllowedExecutionTimeMilis = 8;
44      final int percentageOfLongestTimesToSkip = 0; // all times will be taken into consideration
45  
46      final Collection<ExecutedTask> tasksInProgress = new ArrayList<>();
47  
48      final Task task = mock(Task.class);
49      final ExecutionContext executionContext = mock(ExecutionContext.class);
50      when(executionContext.getExecutionsInProgress()).thenReturn(tasksInProgress);
51  
52      final TimeUtil timeUtil = mock(TimeUtil.class);
53  
54  
55      IntStream.range(0, 10).forEach(i -> {
56        ExecutedTask executedTask = new ExecutedTask(mock(Task.class), i);
57        tasksInProgress.add(executedTask);
58      });
59  
60      final LimitedCurrentAverageExecutionTimeStrategy strategy = new LimitedCurrentAverageExecutionTimeStrategy(
61        maxAllowedExecutionTimeMilis,
62        percentageOfLongestTimesToSkip);
63  
64      final Field timeUtilField = LimitedCurrentAverageExecutionTimeStrategy.class.getDeclaredField("timeUtil");
65      timeUtilField.setAccessible(true);
66      timeUtilField.set(strategy, timeUtil);
67  
68      final long currentTimeForStrategy = 10;
69      when(timeUtil.getCurrentTimeMilis()).thenReturn(currentTimeForStrategy);
70  
71      // when
72      final boolean shouldBreakResult = strategy.shouldBreak(task, executionContext);
73  
74      // then
75      assertThat(shouldBreakResult, equalTo(false));
76  
77  
78    }
79  
80    @Test
81    public void shouldNotBreakWhenAverageExecutionTimeIsLessThenMaxTime_with10PercentOfTimesToSkip() throws Exception {
82      // given
83      final long maxAllowedExecutionTimeMilis = 8;
84      final int percentageOfLongestTimesToSkip = 10; // !!! now 10 percent of times should be skipped
85  
86      final Collection<ExecutedTask> tasksInProgress = new ArrayList<>();
87  
88      final Task task = mock(Task.class);
89      final ExecutionContext executionContext = mock(ExecutionContext.class);
90      when(executionContext.getExecutionsInProgress()).thenReturn(tasksInProgress);
91  
92      final TimeUtil timeUtil = mock(TimeUtil.class);
93  
94  
95      IntStream.range(0, 10).forEach(i -> {
96        ExecutedTask executedTask = new ExecutedTask(mock(Task.class), i);
97        tasksInProgress.add(executedTask);
98      });
99  
100     final LimitedCurrentAverageExecutionTimeStrategy strategy = new LimitedCurrentAverageExecutionTimeStrategy(
101       maxAllowedExecutionTimeMilis,
102       percentageOfLongestTimesToSkip);
103 
104     final Field timeUtilField = LimitedCurrentAverageExecutionTimeStrategy.class.getDeclaredField("timeUtil");
105     timeUtilField.setAccessible(true);
106     timeUtilField.set(strategy, timeUtil);
107 
108     final long currentTimeForStrategy = 10;
109     when(timeUtil.getCurrentTimeMilis()).thenReturn(currentTimeForStrategy);
110 
111     // when
112     final boolean shouldBreakResult = strategy.shouldBreak(task, executionContext);
113 
114     // then
115     assertThat(shouldBreakResult, equalTo(false));
116 
117 
118   }
119 
120   @Test
121   public void shouldNotBreakWhenAverageExecutionTimeIsLessThenMaxTime_with20PercentOfTimesToSkip() throws Exception {
122     // given
123     final long maxAllowedExecutionTimeMilis = 8;
124     final int percentageOfLongestTimesToSkip = 20; // !!! now 20 percent of times should be skipped
125 
126     final Collection<ExecutedTask> tasksInProgress = new ArrayList<>();
127 
128     final Task task = mock(Task.class);
129     final ExecutionContext executionContext = mock(ExecutionContext.class);
130     when(executionContext.getExecutionsInProgress()).thenReturn(tasksInProgress);
131 
132     final TimeUtil timeUtil = mock(TimeUtil.class);
133 
134 
135     IntStream.range(0, 10).forEach(i -> {
136       ExecutedTask executedTask = new ExecutedTask(mock(Task.class), i);
137       tasksInProgress.add(executedTask);
138     });
139 
140     final LimitedCurrentAverageExecutionTimeStrategy strategy = new LimitedCurrentAverageExecutionTimeStrategy(
141       maxAllowedExecutionTimeMilis,
142       percentageOfLongestTimesToSkip);
143 
144     final Field timeUtilField = LimitedCurrentAverageExecutionTimeStrategy.class.getDeclaredField("timeUtil");
145     timeUtilField.setAccessible(true);
146     timeUtilField.set(strategy, timeUtil);
147 
148     final long currentTimeForStrategy = 10;
149     when(timeUtil.getCurrentTimeMilis()).thenReturn(currentTimeForStrategy);
150 
151     // when
152     final boolean shouldBreakResult = strategy.shouldBreak(task, executionContext);
153 
154     // then
155     assertThat(shouldBreakResult, equalTo(false));
156 
157 
158   }
159 
160   @Test
161   public void shouldNotBreakWhenAverageExecutionTimeIsLessThenMaxTime_with30PercentOfTimesToSkip() throws Exception {
162     // given
163     final long maxAllowedExecutionTimeMilis = 8;
164     final int percentageOfLongestTimesToSkip = 30; // !!! now 30 percents of times should be skipped
165 
166     final Collection<ExecutedTask> tasksInProgress = new ArrayList<>();
167 
168     final Task task = mock(Task.class);
169     final ExecutionContext executionContext = mock(ExecutionContext.class);
170     when(executionContext.getExecutionsInProgress()).thenReturn(tasksInProgress);
171 
172     final TimeUtil timeUtil = mock(TimeUtil.class);
173 
174 
175     IntStream.range(0, 10).forEach(i -> {
176       ExecutedTask executedTask = new ExecutedTask(mock(Task.class), i);
177       tasksInProgress.add(executedTask);
178     });
179 
180     final LimitedCurrentAverageExecutionTimeStrategy strategy = new LimitedCurrentAverageExecutionTimeStrategy(
181       maxAllowedExecutionTimeMilis,
182       percentageOfLongestTimesToSkip);
183 
184     final Field timeUtilField = LimitedCurrentAverageExecutionTimeStrategy.class.getDeclaredField("timeUtil");
185     timeUtilField.setAccessible(true);
186     timeUtilField.set(strategy, timeUtil);
187 
188     final long currentTimeForStrategy = 10;
189     when(timeUtil.getCurrentTimeMilis()).thenReturn(currentTimeForStrategy);
190 
191     // when
192     final boolean shouldBreakResult = strategy.shouldBreak(task, executionContext);
193 
194     // then
195     assertThat(shouldBreakResult, equalTo(false));
196   }
197 
198   @Test
199   public void shouldNotBreakWhenAverageExecutionTimeIsLessThenMaxTime_with40PercentOfTimesToSkip() throws Exception {
200     // given
201     final long maxAllowedExecutionTimeMilis = 8;
202     final int percentageOfLongestTimesToSkip = 40; // !!! now 40 percents of times should be skipped
203 
204     final Collection<ExecutedTask> tasksInProgress = new ArrayList<>();
205 
206     final Task task = mock(Task.class);
207     final ExecutionContext executionContext = mock(ExecutionContext.class);
208     when(executionContext.getExecutionsInProgress()).thenReturn(tasksInProgress);
209 
210     final TimeUtil timeUtil = mock(TimeUtil.class);
211 
212 
213     IntStream.range(0, 10).forEach(i -> {
214       ExecutedTask executedTask = new ExecutedTask(mock(Task.class), i);
215       tasksInProgress.add(executedTask);
216     });
217 
218     final LimitedCurrentAverageExecutionTimeStrategy strategy = new LimitedCurrentAverageExecutionTimeStrategy(
219       maxAllowedExecutionTimeMilis,
220       percentageOfLongestTimesToSkip);
221 
222     final Field timeUtilField = LimitedCurrentAverageExecutionTimeStrategy.class.getDeclaredField("timeUtil");
223     timeUtilField.setAccessible(true);
224     timeUtilField.set(strategy, timeUtil);
225 
226     final long currentTimeForStrategy = 10;
227     when(timeUtil.getCurrentTimeMilis()).thenReturn(currentTimeForStrategy);
228 
229     // when
230     final boolean shouldBreakResult = strategy.shouldBreak(task, executionContext);
231 
232     // then
233     assertThat(shouldBreakResult, equalTo(false));
234   }
235 
236   @Test
237   public void shouldNotBreakWhenAverageExecutionTimeIsLessThenMaxTime_with50PercentOfTimesToSkip() throws Exception {
238     // given
239     final long maxAllowedExecutionTimeMilis = 8;
240     final int percentageOfLongestTimesToSkip = 50; // !!! now 50 percents of times should be skipped
241 
242     final Collection<ExecutedTask> tasksInProgress = new ArrayList<>();
243 
244     final Task task = mock(Task.class);
245     final ExecutionContext executionContext = mock(ExecutionContext.class);
246     when(executionContext.getExecutionsInProgress()).thenReturn(tasksInProgress);
247 
248     final TimeUtil timeUtil = mock(TimeUtil.class);
249 
250 
251     IntStream.range(0, 10).forEach(i -> {
252       ExecutedTask executedTask = new ExecutedTask(mock(Task.class), i);
253       tasksInProgress.add(executedTask);
254     });
255 
256     final LimitedCurrentAverageExecutionTimeStrategy strategy = new LimitedCurrentAverageExecutionTimeStrategy(
257       maxAllowedExecutionTimeMilis,
258       percentageOfLongestTimesToSkip);
259 
260     final Field timeUtilField = LimitedCurrentAverageExecutionTimeStrategy.class.getDeclaredField("timeUtil");
261     timeUtilField.setAccessible(true);
262     timeUtilField.set(strategy, timeUtil);
263 
264     final long currentTimeForStrategy = 10;
265     when(timeUtil.getCurrentTimeMilis()).thenReturn(currentTimeForStrategy);
266 
267     // when
268     final boolean shouldBreakResult = strategy.shouldBreak(task, executionContext); // THIS IS BOUNDARY VALUE - AVERAGE TIME == 8 (as maxAllowedExecutionTimeMilis)
269 
270     // then
271     assertThat(shouldBreakResult, equalTo(false));
272   }
273 
274   @Test
275   public void shouldNotBreakWhenAverageExecutionTimeIsLessThenMaxTime_with60PercentOfTimesToSkip() throws Exception {
276     // given
277     final long maxAllowedExecutionTimeMilis = 8;
278     final int percentageOfLongestTimesToSkip = 60; // !!! now 60 percents of times should be skipped
279 
280     final Collection<ExecutedTask> tasksInProgress = new ArrayList<>();
281 
282     final Task task = mock(Task.class);
283     final ExecutionContext executionContext = mock(ExecutionContext.class);
284     when(executionContext.getExecutionsInProgress()).thenReturn(tasksInProgress);
285 
286     final TimeUtil timeUtil = mock(TimeUtil.class);
287 
288 
289     IntStream.range(0, 10).forEach(i -> {
290       ExecutedTask executedTask = new ExecutedTask(mock(Task.class), i);
291       tasksInProgress.add(executedTask);
292     });
293 
294     final LimitedCurrentAverageExecutionTimeStrategy strategy = new LimitedCurrentAverageExecutionTimeStrategy(
295       maxAllowedExecutionTimeMilis,
296       percentageOfLongestTimesToSkip);
297 
298     final Field timeUtilField = LimitedCurrentAverageExecutionTimeStrategy.class.getDeclaredField("timeUtil");
299     timeUtilField.setAccessible(true);
300     timeUtilField.set(strategy, timeUtil);
301 
302     final long currentTimeForStrategy = 10;
303     when(timeUtil.getCurrentTimeMilis()).thenReturn(currentTimeForStrategy);
304 
305     // when
306     final boolean shouldBreakResult = strategy.shouldBreak(task, executionContext);
307 
308     // then
309     assertThat(shouldBreakResult, equalTo(true)); // now should break because 8.5 > maxAllowedExecutionTimeMilis (which is 8)
310   }
311 
312   @Test
313   public void shouldNotBreakWhenAverageExecutionTimeIsLessThenMaxTime_with70PercentOfTimesToSkip() throws Exception {
314     // given
315     final long maxAllowedExecutionTimeMilis = 8;
316     final int percentageOfLongestTimesToSkip = 70; // !!! now 70 percents of times should be skipped
317 
318     final Collection<ExecutedTask> tasksInProgress = new ArrayList<>();
319 
320     final Task task = mock(Task.class);
321     final ExecutionContext executionContext = mock(ExecutionContext.class);
322     when(executionContext.getExecutionsInProgress()).thenReturn(tasksInProgress);
323 
324     final TimeUtil timeUtil = mock(TimeUtil.class);
325 
326 
327     IntStream.range(0, 10).forEach(i -> {
328       ExecutedTask executedTask = new ExecutedTask(mock(Task.class), i);
329       tasksInProgress.add(executedTask);
330     });
331 
332     final LimitedCurrentAverageExecutionTimeStrategy strategy = new LimitedCurrentAverageExecutionTimeStrategy(
333       maxAllowedExecutionTimeMilis,
334       percentageOfLongestTimesToSkip);
335 
336     final Field timeUtilField = LimitedCurrentAverageExecutionTimeStrategy.class.getDeclaredField("timeUtil");
337     timeUtilField.setAccessible(true);
338     timeUtilField.set(strategy, timeUtil);
339 
340     final long currentTimeForStrategy = 10;
341     when(timeUtil.getCurrentTimeMilis()).thenReturn(currentTimeForStrategy);
342 
343     // when
344     final boolean shouldBreakResult = strategy.shouldBreak(task, executionContext);
345 
346     // then
347     assertThat(shouldBreakResult, equalTo(true));
348   }
349 
350   @Test
351   public void shouldNotBreakWhenAverageExecutionTimeIsLessThenMaxTime_with80PercentOfTimesToSkip() throws Exception {
352     // given
353     final long maxAllowedExecutionTimeMilis = 8;
354     final int percentageOfLongestTimesToSkip = 80; // !!! now 80 percents of times should be skipped
355 
356     final Collection<ExecutedTask> tasksInProgress = new ArrayList<>();
357 
358     final Task task = mock(Task.class);
359     final ExecutionContext executionContext = mock(ExecutionContext.class);
360     when(executionContext.getExecutionsInProgress()).thenReturn(tasksInProgress);
361 
362     final TimeUtil timeUtil = mock(TimeUtil.class);
363 
364 
365     IntStream.range(0, 10).forEach(i -> {
366       ExecutedTask executedTask = new ExecutedTask(mock(Task.class), i);
367       tasksInProgress.add(executedTask);
368     });
369 
370     final LimitedCurrentAverageExecutionTimeStrategy strategy = new LimitedCurrentAverageExecutionTimeStrategy(
371       maxAllowedExecutionTimeMilis,
372       percentageOfLongestTimesToSkip);
373 
374     final Field timeUtilField = LimitedCurrentAverageExecutionTimeStrategy.class.getDeclaredField("timeUtil");
375     timeUtilField.setAccessible(true);
376     timeUtilField.set(strategy, timeUtil);
377 
378     final long currentTimeForStrategy = 10;
379     when(timeUtil.getCurrentTimeMilis()).thenReturn(currentTimeForStrategy);
380 
381     // when
382     final boolean shouldBreakResult = strategy.shouldBreak(task, executionContext);
383 
384     // then
385     assertThat(shouldBreakResult, equalTo(true));
386   }
387 
388   @Test
389   public void shouldNotBreakWhenAverageExecutionTimeIsLessThenMaxTime_with90PercentOfTimesToSkip() throws Exception {
390     // given
391     final long maxAllowedExecutionTimeMilis = 8;
392     final int percentageOfLongestTimesToSkip = 90; // !!! now 90 percents of times should be skipped
393 
394     final Collection<ExecutedTask> tasksInProgress = new ArrayList<>();
395 
396     final Task task = mock(Task.class);
397     final ExecutionContext executionContext = mock(ExecutionContext.class);
398     when(executionContext.getExecutionsInProgress()).thenReturn(tasksInProgress);
399 
400     final TimeUtil timeUtil = mock(TimeUtil.class);
401 
402 
403     IntStream.range(0, 10).forEach(i -> {
404       ExecutedTask executedTask = new ExecutedTask(mock(Task.class), i);
405       tasksInProgress.add(executedTask);
406     });
407 
408     final LimitedCurrentAverageExecutionTimeStrategy strategy = new LimitedCurrentAverageExecutionTimeStrategy(
409       maxAllowedExecutionTimeMilis,
410       percentageOfLongestTimesToSkip);
411 
412     final Field timeUtilField = LimitedCurrentAverageExecutionTimeStrategy.class.getDeclaredField("timeUtil");
413     timeUtilField.setAccessible(true);
414     timeUtilField.set(strategy, timeUtil);
415 
416     final long currentTimeForStrategy = 10;
417     when(timeUtil.getCurrentTimeMilis()).thenReturn(currentTimeForStrategy);
418 
419     // when
420     final boolean shouldBreakResult = strategy.shouldBreak(task, executionContext);
421 
422     // then
423     assertThat(shouldBreakResult, equalTo(true));
424   }
425 
426   @Test
427   public void shouldNotBreakWhenAverageExecutionTimeIsLessThenMaxTime_with99PercentOfTimesToSkip() throws Exception {
428     // given
429     final long maxAllowedExecutionTimeMilis = 8;
430     final int percentageOfLongestTimesToSkip = 99; // !!! now 99 percents of times should be skipped
431 
432     final Collection<ExecutedTask> tasksInProgress = new ArrayList<>();
433 
434     final Task task = mock(Task.class);
435     final ExecutionContext executionContext = mock(ExecutionContext.class);
436     when(executionContext.getExecutionsInProgress()).thenReturn(tasksInProgress);
437 
438     final TimeUtil timeUtil = mock(TimeUtil.class);
439 
440 
441     IntStream.range(0, 10).forEach(i -> {
442       ExecutedTask executedTask = new ExecutedTask(mock(Task.class), i);
443       tasksInProgress.add(executedTask);
444     });
445 
446     final LimitedCurrentAverageExecutionTimeStrategy strategy = new LimitedCurrentAverageExecutionTimeStrategy(
447       maxAllowedExecutionTimeMilis,
448       percentageOfLongestTimesToSkip);
449 
450     final Field timeUtilField = LimitedCurrentAverageExecutionTimeStrategy.class.getDeclaredField("timeUtil");
451     timeUtilField.setAccessible(true);
452     timeUtilField.set(strategy, timeUtil);
453 
454     final long currentTimeForStrategy = 10;
455     when(timeUtil.getCurrentTimeMilis()).thenReturn(currentTimeForStrategy);
456 
457     // when
458     final boolean shouldBreakResult = strategy.shouldBreak(task, executionContext);
459 
460     // then
461     assertThat(shouldBreakResult, equalTo(false)); // false becasue there are no times to take into consideration
462   }
463 
464   @Test
465   public void shouldNotBreakWhenAverageExecutionTimeIsLessThenMaxTime_with100PercentOfTimesToSkip() throws Exception {
466     // given
467     final long maxAllowedExecutionTimeMilis = 8;
468     final int percentageOfLongestTimesToSkip = 100; // !!! now 100 percents of times should be skipped
469 
470     final Collection<ExecutedTask> tasksInProgress = new ArrayList<>();
471 
472     final Task task = mock(Task.class);
473     final ExecutionContext executionContext = mock(ExecutionContext.class);
474     when(executionContext.getExecutionsInProgress()).thenReturn(tasksInProgress);
475 
476     final TimeUtil timeUtil = mock(TimeUtil.class);
477 
478 
479     IntStream.range(0, 10).forEach(i -> {
480       ExecutedTask executedTask = new ExecutedTask(mock(Task.class), i);
481       tasksInProgress.add(executedTask);
482     });
483 
484     final LimitedCurrentAverageExecutionTimeStrategy strategy = new LimitedCurrentAverageExecutionTimeStrategy(
485       maxAllowedExecutionTimeMilis,
486       percentageOfLongestTimesToSkip);
487 
488     final Field timeUtilField = LimitedCurrentAverageExecutionTimeStrategy.class.getDeclaredField("timeUtil");
489     timeUtilField.setAccessible(true);
490     timeUtilField.set(strategy, timeUtil);
491 
492     final long currentTimeForStrategy = 10;
493     when(timeUtil.getCurrentTimeMilis()).thenReturn(currentTimeForStrategy);
494 
495     // when
496     final boolean shouldBreakResult = strategy.shouldBreak(task, executionContext);
497 
498     // then
499     assertThat(shouldBreakResult, equalTo(false)); // false becasue there are no times to take into consideration
500   }
501 
502   @Test
503   public void shouldNotBreakWhenAverageExecutionTimeIsLessThenMaxTime_with105PercentOfTimesToSkip() throws Exception {
504     // given
505     final long maxAllowedExecutionTimeMilis = 8;
506     final int percentageOfLongestTimesToSkip = 105; // !!! now 105 percents of times should be skipped - this is transformed to 0%
507 
508     final Collection<ExecutedTask> tasksInProgress = new ArrayList<>();
509 
510     final Task task = mock(Task.class);
511     final ExecutionContext executionContext = mock(ExecutionContext.class);
512     when(executionContext.getExecutionsInProgress()).thenReturn(tasksInProgress);
513 
514     final TimeUtil timeUtil = mock(TimeUtil.class);
515 
516 
517     IntStream.range(0, 10).forEach(i -> {
518       ExecutedTask executedTask = new ExecutedTask(mock(Task.class), i);
519       tasksInProgress.add(executedTask);
520     });
521 
522     final LimitedCurrentAverageExecutionTimeStrategy strategy = new LimitedCurrentAverageExecutionTimeStrategy(
523       maxAllowedExecutionTimeMilis,
524       percentageOfLongestTimesToSkip);
525 
526     final Field timeUtilField = LimitedCurrentAverageExecutionTimeStrategy.class.getDeclaredField("timeUtil");
527     timeUtilField.setAccessible(true);
528     timeUtilField.set(strategy, timeUtil);
529 
530     final long currentTimeForStrategy = 10;
531     when(timeUtil.getCurrentTimeMilis()).thenReturn(currentTimeForStrategy);
532 
533     // when
534     final boolean shouldBreakResult = strategy.shouldBreak(task, executionContext);
535 
536     // then
537     assertThat(shouldBreakResult, equalTo(false)); // false because there all times were taken into consideration - because 105% transforms to 0%
538   }
539 
540   @Test
541   public void shouldNotBreakWhenAverageExecutionTimeIsLessThenMaxTime_withMinus1PercentOfTimesToSkip()
542                                                                                               throws Exception {
543     // given
544     final long maxAllowedExecutionTimeMilis = 8;
545     final int percentageOfLongestTimesToSkip = -1; // !!! now -1 percentsof times should be skipped - this is transformed to 0%
546 
547     final Collection<ExecutedTask> tasksInProgress = new ArrayList<>();
548 
549     final Task task = mock(Task.class);
550     final ExecutionContext executionContext = mock(ExecutionContext.class);
551     when(executionContext.getExecutionsInProgress()).thenReturn(tasksInProgress);
552 
553     final TimeUtil timeUtil = mock(TimeUtil.class);
554 
555 
556     IntStream.range(0, 10).forEach(i -> {
557       ExecutedTask executedTask = new ExecutedTask(mock(Task.class), i);
558       tasksInProgress.add(executedTask);
559     });
560 
561     final LimitedCurrentAverageExecutionTimeStrategy strategy = new LimitedCurrentAverageExecutionTimeStrategy(
562       maxAllowedExecutionTimeMilis,
563       percentageOfLongestTimesToSkip);
564 
565     final Field timeUtilField = LimitedCurrentAverageExecutionTimeStrategy.class.getDeclaredField("timeUtil");
566     timeUtilField.setAccessible(true);
567     timeUtilField.set(strategy, timeUtil);
568 
569     final long currentTimeForStrategy = 10;
570     when(timeUtil.getCurrentTimeMilis()).thenReturn(currentTimeForStrategy);
571 
572     // when
573     final boolean shouldBreakResult = strategy.shouldBreak(task, executionContext);
574 
575     // then
576     assertThat(shouldBreakResult, equalTo(false)); // false because there all times were taken into consideration - because 105% transforms to 0%
577   }
578 }