View Javadoc

1   package org.apache.maven.surefire.junitcore;
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.apache.maven.surefire.testset.TestSetFailedException;
23  import org.junit.AfterClass;
24  import org.junit.BeforeClass;
25  import org.junit.Rule;
26  import org.junit.Test;
27  import org.junit.experimental.theories.DataPoint;
28  import org.junit.experimental.theories.Theories;
29  import org.junit.experimental.theories.Theory;
30  import org.junit.rules.ExpectedException;
31  import org.junit.runner.RunWith;
32  
33  import java.util.Properties;
34  
35  import static org.apache.maven.surefire.junitcore.ParallelComputerFactory.*;
36  import static org.apache.maven.surefire.junitcore.JUnitCoreParameters.*;
37  import static org.hamcrest.core.Is.is;
38  import static org.junit.Assert.*;
39  
40  /**
41   * Testing an algorithm in {@link ParallelComputerFactory} which configures
42   * allocated thread resources in ParallelComputer by given {@link JUnitCoreParameters}.
43   *
44   * @author Tibor Digana (tibor17)
45   * @since 2.16
46   *
47   * @see org.apache.maven.surefire.junitcore.ParallelComputerFactory
48   */
49  @RunWith(Theories.class)
50  public final class ParallelComputerFactoryTest
51  {
52      @Rule
53      public final ExpectedException exception = ExpectedException.none();
54  
55      @DataPoint
56      public static final int CPU_1 = 1;
57  
58      @DataPoint
59      public static final int CPU_4 = 4;
60  
61      @BeforeClass
62      public static void beforeClass()
63      {
64          ParallelComputerFactory.overrideAvailableProcessors( 1 );
65      }
66  
67      @AfterClass
68      public static void afterClass()
69      {
70          ParallelComputerFactory.setDefaultAvailableProcessors();
71      }
72  
73      @Test
74      public void unknownParallel() throws TestSetFailedException
75      {
76          Properties properties = new Properties();
77          exception.expect( TestSetFailedException.class  );
78          resolveConcurrency( new JUnitCoreParameters( properties ) );
79      }
80  
81      @Test
82      public void unknownThreadCountSuites() throws TestSetFailedException
83      {
84          JUnitCoreParameters params = new JUnitCoreParameters( parallel( "suites" ) );
85          assertTrue( params.isParallelSuites() );
86          assertFalse( params.isParallelClasses() );
87          assertFalse( params.isParallelMethod() );
88          exception.expect( TestSetFailedException.class );
89          resolveConcurrency( params );
90      }
91  
92      @Test
93      public void unknownThreadCountClasses() throws TestSetFailedException
94      {
95          JUnitCoreParameters params = new JUnitCoreParameters( parallel( "classes" ) );
96          assertFalse( params.isParallelSuites() );
97          assertTrue( params.isParallelClasses() );
98          assertFalse( params.isParallelMethod() );
99          exception.expect( TestSetFailedException.class );
100         resolveConcurrency( params );
101     }
102 
103     @Test
104     public void unknownThreadCountMethods() throws TestSetFailedException
105     {
106         JUnitCoreParameters params = new JUnitCoreParameters( parallel( "methods" ) );
107         assertFalse( params.isParallelSuites() );
108         assertFalse( params.isParallelClasses() );
109         assertTrue( params.isParallelMethod() );
110         exception.expect( TestSetFailedException.class );
111         resolveConcurrency( params );
112     }
113 
114     @Test
115     public void unknownThreadCountBoth() throws TestSetFailedException
116     {
117         JUnitCoreParameters params = new JUnitCoreParameters( parallel( "both" ) );
118         assertFalse( params.isParallelSuites() );
119         assertTrue( params.isParallelClasses() );
120         assertTrue( params.isParallelMethod() );
121         exception.expect( TestSetFailedException.class );
122         resolveConcurrency( params );
123     }
124 
125     @Test
126     public void unknownThreadCountAll() throws TestSetFailedException
127     {
128         JUnitCoreParameters params = new JUnitCoreParameters( parallel( "all" ) );
129         assertTrue( params.isParallelSuites() );
130         assertTrue( params.isParallelClasses() );
131         assertTrue( params.isParallelMethod() );
132         exception.expect( TestSetFailedException.class );
133         resolveConcurrency( params );
134     }
135 
136     @Test
137     public void unknownThreadCountSuitesAndClasses() throws TestSetFailedException
138     {
139         JUnitCoreParameters params = new JUnitCoreParameters( parallel( "suitesAndClasses" ) );
140         assertTrue( params.isParallelSuites() );
141         assertTrue( params.isParallelClasses() );
142         assertFalse( params.isParallelMethod() );
143         exception.expect( TestSetFailedException.class );
144         resolveConcurrency( params );
145     }
146 
147     @Test
148     public void unknownThreadCountSuitesAndMethods() throws TestSetFailedException
149     {
150         JUnitCoreParameters params = new JUnitCoreParameters( parallel( "suitesAndMethods" ) );
151         assertTrue( params.isParallelSuites() );
152         assertFalse( params.isParallelClasses() );
153         assertTrue( params.isParallelMethod() );
154         exception.expect( TestSetFailedException.class );
155         resolveConcurrency( params );
156     }
157 
158     @Test
159     public void unknownThreadCountClassesAndMethods() throws TestSetFailedException
160     {
161         JUnitCoreParameters params = new JUnitCoreParameters( parallel( "classesAndMethods" ) );
162         assertFalse( params.isParallelSuites() );
163         assertTrue( params.isParallelClasses() );
164         assertTrue( params.isParallelMethod() );
165         exception.expect( TestSetFailedException.class );
166         resolveConcurrency( params );
167     }
168 
169     @Theory
170     public void useUnlimitedThreadsSuites( int cpu ) throws TestSetFailedException
171     {
172         ParallelComputerFactory.overrideAvailableProcessors( cpu );
173         Properties properties = new Properties();
174         properties.setProperty( PARALLEL_KEY, "suites" );
175         properties.setProperty( USEUNLIMITEDTHREADS_KEY, "true" );
176         JUnitCoreParameters params = new JUnitCoreParameters( properties );
177         Concurrency concurrency = resolveConcurrency( params );
178         assertTrue( params.isParallelSuites() );
179         assertFalse( params.isParallelClasses() );
180         assertFalse( params.isParallelMethod() );
181         assertThat( concurrency.capacity, is( Integer.MAX_VALUE ) );
182         assertThat( concurrency.suites, is( Integer.MAX_VALUE ) );
183         assertThat( concurrency.classes, is( 0 ) );
184         assertThat( concurrency.methods, is( 0 ) );
185 
186         properties.setProperty( THREADCOUNTSUITES_KEY, "5" );
187         params = new JUnitCoreParameters( properties );
188         concurrency = resolveConcurrency( params );
189         assertTrue( params.isParallelSuites() );
190         assertFalse( params.isParallelClasses() );
191         assertFalse( params.isParallelMethod() );
192         assertThat( concurrency.capacity, is( Integer.MAX_VALUE ) );
193         assertThat( concurrency.suites, is( 5 * cpu ) );
194         assertThat( concurrency.classes, is( 0 ) );
195         assertThat( concurrency.methods, is( 0 ) );
196     }
197 
198     @Theory
199     public void useUnlimitedThreadsClasses( int cpu ) throws TestSetFailedException
200     {
201         ParallelComputerFactory.overrideAvailableProcessors( cpu );
202         Properties properties = new Properties();
203         properties.setProperty( PARALLEL_KEY, "classes" );
204         properties.setProperty( USEUNLIMITEDTHREADS_KEY, "true" );
205         JUnitCoreParameters params = new JUnitCoreParameters( properties );
206         Concurrency concurrency = resolveConcurrency( params );
207         assertFalse( params.isParallelSuites() );
208         assertTrue( params.isParallelClasses() );
209         assertFalse( params.isParallelMethod() );
210         assertThat( concurrency.capacity, is( Integer.MAX_VALUE ) );
211         assertThat( concurrency.suites, is( 0 ) );
212         assertThat( concurrency.classes, is( Integer.MAX_VALUE ) );
213         assertThat( concurrency.methods, is( 0 ) );
214 
215         properties.setProperty( THREADCOUNTCLASSES_KEY, "5" );
216         params = new JUnitCoreParameters( properties );
217         concurrency = resolveConcurrency( params );
218         assertFalse( params.isParallelSuites() );
219         assertTrue( params.isParallelClasses() );
220         assertFalse( params.isParallelMethod() );
221         assertThat( concurrency.capacity, is( Integer.MAX_VALUE ) );
222         assertThat( concurrency.suites, is( 0 ) );
223         assertThat( concurrency.classes, is( 5 * cpu ) );
224         assertThat( concurrency.methods, is( 0 ) );
225     }
226 
227     @Theory
228     public void unlimitedThreadsMethods( int cpu ) throws TestSetFailedException
229     {
230         ParallelComputerFactory.overrideAvailableProcessors( cpu );
231         Properties properties = new Properties();
232         properties.setProperty( PARALLEL_KEY, "methods" );
233         properties.setProperty( USEUNLIMITEDTHREADS_KEY, "true" );
234         JUnitCoreParameters params = new JUnitCoreParameters( properties );
235         Concurrency concurrency = resolveConcurrency( params );
236         assertFalse( params.isParallelSuites() );
237         assertFalse( params.isParallelClasses() );
238         assertTrue( params.isParallelMethod() );
239         assertThat( concurrency.capacity, is( Integer.MAX_VALUE ) );
240         assertThat( concurrency.suites, is( 0 ) );
241         assertThat( concurrency.classes, is( 0 ) );
242         assertThat( concurrency.methods, is( Integer.MAX_VALUE ) );
243 
244         properties.setProperty( THREADCOUNTMETHODS_KEY, "5" );
245         params = new JUnitCoreParameters( properties );
246         concurrency = resolveConcurrency( params );
247         assertFalse( params.isParallelSuites() );
248         assertFalse( params.isParallelClasses() );
249         assertTrue( params.isParallelMethod() );
250         assertThat( concurrency.capacity, is( Integer.MAX_VALUE ) );
251         assertThat( concurrency.suites, is( 0 ) );
252         assertThat( concurrency.classes, is( 0 ) );
253         assertThat( concurrency.methods, is( 5 * cpu ) );
254     }
255 
256     @Theory
257     public void unlimitedThreadsSuitesAndClasses( int cpu ) throws TestSetFailedException
258     {
259         ParallelComputerFactory.overrideAvailableProcessors( cpu );
260         Properties properties = new Properties();
261         properties.setProperty( PARALLEL_KEY, "suitesAndClasses" );
262         properties.setProperty( USEUNLIMITEDTHREADS_KEY, "true" );
263         JUnitCoreParameters params = new JUnitCoreParameters( properties );
264         Concurrency concurrency = resolveConcurrency( params );
265         assertTrue( params.isParallelSuites() );
266         assertTrue( params.isParallelClasses() );
267         assertFalse( params.isParallelMethod() );
268         assertThat( concurrency.capacity, is( Integer.MAX_VALUE ) );
269         assertThat( concurrency.suites, is( Integer.MAX_VALUE ) );
270         assertThat( concurrency.classes, is( Integer.MAX_VALUE ) );
271         assertThat( concurrency.methods, is( 0 ) );
272 
273         properties.setProperty( THREADCOUNTSUITES_KEY, "5" );
274         properties.setProperty( THREADCOUNTCLASSES_KEY, "15" );
275         params = new JUnitCoreParameters( properties );
276         concurrency = resolveConcurrency( params );
277         assertTrue( params.isParallelSuites() );
278         assertTrue( params.isParallelClasses() );
279         assertFalse( params.isParallelMethod() );
280         assertThat( concurrency.capacity, is( Integer.MAX_VALUE ) );
281         assertThat( concurrency.suites, is( 5 * cpu ) );
282         assertThat( concurrency.classes, is( 15 * cpu ) );
283         assertThat( concurrency.methods, is( 0 ) );
284     }
285 
286     @Theory
287     public void unlimitedThreadsSuitesAndMethods( int cpu ) throws TestSetFailedException
288     {
289         ParallelComputerFactory.overrideAvailableProcessors( cpu );
290         Properties properties = new Properties();
291         properties.setProperty( PARALLEL_KEY, "suitesAndMethods" );
292         properties.setProperty( USEUNLIMITEDTHREADS_KEY, "true" );
293         JUnitCoreParameters params = new JUnitCoreParameters( properties );
294         Concurrency concurrency = resolveConcurrency( params );
295         assertTrue( params.isParallelSuites() );
296         assertFalse( params.isParallelClasses() );
297         assertTrue( params.isParallelMethod() );
298         assertThat( concurrency.capacity, is( Integer.MAX_VALUE ) );
299         assertThat( concurrency.suites, is( Integer.MAX_VALUE ) );
300         assertThat( concurrency.classes, is( 0 ) );
301         assertThat( concurrency.methods, is( Integer.MAX_VALUE ) );
302 
303         properties.setProperty( THREADCOUNTSUITES_KEY, "5" );
304         properties.setProperty( THREADCOUNTMETHODS_KEY, "15" );
305         params = new JUnitCoreParameters( properties );
306         concurrency = resolveConcurrency( params );
307         assertTrue( params.isParallelSuites() );
308         assertFalse( params.isParallelClasses() );
309         assertTrue( params.isParallelMethod() );
310         assertThat( concurrency.capacity, is( Integer.MAX_VALUE ) );
311         assertThat( concurrency.suites, is( 5 * cpu ) );
312         assertThat( concurrency.classes, is( 0 ) );
313         assertThat( concurrency.methods, is( 15 * cpu ) );
314     }
315 
316     @Theory
317     public void unlimitedThreadsClassesAndMethods( int cpu ) throws TestSetFailedException
318     {
319         ParallelComputerFactory.overrideAvailableProcessors( cpu );
320         Properties properties = new Properties();
321         properties.setProperty( PARALLEL_KEY, "classesAndMethods" );
322         properties.setProperty( USEUNLIMITEDTHREADS_KEY, "true" );
323         JUnitCoreParameters params = new JUnitCoreParameters( properties );
324         Concurrency concurrency = resolveConcurrency( params );
325         assertFalse( params.isParallelSuites() );
326         assertTrue( params.isParallelClasses() );
327         assertTrue( params.isParallelMethod() );
328         assertThat( concurrency.capacity, is( Integer.MAX_VALUE ) );
329         assertThat( concurrency.suites, is( 0 ) );
330         assertThat( concurrency.classes, is( Integer.MAX_VALUE ) );
331         assertThat( concurrency.methods, is( Integer.MAX_VALUE ) );
332 
333         properties.setProperty( THREADCOUNTCLASSES_KEY, "5" );
334         properties.setProperty( THREADCOUNTMETHODS_KEY, "15" );
335         params = new JUnitCoreParameters( properties );
336         concurrency = resolveConcurrency( params );
337         assertFalse( params.isParallelSuites() );
338         assertTrue( params.isParallelClasses() );
339         assertTrue( params.isParallelMethod() );
340         assertThat( concurrency.capacity, is( Integer.MAX_VALUE ) );
341         assertThat( concurrency.suites, is( 0 ) );
342         assertThat( concurrency.classes, is( 5 * cpu ) );
343         assertThat( concurrency.methods, is( 15 * cpu ) );
344     }
345 
346     @Theory
347     public void unlimitedThreadsAll( int cpu ) throws TestSetFailedException
348     {
349         ParallelComputerFactory.overrideAvailableProcessors( cpu );
350         Properties properties = new Properties();
351         properties.setProperty( PARALLEL_KEY, "all" );
352         properties.setProperty( USEUNLIMITEDTHREADS_KEY, "true" );
353         JUnitCoreParameters params = new JUnitCoreParameters( properties );
354         Concurrency concurrency = resolveConcurrency( params );
355         assertTrue( params.isParallelSuites() );
356         assertTrue( params.isParallelClasses() );
357         assertTrue( params.isParallelMethod() );
358         assertThat( concurrency.capacity, is( Integer.MAX_VALUE ) );
359         assertThat( concurrency.suites, is( Integer.MAX_VALUE ) );
360         assertThat( concurrency.classes, is( Integer.MAX_VALUE ) );
361         assertThat( concurrency.methods, is( Integer.MAX_VALUE ) );
362 
363         properties.setProperty( THREADCOUNTSUITES_KEY, "5" );
364         properties.setProperty( THREADCOUNTCLASSES_KEY, "15" );
365         properties.setProperty( THREADCOUNTMETHODS_KEY, "30" );
366         params = new JUnitCoreParameters( properties );
367         concurrency = resolveConcurrency( params );
368         assertTrue( params.isParallelSuites() );
369         assertTrue( params.isParallelClasses() );
370         assertTrue( params.isParallelMethod() );
371         assertThat( concurrency.capacity, is( Integer.MAX_VALUE ) );
372         assertThat( concurrency.suites, is( 5 * cpu ) );
373         assertThat( concurrency.classes, is( 15 * cpu ) );
374         assertThat( concurrency.methods, is( 30 * cpu ) );
375     }
376 
377     @Theory
378     public void threadCountSuites( int cpu ) throws TestSetFailedException
379     {
380         ParallelComputerFactory.overrideAvailableProcessors( cpu );
381         Properties properties = new Properties();
382         properties.setProperty( PARALLEL_KEY, "suites" );
383         properties.setProperty( THREADCOUNT_KEY, "3" );
384         JUnitCoreParameters params = new JUnitCoreParameters( properties );
385         Concurrency concurrency = resolveConcurrency( params );
386         assertTrue( params.isParallelSuites() );
387         assertFalse( params.isParallelClasses() );
388         assertFalse( params.isParallelMethod() );
389         assertThat( concurrency.capacity, is( 0 ) );
390         assertThat( concurrency.suites, is( 3 * cpu ) );
391         assertThat( concurrency.classes, is( 0 ) );
392         assertThat( concurrency.methods, is( 0 ) );
393     }
394 
395     @Theory
396     public void threadCountClasses( int cpu ) throws TestSetFailedException
397     {
398         ParallelComputerFactory.overrideAvailableProcessors( cpu );
399         Properties properties = new Properties();
400         properties.setProperty( PARALLEL_KEY, "classes" );
401         properties.setProperty( THREADCOUNT_KEY, "3" );
402         JUnitCoreParameters params = new JUnitCoreParameters( properties );
403         Concurrency concurrency = resolveConcurrency( params );
404         assertFalse( params.isParallelSuites() );
405         assertTrue( params.isParallelClasses() );
406         assertFalse( params.isParallelMethod() );
407         assertThat( concurrency.capacity, is( 0 ) );
408         assertThat( concurrency.suites, is( 0 ) );
409         assertThat( concurrency.classes, is( 3 * cpu ) );
410         assertThat( concurrency.methods, is( 0 ) );
411     }
412 
413     @Theory
414     public void threadCountMethods( int cpu ) throws TestSetFailedException
415     {
416         ParallelComputerFactory.overrideAvailableProcessors( cpu );
417         Properties properties = new Properties();
418         properties.setProperty( PARALLEL_KEY, "methods" );
419         properties.setProperty( THREADCOUNT_KEY, "3" );
420         JUnitCoreParameters params = new JUnitCoreParameters( properties );
421         Concurrency concurrency = resolveConcurrency( params );
422         assertFalse( params.isParallelSuites() );
423         assertFalse( params.isParallelClasses() );
424         assertTrue( params.isParallelMethod() );
425         assertThat( concurrency.capacity, is( 0 ) );
426         assertThat( concurrency.suites, is( 0 ) );
427         assertThat( concurrency.classes, is( 0 ) );
428         assertThat( concurrency.methods, is( 3 * cpu ) );
429     }
430 
431     @Theory
432     public void threadCountBoth( int cpu ) throws TestSetFailedException
433     {
434         ParallelComputerFactory.overrideAvailableProcessors( cpu );
435         Properties properties = new Properties();
436         properties.setProperty( PARALLEL_KEY, "both" );
437         properties.setProperty( THREADCOUNT_KEY, "3" );
438         JUnitCoreParameters params = new JUnitCoreParameters( properties );
439         Concurrency concurrency = resolveConcurrency( params );
440         assertFalse( params.isParallelSuites() );
441         assertTrue( params.isParallelClasses() );
442         assertTrue( params.isParallelMethod() );
443         assertThat( concurrency.capacity, is( 3 * cpu ) );
444         assertThat( concurrency.suites, is( 0 ) );
445         assertThat( concurrency.classes, is( (int) ( ( 3d / 2 ) * cpu ) ) );
446         assertThat( concurrency.methods, is( Integer.MAX_VALUE ) );
447     }
448 
449     @Theory
450     public void threadCountClassesAndMethods( int cpu ) throws TestSetFailedException
451     {
452         ParallelComputerFactory.overrideAvailableProcessors( cpu );
453         Properties properties = new Properties();
454         properties.setProperty( PARALLEL_KEY, "classesAndMethods" );
455         properties.setProperty( THREADCOUNT_KEY, "3" );
456         JUnitCoreParameters params = new JUnitCoreParameters( properties );
457         Concurrency concurrency = resolveConcurrency( params );
458         assertFalse( params.isParallelSuites() );
459         assertTrue( params.isParallelClasses() );
460         assertTrue( params.isParallelMethod() );
461         assertThat( concurrency.capacity, is( 3 * cpu ) );
462         assertThat( concurrency.suites, is( 0 ) );
463         assertThat( concurrency.classes, is( (int) ( ( 3d / 2 ) * cpu ) ) );
464         assertThat( concurrency.methods, is( Integer.MAX_VALUE ) );
465     }
466 
467     @Theory
468     public void threadCountSuitesAndMethods( int cpu ) throws TestSetFailedException
469     {
470         ParallelComputerFactory.overrideAvailableProcessors( cpu );
471         Properties properties = new Properties();
472         properties.setProperty( PARALLEL_KEY, "suitesAndMethods" );
473         properties.setProperty( THREADCOUNT_KEY, "3" );
474         JUnitCoreParameters params = new JUnitCoreParameters( properties );
475         Concurrency concurrency = resolveConcurrency( params );
476         assertTrue( params.isParallelSuites() );
477         assertFalse( params.isParallelClasses() );
478         assertTrue( params.isParallelMethod() );
479         assertThat( concurrency.capacity, is( 3 * cpu ) );
480         assertThat( concurrency.suites, is( (int) ( ( 3d / 2 ) * cpu ) ) );
481         assertThat( concurrency.classes, is( 0 ) );
482         assertThat( concurrency.methods, is( Integer.MAX_VALUE ) );
483     }
484 
485     @Theory
486     public void threadCountSuitesAndClasses( int cpu ) throws TestSetFailedException
487     {
488         ParallelComputerFactory.overrideAvailableProcessors( cpu );
489         Properties properties = new Properties();
490         properties.setProperty( PARALLEL_KEY, "suitesAndClasses" );
491         properties.setProperty( THREADCOUNT_KEY, "3" );
492         JUnitCoreParameters params = new JUnitCoreParameters( properties );
493         Concurrency concurrency = resolveConcurrency( params );
494         assertTrue( params.isParallelSuites() );
495         assertTrue( params.isParallelClasses() );
496         assertFalse( params.isParallelMethod() );
497         assertThat( concurrency.capacity, is( 3 * cpu ) );
498         assertThat( concurrency.suites, is( (int) ( ( 3d / 2 ) * cpu ) ) );
499         assertThat( concurrency.classes, is( Integer.MAX_VALUE ) );
500         assertThat( concurrency.methods, is( 0 ) );
501     }
502 
503     @Theory
504     public void threadCountAll( int cpu ) throws TestSetFailedException
505     {
506         ParallelComputerFactory.overrideAvailableProcessors( cpu );
507         Properties properties = new Properties();
508         properties.setProperty( PARALLEL_KEY, "all" );
509         properties.setProperty( THREADCOUNT_KEY, "3" );
510         JUnitCoreParameters params = new JUnitCoreParameters( properties );
511         Concurrency concurrency = resolveConcurrency( params );
512         assertTrue( params.isParallelSuites() );
513         assertTrue( params.isParallelClasses() );
514         assertTrue( params.isParallelMethod() );
515         assertThat( concurrency.capacity, is( 3 * cpu ) );
516         assertThat( concurrency.suites, is( cpu ) );
517         assertThat( concurrency.classes, is( cpu ) );
518         assertThat( concurrency.methods, is( Integer.MAX_VALUE ) );
519     }
520 
521     @Theory
522     public void everyThreadCountSuitesAndClasses( int cpu ) throws TestSetFailedException
523     {
524         ParallelComputerFactory.overrideAvailableProcessors( cpu );
525         Properties properties = new Properties();
526         properties.setProperty( PARALLEL_KEY, "suitesAndClasses" );
527         properties.setProperty( THREADCOUNT_KEY, "3" );
528         // % percentage ratio
529         properties.setProperty( THREADCOUNTSUITES_KEY, "34" );
530         properties.setProperty( THREADCOUNTCLASSES_KEY, "66" );
531         JUnitCoreParameters params = new JUnitCoreParameters( properties );
532         Concurrency concurrency = resolveConcurrency( params );
533         assertTrue( params.isParallelSuites() );
534         assertTrue( params.isParallelClasses() );
535         assertFalse( params.isParallelMethod() );
536         assertThat( concurrency.capacity, is(3 * cpu) );
537         int concurrentSuites = (int) ( 0.34d * concurrency.capacity );
538         assertThat( concurrency.suites, is( concurrentSuites ) );
539         assertThat( concurrency.classes, is( concurrency.capacity - concurrentSuites ) );
540         assertThat( concurrency.methods, is( 0 ) );
541     }
542 
543     @Theory
544     public void everyThreadCountSuitesAndMethods( int cpu ) throws TestSetFailedException
545     {
546         ParallelComputerFactory.overrideAvailableProcessors( cpu );
547         Properties properties = new Properties();
548         properties.setProperty( PARALLEL_KEY, "suitesAndMethods" );
549         properties.setProperty( THREADCOUNT_KEY, "3" );
550         // % percentage ratio
551         properties.setProperty( THREADCOUNTSUITES_KEY, "34" );
552         properties.setProperty( THREADCOUNTMETHODS_KEY, "66" );
553         JUnitCoreParameters params = new JUnitCoreParameters( properties );
554         Concurrency concurrency = resolveConcurrency( params );
555         assertTrue( params.isParallelSuites() );
556         assertFalse( params.isParallelClasses() );
557         assertTrue( params.isParallelMethod() );
558         assertThat( concurrency.capacity, is( 3 * cpu ) );
559         int concurrentSuites = (int) ( 0.34d * concurrency.capacity );
560         assertThat( concurrency.suites, is( concurrentSuites ) );
561         assertThat( concurrency.classes, is( 0 ) );
562         assertThat( concurrency.methods, is( concurrency.capacity - concurrentSuites ) );
563     }
564 
565     @Theory
566     public void everyThreadCountClassesAndMethods( int cpu ) throws TestSetFailedException
567     {
568         ParallelComputerFactory.overrideAvailableProcessors( cpu );
569         Properties properties = new Properties();
570         properties.setProperty( PARALLEL_KEY, "classesAndMethods" );
571         properties.setProperty( THREADCOUNT_KEY, "3" );
572         // % percentage ratio
573         properties.setProperty( THREADCOUNTCLASSES_KEY, "34" );
574         properties.setProperty( THREADCOUNTMETHODS_KEY, "66" );
575         JUnitCoreParameters params = new JUnitCoreParameters( properties );
576         Concurrency concurrency = resolveConcurrency( params );
577         assertFalse( params.isParallelSuites() );
578         assertTrue( params.isParallelClasses() );
579         assertTrue( params.isParallelMethod() );
580         assertThat( concurrency.capacity, is( 3 * cpu ) );
581         assertThat( concurrency.suites, is( 0 ) );
582         int concurrentClasses = (int) ( 0.34d * concurrency.capacity );
583         assertThat( concurrency.classes, is( concurrentClasses ) );
584         assertThat( concurrency.methods, is( concurrency.capacity - concurrentClasses ) );
585     }
586 
587     @Theory
588     public void everyThreadCountAll( int cpu ) throws TestSetFailedException
589     {
590         ParallelComputerFactory.overrideAvailableProcessors( cpu );
591         Properties properties = new Properties();
592         properties.setProperty( PARALLEL_KEY, "all" );
593         properties.setProperty( THREADCOUNT_KEY, "3" );
594         // % percentage ratio
595         properties.setProperty( THREADCOUNTSUITES_KEY, "17" );
596         properties.setProperty( THREADCOUNTCLASSES_KEY, "34" );
597         properties.setProperty( THREADCOUNTMETHODS_KEY, "49" );
598         JUnitCoreParameters params = new JUnitCoreParameters( properties );
599         Concurrency concurrency = resolveConcurrency( params );
600         assertTrue( params.isParallelSuites() );
601         assertTrue( params.isParallelClasses() );
602         assertTrue( params.isParallelMethod() );
603         assertThat( concurrency.capacity, is( 3 * cpu ) );
604         int concurrentSuites = (int) ( 0.17d * concurrency.capacity );
605         int concurrentClasses = (int) ( 0.34d * concurrency.capacity );
606         assertThat( concurrency.suites, is( concurrentSuites ) );
607         assertThat( concurrency.classes, is( concurrentClasses ) );
608         assertThat( concurrency.methods, is( concurrency.capacity - concurrentSuites - concurrentClasses ) );
609     }
610 
611     @Theory
612     public void reusableThreadCountSuitesAndClasses( int cpu ) throws TestSetFailedException
613     {
614         // 4 * cpu to 5 * cpu threads to run test classes
615         ParallelComputerFactory.overrideAvailableProcessors( cpu );
616         Properties properties = new Properties();
617         properties.setProperty( PARALLEL_KEY, "suitesAndClasses" );
618         properties.setProperty( THREADCOUNT_KEY, "6" );
619         properties.setProperty( THREADCOUNTSUITES_KEY, "2" );
620         JUnitCoreParameters params = new JUnitCoreParameters( properties );
621         Concurrency concurrency = resolveConcurrency( params );
622         assertTrue( params.isParallelSuites() );
623         assertTrue( params.isParallelClasses() );
624         assertFalse( params.isParallelMethod() );
625         assertThat( concurrency.capacity, is( 6 * cpu ) );
626         assertThat( concurrency.suites, is( 2 * cpu ) );
627         assertThat( concurrency.classes, is( Integer.MAX_VALUE ) );
628         assertThat( concurrency.methods, is( 0 ) );
629     }
630 
631     @Theory
632     public void reusableThreadCountSuitesAndMethods( int cpu ) throws TestSetFailedException
633     {
634         // 4 * cpu to 5 * cpu threads to run test methods
635         ParallelComputerFactory.overrideAvailableProcessors( cpu );
636         Properties properties = new Properties();
637         properties.setProperty( PARALLEL_KEY, "suitesAndMethods" );
638         properties.setProperty( THREADCOUNT_KEY, "6" );
639         properties.setProperty( THREADCOUNTSUITES_KEY, "2" );
640         JUnitCoreParameters params = new JUnitCoreParameters( properties );
641         Concurrency concurrency = resolveConcurrency( params );
642         assertTrue( params.isParallelSuites() );
643         assertFalse( params.isParallelClasses() );
644         assertTrue( params.isParallelMethod() );
645         assertThat( concurrency.capacity, is( 6 * cpu ) );
646         assertThat( concurrency.suites, is( 2 * cpu ) );
647         assertThat( concurrency.classes, is( 0 ) );
648         assertThat( concurrency.methods, is( Integer.MAX_VALUE ) );
649     }
650 
651     @Theory
652     public void reusableThreadCountClassesAndMethods( int cpu ) throws TestSetFailedException
653     {
654         // 4 * cpu to 5 * cpu threads to run test methods
655         ParallelComputerFactory.overrideAvailableProcessors( cpu );
656         Properties properties = new Properties();
657         properties.setProperty( PARALLEL_KEY, "classesAndMethods" );
658         properties.setProperty( THREADCOUNT_KEY, "6" );
659         properties.setProperty( THREADCOUNTCLASSES_KEY, "2" );
660         JUnitCoreParameters params = new JUnitCoreParameters( properties );
661         Concurrency concurrency = resolveConcurrency( params );
662         assertFalse( params.isParallelSuites() );
663         assertTrue( params.isParallelClasses() );
664         assertTrue( params.isParallelMethod() );
665         assertThat( concurrency.capacity, is( 6 * cpu ) );
666         assertThat( concurrency.suites, is( 0 ) );
667         assertThat( concurrency.classes, is( 2 * cpu ) );
668         assertThat( concurrency.methods, is( Integer.MAX_VALUE ) );
669     }
670 
671     @Theory
672     public void reusableThreadCountAll( int cpu ) throws TestSetFailedException
673     {
674         // 8 * cpu to 13 * cpu threads to run test methods
675         ParallelComputerFactory.overrideAvailableProcessors( cpu );
676         Properties properties = new Properties();
677         properties.setProperty( PARALLEL_KEY, "all" );
678         properties.setProperty( THREADCOUNT_KEY, "14" );
679         properties.setProperty( THREADCOUNTSUITES_KEY, "2" );
680         properties.setProperty( THREADCOUNTCLASSES_KEY, "4" );
681         JUnitCoreParameters params = new JUnitCoreParameters( properties );
682         Concurrency concurrency = resolveConcurrency( params );
683         assertTrue( params.isParallelSuites() );
684         assertTrue( params.isParallelClasses() );
685         assertTrue( params.isParallelMethod() );
686         assertThat( concurrency.capacity, is( 14 * cpu ) );
687         assertThat( concurrency.suites, is( 2 * cpu ) );
688         assertThat( concurrency.classes, is( 4 * cpu ) );
689         assertThat( concurrency.methods, is( Integer.MAX_VALUE ) );
690     }
691 
692     @Theory
693     public void suites( int cpu ) throws TestSetFailedException
694     {
695         ParallelComputerFactory.overrideAvailableProcessors( cpu );
696         Properties properties = new Properties();
697         properties.setProperty( PARALLEL_KEY, "suites" );
698         properties.setProperty( THREADCOUNTSUITES_KEY, "5" );
699         JUnitCoreParameters params = new JUnitCoreParameters( properties );
700         Concurrency concurrency = resolveConcurrency( params );
701         assertTrue( params.isParallelSuites() );
702         assertFalse( params.isParallelClasses() );
703         assertFalse( params.isParallelMethod() );
704         assertThat( concurrency.capacity, is( 5 * cpu ) );
705         assertThat( concurrency.suites, is( 5 * cpu ) );
706         assertThat( concurrency.classes, is( 0 ) );
707         assertThat( concurrency.methods, is( 0 ) );
708     }
709 
710     @Theory
711     public void classes( int cpu ) throws TestSetFailedException
712     {
713         ParallelComputerFactory.overrideAvailableProcessors( cpu );
714         Properties properties = new Properties();
715         properties.setProperty( PARALLEL_KEY, "classes" );
716         properties.setProperty( THREADCOUNTCLASSES_KEY, "5" );
717         JUnitCoreParameters params = new JUnitCoreParameters( properties );
718         Concurrency concurrency = resolveConcurrency( params );
719         assertFalse( params.isParallelSuites() );
720         assertTrue( params.isParallelClasses() );
721         assertFalse( params.isParallelMethod() );
722         assertThat( concurrency.capacity, is( 5 * cpu ) );
723         assertThat( concurrency.suites, is( 0 ) );
724         assertThat( concurrency.classes, is( 5 * cpu ) );
725         assertThat( concurrency.methods, is( 0 ) );
726     }
727 
728     @Theory
729     public void methods( int cpu ) throws TestSetFailedException
730     {
731         ParallelComputerFactory.overrideAvailableProcessors( cpu );
732         Properties properties = new Properties();
733         properties.setProperty( PARALLEL_KEY, "methods" );
734         properties.setProperty( THREADCOUNTMETHODS_KEY, "5" );
735         JUnitCoreParameters params = new JUnitCoreParameters( properties );
736         Concurrency concurrency = resolveConcurrency( params );
737         assertFalse( params.isParallelSuites() );
738         assertFalse( params.isParallelClasses() );
739         assertTrue( params.isParallelMethod() );
740         assertThat( concurrency.capacity, is( 5 * cpu ) );
741         assertThat( concurrency.suites, is( 0 ) );
742         assertThat( concurrency.classes, is( 0 ) );
743         assertThat( concurrency.methods, is( 5 * cpu ) );
744     }
745 
746     @Theory
747     public void suitesAndClasses( int cpu ) throws TestSetFailedException
748     {
749         ParallelComputerFactory.overrideAvailableProcessors( cpu );
750         Properties properties = new Properties();
751 
752         properties.setProperty( PARALLEL_KEY, "suitesAndClasses" );
753         properties.setProperty( THREADCOUNTSUITES_KEY, "5" );
754         properties.setProperty( THREADCOUNTCLASSES_KEY, "15" );
755         JUnitCoreParameters params = new JUnitCoreParameters( properties );
756         Concurrency concurrency = resolveConcurrency( params );
757         assertTrue( params.isParallelSuites() );
758         assertTrue( params.isParallelClasses() );
759         assertFalse( params.isParallelMethod() );
760         assertThat( concurrency.capacity, is( 20 * cpu ) );
761         assertThat( concurrency.suites, is( 5 * cpu ) );
762         assertThat( concurrency.classes, is( 15 * cpu ) );
763         assertThat( concurrency.methods, is( 0 ) );
764 
765         // Warning: this case works but is not enabled in AbstractSurefireMojo
766         // Instead use the 'useUnlimitedThreads' parameter.
767         properties = new Properties();
768         properties.setProperty( PARALLEL_KEY, "suitesAndClasses" );
769         properties.setProperty( THREADCOUNTSUITES_KEY, "5" );
770         params = new JUnitCoreParameters( properties );
771         concurrency = resolveConcurrency( params );
772         assertTrue( params.isParallelSuites() );
773         assertTrue( params.isParallelClasses() );
774         assertFalse( params.isParallelMethod() );
775         assertThat( concurrency.capacity, is( Integer.MAX_VALUE ) );
776         assertThat( concurrency.suites, is( 5 * cpu ) );
777         assertThat( concurrency.classes, is( Integer.MAX_VALUE ) );
778         assertThat( concurrency.methods, is( 0 ) );
779     }
780 
781     @Theory
782     public void suitesAndMethods( int cpu ) throws TestSetFailedException
783     {
784         ParallelComputerFactory.overrideAvailableProcessors( cpu );
785         Properties properties = new Properties();
786 
787         properties.setProperty( PARALLEL_KEY, "suitesAndMethods" );
788         properties.setProperty( THREADCOUNTSUITES_KEY, "5" );
789         properties.setProperty( THREADCOUNTMETHODS_KEY, "15" );
790         JUnitCoreParameters params = new JUnitCoreParameters( properties );
791         Concurrency concurrency = resolveConcurrency( params );
792         assertTrue( params.isParallelSuites() );
793         assertFalse( params.isParallelClasses() );
794         assertTrue( params.isParallelMethod() );
795         assertThat( concurrency.capacity, is( 20 * cpu ) );
796         assertThat( concurrency.suites, is( 5 * cpu ) );
797         assertThat( concurrency.classes, is( 0 ) );
798         assertThat( concurrency.methods, is( 15 * cpu ) );
799 
800         // Warning: this case works but is not enabled in AbstractSurefireMojo
801         // Instead use the 'useUnlimitedThreads' parameter.
802         properties = new Properties();
803         properties.setProperty( PARALLEL_KEY, "suitesAndMethods" );
804         properties.setProperty( THREADCOUNTSUITES_KEY, "5" );
805         params = new JUnitCoreParameters( properties );
806         concurrency = resolveConcurrency( params );
807         assertTrue( params.isParallelSuites() );
808         assertFalse( params.isParallelClasses() );
809         assertTrue( params.isParallelMethod() );
810         assertThat( concurrency.capacity, is( Integer.MAX_VALUE ) );
811         assertThat( concurrency.suites, is( 5 * cpu ) );
812         assertThat( concurrency.classes, is( 0 ) );
813         assertThat( concurrency.methods, is( Integer.MAX_VALUE ) );
814     }
815 
816     @Theory
817     public void classesAndMethods( int cpu ) throws TestSetFailedException
818     {
819         ParallelComputerFactory.overrideAvailableProcessors( cpu );
820         Properties properties = new Properties();
821 
822         properties.setProperty( PARALLEL_KEY, "classesAndMethods" );
823         properties.setProperty( THREADCOUNTCLASSES_KEY, "5" );
824         properties.setProperty( THREADCOUNTMETHODS_KEY, "15" );
825         JUnitCoreParameters params = new JUnitCoreParameters( properties );
826         Concurrency concurrency = resolveConcurrency( params );
827         assertFalse( params.isParallelSuites() );
828         assertTrue( params.isParallelClasses() );
829         assertTrue( params.isParallelMethod() );
830         assertThat( concurrency.capacity, is( 20 * cpu ) );
831         assertThat( concurrency.suites, is( 0 ) );
832         assertThat( concurrency.classes, is( 5 * cpu ) );
833         assertThat( concurrency.methods, is( 15 * cpu ) );
834 
835         // Warning: this case works but is not enabled in AbstractSurefireMojo
836         // Instead use the 'useUnlimitedThreads' parameter.
837         properties = new Properties();
838         properties.setProperty( PARALLEL_KEY, "classesAndMethods" );
839         properties.setProperty( THREADCOUNTCLASSES_KEY, "5" );
840         params = new JUnitCoreParameters( properties );
841         concurrency = resolveConcurrency( params );
842         assertFalse( params.isParallelSuites() );
843         assertTrue( params.isParallelClasses() );
844         assertTrue( params.isParallelMethod() );
845         assertThat( concurrency.capacity, is( Integer.MAX_VALUE ) );
846         assertThat( concurrency.suites, is( 0 ) );
847         assertThat( concurrency.classes, is( 5 * cpu ) );
848         assertThat( concurrency.methods, is( Integer.MAX_VALUE ) );
849     }
850 
851     @Theory
852     public void all( int cpu ) throws TestSetFailedException
853     {
854         ParallelComputerFactory.overrideAvailableProcessors( cpu );
855         Properties properties = new Properties();
856 
857         properties.setProperty( PARALLEL_KEY, "all" );
858         properties.setProperty( THREADCOUNTSUITES_KEY, "5" );
859         properties.setProperty( THREADCOUNTCLASSES_KEY, "15" );
860         properties.setProperty( THREADCOUNTMETHODS_KEY, "30" );
861         JUnitCoreParameters params = new JUnitCoreParameters( properties );
862         Concurrency concurrency = resolveConcurrency( params );
863         assertTrue( params.isParallelSuites() );
864         assertTrue( params.isParallelClasses() );
865         assertTrue( params.isParallelMethod() );
866         assertThat( concurrency.capacity, is( 50 * cpu ) );
867         assertThat( concurrency.suites, is( 5 * cpu ) );
868         assertThat( concurrency.classes, is( 15 * cpu ) );
869         assertThat( concurrency.methods, is( 30 * cpu ) );
870 
871         // Warning: these cases work but they are not enabled in AbstractSurefireMojo
872         // Instead use the 'useUnlimitedThreads' parameter.
873         properties = new Properties();
874         properties.setProperty( PARALLEL_KEY, "all" );
875         properties.setProperty( THREADCOUNTSUITES_KEY, "5" );
876         properties.setProperty( THREADCOUNTCLASSES_KEY, "15" );
877         params = new JUnitCoreParameters( properties );
878         concurrency = resolveConcurrency( params );
879         assertTrue( params.isParallelSuites() );
880         assertTrue( params.isParallelClasses() );
881         assertTrue( params.isParallelMethod() );
882         assertThat( concurrency.capacity, is( Integer.MAX_VALUE ) );
883         assertThat( concurrency.suites, is( 5 * cpu ) );
884         assertThat( concurrency.classes, is( 15 * cpu ) );
885         assertThat( concurrency.methods, is( Integer.MAX_VALUE ) );
886 
887         properties = new Properties();
888         properties.setProperty( PARALLEL_KEY, "all" );
889         properties.setProperty( THREADCOUNTCLASSES_KEY, "15" );
890         params = new JUnitCoreParameters( properties );
891         concurrency = resolveConcurrency( params );
892         assertTrue( params.isParallelSuites() );
893         assertTrue( params.isParallelClasses() );
894         assertTrue( params.isParallelMethod() );
895         assertThat( concurrency.capacity, is( Integer.MAX_VALUE ) );
896         assertThat( concurrency.suites, is( Integer.MAX_VALUE ) );
897         assertThat( concurrency.classes, is( 15 * cpu ) );
898         assertThat( concurrency.methods, is( Integer.MAX_VALUE ) );
899     }
900 
901     private static Properties parallel( String parallel )
902     {
903         Properties properties = new Properties();
904         properties.setProperty( PARALLEL_KEY, parallel );
905         return properties;
906     }
907 }