GroboUtils之多线程测试

    Junit作为java自动化测试利器，在java软件开发方面有着强大的功能和便利。通过大量的单元测试，可以方便的定位错位，而且可以提高自己对代码的信心。单元的颗粒度可以小到是一个函数，也是大到是一个类，甚至更大，但是，在单元测试时，由于junit的设计，它对于runnable的对象是忽略的，所以，在我们的测试过程中，对于多线程的测试就变得困难和不可行。但是，在有些项目中，对多线程的测试又是必须的，难以两全么？现在有了groboutils，这一切就变得轻松方便了。
    在一些单元测试时，我们有可能需要调用一些类的线程，但是，在junit原有的模型上，要么runnable对象被忽略了，要么就得调用它的run()方法，但是，这样的调用也就失去了并发性，在想要查看线程之间的调度时，这样的功能是不够的。
    首先来看一段简单的代码，我们有个类来计算pi，还有个去查看即时的pi值。

1. //class 'calculate pi'
2. public class pi extends Thread {
3.         volatile double pi;
4.         public double getPi() {
5.                 return this.pi;
6.         }
7.         public void setPi(double pi) {
8.                 this.pi = pi;
9.         }
10.         public void run() {
11.                 calPI();
12.         }
13.         private double calPI() {
14.                 boolean negative = true;
15.                 for (int i = 3; i < Long.MAX_VALUE; i += 2) {
16.                         if (negative)
17.                                 pi -= (1.0 / i);
18.                         else
19.                                 pi += (1.0 / i);
20.                         negative = !negative;
21.                 }
22.                 pi += 1.0;
23.                 pi *= 4.0;
24.                 return this.pi;
25.         }
26.         public pi() {
27.                 start();
28.         }
29. }
30. //class view the value of pi
31. public class observer extends Thread {
32.         pi pi;
33.         observer(pi pi) throws InterruptedException {
34.                 this.pi = pi;
35.                 System.out.println("Start to calculate pi");
36.                 start();
37.         }
38.         public void run() {
39.                 while (true) {
40.                         double zz = pi.pi;
41.                         try {
42.                                 Thread.sleep(1000);
43.                                 System.out.println((zz + 1) * 4);
44.                         } catch (InterruptedException e) {
45.                                 e.printStackTrace();
46.                         }
47.                 }
48.         }
49. }

然后，我们进行junit测试。

1. //测试类
2. import junit.framework.TestCase;
3. public class observerTest extends TestCase {
4.         protected void setUp() throws Exception {
5.         }
6.         protected void tearDown() throws Exception {
7.         }
8.         public void testObserver() throws InterruptedException {
9.                 pi temp = new pi();
10.                 new observer(temp);
11.         }
12. }

    很不幸，我们发现，在构造函数初始化时，它忽略了start(),就直接结束了。这显然不是我们想要的结果，在junit中，对于线程，显然是不支持的。好在有了groboutils,这一些就变得方便和轻松了。作为在junit的框架下面的扩展，如果想要使用支持线程的测试，线程要继承TestRunnable这个类，并且重载这个类的runTest方法来代替原来的run();进行多线程测试时，通过MultiThreadedTestRunner来控制线程的启动，先给出改写后的类。

1. //改写后的pi计算
3. import net.sourceforge.groboutils.junit.v1.TestRunnable;
4. public class testpi extends TestRunnable {
5.         volatile double pi;
6.         public double getPi() {
7.                 return this.pi;
8.         }
9.         public void setPi(double pi) {
10.                 this.pi = pi;
11.         }
12.         public void runTest() {
13.                 calPI();
14.         }
15.         private double calPI() {
16.                 boolean negative = true;
17.                 for (int i = 3; i < Long.MAX_VALUE; i += 2) {
18.                         if (negative)
19.                                 pi -= (1.0 / i);
20.                         else
21.                                 pi += (1.0 / i);
22.                         negative = !negative;
23.                 }
24.                 pi += 1.0;
25.                 pi *= 4.0;
26.                 return this.pi;
27.         }
28.         public testpi() {
29.         }
30. }
32. //改写后的ob
33. import net.sourceforge.groboutils.junit.v1.TestRunnable;
34. public class testob extends TestRunnable {
35.         testpi pi;
36.         testob(testpi pi) throws InterruptedException {
37.                 this.pi = pi;
38.                 System.out.println("Start to calculate pi");
39.         }
40.         public void runTest() {
41.                 while (true) {
42.                         double zz = pi.pi;
43.                         try {
44.                                 Thread.sleep(1000);
45.                                 System.out.println((zz + 1) * 4);
46.                         } catch (InterruptedException e) {
47.                                 e.printStackTrace();
48.                         }
49.                 }
50.         }
51. }

1. //改写后的测试类
2. import net.sourceforge.groboutils.junit.v1.MultiThreadedTestRunner;
3. import net.sourceforge.groboutils.junit.v1.TestRunnable;
4. import junit.framework.TestCase;
6. public class groboutil_test1 extends TestCase {
7.         public void testobserver() throws Throwable {
8.                 TestRunnable tr1,tr2;
9.                
10.                 tr1=new testpi();
11.                 tr2=new testob((testpi)tr1);
12.                 TestRunnable[] trs={tr1,tr2};
13.                 MultiThreadedTestRunner mttr = new MultiThreadedTestRunner(trs);
14.                 mttr.runTestRunnables();
15.         }
16. }

    可以看到，这样，程序又可以正常的启动测试了。通过在testrunnable数组里面任意调用需要的线程， MultiThreadedTestRunner会自己等待所有的线程执行完毕退出后才继续，所以，我们不必自己调用线程的start(),来启动线程，而且交给MultiThreadedTestRunner来统一调度，它会统一为线程启动进行异步控制。对于测试者而言，只需把注意力放在自己关注的单元测试上。并且，它还提供了delay(),isDone()等方法，进一步方便测试者的调试。
    有了GroboUtils,多线程测试从此变得简单而快乐。
    GroboUtils链接： http://groboutils.sourceforge.net/