1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 package org.apache.maven.surefire.junitcore.pc;
20
21 import java.util.concurrent.ExecutorService;
22 import java.util.concurrent.Executors;
23 import java.util.concurrent.ThreadFactory;
24
25 import org.apache.maven.plugin.surefire.log.api.ConsoleLogger;
26 import org.junit.Test;
27
28 import static org.apache.maven.surefire.api.util.internal.DaemonThreadFactory.newDaemonThreadFactory;
29 import static org.junit.Assert.assertFalse;
30 import static org.junit.Assert.assertTrue;
31 import static org.mockito.Mockito.mock;
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47 public class SchedulingStrategiesTest {
48 private static final ThreadFactory DAEMON_THREAD_FACTORY = newDaemonThreadFactory();
49 private final ConsoleLogger logger = mock(ConsoleLogger.class);
50
51 @Test
52 public void invokerStrategy() throws InterruptedException {
53 SchedulingStrategy strategy = SchedulingStrategies.createInvokerStrategy(logger);
54 assertFalse(strategy.hasSharedThreadPool());
55 assertTrue(strategy.canSchedule());
56
57 Task task = new Task();
58
59 strategy.schedule(task);
60
61 assertTrue(strategy.canSchedule());
62
63 assertTrue(task.result);
64
65 assertTrue(strategy.finished());
66 assertFalse(strategy.canSchedule());
67 }
68
69 @Test
70 public void nonSharedPoolStrategy() throws InterruptedException {
71 SchedulingStrategy strategy = SchedulingStrategies.createParallelStrategy(logger, 2);
72 assertFalse(strategy.hasSharedThreadPool());
73 assertTrue(strategy.canSchedule());
74
75 Task task1 = new Task();
76 Task task2 = new Task();
77
78 strategy.schedule(task1);
79 strategy.schedule(task2);
80
81 assertTrue(strategy.canSchedule());
82
83 assertTrue(strategy.finished());
84 assertFalse(strategy.canSchedule());
85
86 assertTrue(task1.result);
87 assertTrue(task2.result);
88 }
89
90 @Test(expected = NullPointerException.class)
91 public void sharedPoolStrategyNullPool() {
92 SchedulingStrategies.createParallelSharedStrategy(logger, null);
93 }
94
95 @Test
96 public void sharedPoolStrategy() throws InterruptedException {
97 ExecutorService sharedPool = Executors.newCachedThreadPool(DAEMON_THREAD_FACTORY);
98
99 SchedulingStrategy strategy1 = SchedulingStrategies.createParallelSharedStrategy(logger, sharedPool);
100 assertTrue(strategy1.hasSharedThreadPool());
101 assertTrue(strategy1.canSchedule());
102
103 SchedulingStrategy strategy2 = SchedulingStrategies.createParallelSharedStrategy(logger, sharedPool);
104 assertTrue(strategy2.hasSharedThreadPool());
105 assertTrue(strategy2.canSchedule());
106
107 Task task1 = new Task();
108 Task task2 = new Task();
109 Task task3 = new Task();
110 Task task4 = new Task();
111
112 strategy1.schedule(task1);
113 strategy2.schedule(task2);
114 strategy1.schedule(task3);
115 strategy2.schedule(task4);
116
117 assertTrue(strategy1.canSchedule());
118 assertTrue(strategy2.canSchedule());
119
120 assertTrue(strategy1.finished());
121 assertFalse(strategy1.canSchedule());
122
123 assertTrue(strategy2.finished());
124 assertFalse(strategy2.canSchedule());
125
126 assertTrue(task1.result);
127 assertTrue(task2.result);
128 assertTrue(task3.result);
129 assertTrue(task4.result);
130 }
131
132 @Test
133 public void infinitePoolStrategy() throws InterruptedException {
134 SchedulingStrategy strategy = SchedulingStrategies.createParallelStrategyUnbounded(logger);
135 assertFalse(strategy.hasSharedThreadPool());
136 assertTrue(strategy.canSchedule());
137
138 Task task1 = new Task();
139 Task task2 = new Task();
140
141 strategy.schedule(task1);
142 strategy.schedule(task2);
143
144 assertTrue(strategy.canSchedule());
145
146 assertTrue(strategy.finished());
147 assertFalse(strategy.canSchedule());
148
149 assertTrue(task1.result);
150 assertTrue(task2.result);
151 }
152
153 static class Task implements Runnable {
154 volatile boolean result = false;
155
156 @Override
157 public void run() {
158 result = true;
159 }
160 }
161 }