JUnit4 多线程执行测试用例 （下)

八戒你干嘛

由于字数限制，此贴分为两贴，此贴为下贴。


上贴地址⬇️
JUnit4 多线程执行测试用例 （上)






只要在单个测试类前，加上注解：@RunWith(MultiThreadRunner.class),就可以并发的执行用例。
如下图：


(三)自定义聚合多个类进行多线程执行的Runner有时我们需要聚合同一个模块的测试类，如果使用@RunWith(Suite.class)@SuiteClasses({A.class,B.class})，当类较多时，需要一一列举，效率不高；可以使用ClasspathSuite，支持过滤，将类名符合一定规则的类聚合，官方文档。
实现代码如下：

1. package com.weibo.concurrent;
   
2. 
   
3. import org.junit.experimental.categories.Categories;
   
4. import org.junit.extensions.cpsuite.ClasspathSuite;
   
5. import org.junit.internal.builders.AllDefaultPossibilitiesBuilder;
   
6. import org.junit.runner.Runner;
   
7. import org.junit.runners.ParentRunner;
   
8. import org.junit.runners.model.InitializationError;
   
9. import org.junit.runners.model.RunnerBuilder;
   
10. import org.junit.runners.model.RunnerScheduler;
    
11. 
    
12. import com.weibo.common.MbLogger;
    
13. 
    
14. import java.lang.reflect.Method;
    
15. import java.util.ArrayList;
    
16. import java.util.Arrays;
    
17. import java.util.LinkedList;
    
18. import java.util.List;
    
19. import java.util.Queue;
    
20. import java.util.concurrent.CompletionService;
    
21. import java.util.concurrent.ExecutorCompletionService;
    
22. import java.util.concurrent.ExecutorService;
    
23. import java.util.concurrent.Executors;
    
24. import java.util.concurrent.Future;
    
25. import java.util.concurrent.ThreadFactory;
    
26. import java.util.concurrent.TimeUnit;
    
27. import java.util.concurrent.atomic.AtomicInteger;
    
28. 
    
29. /**
    
30. * @author hugang
    
31. *
    
32. **/
    
33. public final class ConcurrentSuite extends ClasspathSuite {
    
34. 
    
35.     public static Runner MulThread(Runner runner) {
    
36.         if (runner instanceof ParentRunner) {
    
37.             // setScheduler(RunnerScheduler scheduler):Sets a scheduler that
    
38.             // determines the order and parallelization of children
    
39.             // RunnerScheduler:Represents a strategy for scheduling when
    
40.             // individual test methods should be run (in serial or parallel)
    
41.             ((ParentRunner) runner).setScheduler(new RunnerScheduler() {
    
42.                 private final ExecutorService fService = Executors
    
43.                         .newCachedThreadPool();
    
44. 
    
45.                 // private final ExecutorService fService =
    
46.                 // Executors.newFixedThreadPool(10);
    
47. 
    
48.                 // Schedule a child statement to run
    
49.                 public void schedule(Runnable childStatement) {
    
50.                     this.fService.submit(childStatement);
    
51.                 }
    
52. 
    
53.                 // Override to implement any behavior that must occur after all
    
54.                 // children have been scheduled
    
55.                 public void finished() {
    
56.                     try {
    
57.                         this.fService.shutdown();
    
58.                         this.fService.awaitTermination(9223372036854775807L,
    
59.                                 TimeUnit.NANOSECONDS);
    
60.                     } catch (InterruptedException e) {
    
61.                         e.printStackTrace(System.err);
    
62.                     }
    
63.                 }
    
64.             });
    
65.         }
    
66.         return runner;
    
67.     }
    
68. 
    
69.     public ConcurrentSuite(final Class<?> klass) throws InitializationError {
    
70.         // 调用父类ClasspathSuite构造函数
    
71.         // AllDefaultPossibilitiesBuilder根据不同的测试类定义（@RunWith的信息）返回Runner,使用职责链模式
    
72.         super(klass, new AllDefaultPossibilitiesBuilder(true) {
    
73.             @Override
    
74.             public Runner runnerForClass(Class<?> testClass) throws Throwable {
    
75.                 List<RunnerBuilder> builders = Arrays
    
76.                         .asList(new RunnerBuilder[] { ignoredBuilder(),
    
77.                                 annotatedBuilder(), suiteMethodBuilder(),
    
78.                                 junit3Builder(), junit4Builder() });
    
79.                 for (RunnerBuilder each : builders) {
    
80.                     // 根据不同的测试类定义（@RunWith的信息）返回Runner
    
81.                     Runner runner = each.safeRunnerForClass(testClass);
    
82.                     if (runner != null)
    
83.                         // 方法级别，多线程执行
    
84.                         return MulThread(runner);
    
85.                 }
    
86.                 return null;
    
87.             }
    
88.         });
    
89. 
    
90.         // 类级别，多线程执行
    
91.         setScheduler(new RunnerScheduler() {
    
92.             private final ExecutorService fService = Executors
    
93.                     .newCachedThreadPool();
    
94. 
    
95.             @Override
    
96.             public void schedule(Runnable paramRunnable) {
    
97.                 // TODO Auto-generated method stub
    
98.                 fService.submit(paramRunnable);
    
99.             }
    
100. 
     
101.             @Override
     
102.             public void finished() {
     
103.                 // TODO Auto-generated method stub
     
104.                 try {
     
105.                     fService.shutdown();
     
106.                     fService.awaitTermination(Long.MAX_VALUE,
     
107.                             TimeUnit.NANOSECONDS);
     
108.                 } catch (InterruptedException e) {
     
109.                     e.printStackTrace(System.err);
     
110.                 }
     
111.             }
     
112. 
     
113.         });
     
114.     }
     
115. 
     
116. }

复制代码

新建一个聚合的IntegrationBeijingOneTests.java文件：

1. @RunWith(ConcurrentSuite.class)
   
2. @ClassnameFilters({"com.weibo.cases.xuelian.*Test", "!.*RemindTest","com.weibo.cases.maincase.*Xuelian"})
   
3. @Concurrent
   
4. public interface IntegrationBeijingOneTests {
   
5. 
   
6. }

复制代码

再建一个suite文件，XuelianTestSuite.java：

1. package com.weibo.cases.suite;
   
2. import org.junit.experimental.categories.Categories;
   
3. import org.junit.runner.RunWith;
   
4. import org.junit.runners.Suite.SuiteClasses;
   
5. 
   
6. @RunWith(Categories.class)
   
7. @SuiteClasses( IntegrationBeijingOneTests.class )
   
8. public class XuelianTestSuite {
   
9. 
   
10. }

复制代码

直接运行XuelianTestSuite.java即可，执行过程如下：


写在最后：设计测试用例时需考虑线程安全。
建议（本组内用例）：
1.账号的使用，同一个测试类中每个测试方法之间需使用不同测试账号（之前未考虑并发，串行执行时方法间使用同样账号，没有影响），咱们组V4的用例共1516个，假设每个用例使用3个账号，则同时执行用例时，则需4548个账号，现库里有1617个账号，可能需要增加用户（空间换时间）； 当然也可以控制并发执行测试方法的数量，来减少用户的使用，比如可以指定同时5个（可调）测试方法并发执行，当然，执行时间上就会相应的增加。
2.非final的全局变量，全改写到测试方法内定义，变成局部变量。

icerman

@Concurrent，我这为什么不识别