1 package org.apache.maven.surefire.junitcore;
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
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
42
43
44
45
46
47
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
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
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
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
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
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
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
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
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
766
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
801
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
836
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
872
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 }