View Javadoc

1   package org.apache.maven.surefire.junitcore.pc;
2   
3   /*
4    * Licensed to the Apache Software Foundation (ASF) under one
5    * or more contributor license agreements.  See the NOTICE file
6    * distributed with this work for additional information
7    * regarding copyright ownership.  The ASF licenses this file
8    * to you under the Apache License, Version 2.0 (the
9    * "License"); you may not use this file except in compliance
10   * with the License.  You may obtain a copy of the License at
11   *
12   *     http://www.apache.org/licenses/LICENSE-2.0
13   *
14   * Unless required by applicable law or agreed to in writing,
15   * software distributed under the License is distributed on an
16   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
17   * KIND, either express or implied.  See the License for the
18   * specific language governing permissions and limitations
19   * under the License.
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   * Tests the factories in SchedulingStrategy.
32   *
33   * Th point of these tests is to check {@link Task#result} if changed
34   * from <code>false</code> to <code>true</code> after all scheduled tasks
35   * have finished.
36   * The call {@link SchedulingStrategy#finished()} is waiting until the
37   * strategy has finished.
38   * Then {@link Task#result} should be asserted that is <code>true</code>.
39   *
40   * @author Tibor Digana (tibor17)
41   * @since 2.16
42   *
43   * @see SchedulingStrategy
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 }