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