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