编程语言

img CICTech

GroboUtils之多线程测试

发表于2008/9/28 9:07:00  4241人阅读

分类: Java

    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计算
  2. import net.sourceforge.groboutils.junit.v1.TestRunnable;
  3. public class testpi extends TestRunnable {
  4.         volatile double pi;
  5.         public double getPi() {
  6.                 return this.pi;
  7.         }
  8.         public void setPi(double pi) {
  9.                 this.pi = pi;
  10.         }
  11.         public void runTest() {
  12.                 calPI();
  13.         }
  14.         private double calPI() {
  15.                 boolean negative = true;
  16.                 for (int i = 3; i < Long.MAX_VALUE; i += 2) {
  17.                         if (negative)
  18.                                 pi -= (1.0 / i);
  19.                         else
  20.                                 pi += (1.0 / i);
  21.                         negative = !negative;
  22.                 }
  23.                 pi += 1.0;
  24.                 pi *= 4.0;
  25.                 return this.pi;
  26.         }
  27.         public testpi() {
  28.         }
  29. }
  30. //改写后的ob
  31. import net.sourceforge.groboutils.junit.v1.TestRunnable;
  32. public class testob extends TestRunnable {
  33.         testpi pi;
  34.         testob(testpi pi) throws InterruptedException {
  35.                 this.pi = pi;
  36.                 System.out.println("Start to calculate pi");
  37.         }
  38.         public void runTest() {
  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. }

  1. //改写后的测试类
  2. import net.sourceforge.groboutils.junit.v1.MultiThreadedTestRunner;
  3. import net.sourceforge.groboutils.junit.v1.TestRunnable;
  4. import junit.framework.TestCase;
  5. public class groboutil_test1 extends TestCase {
  6.         public void testobserver() throws Throwable {
  7.                 TestRunnable tr1,tr2;
  8.                
  9.                 tr1=new testpi();
  10.                 tr2=new testob((testpi)tr1);
  11.                 TestRunnable[] trs={tr1,tr2};
  12.                 MultiThreadedTestRunner mttr = new MultiThreadedTestRunner(trs);
  13.                 mttr.runTestRunnables();
  14.         }
  15. }
    可以看到,这样,程序又可以正常的启动测试了。通过在testrunnable数组里面任意调用需要的线程, MultiThreadedTestRunner会自己等待所有的线程执行完毕退出后才继续,所以,我们不必自己调用线程的start(),来启动线程, 而且交给 MultiThreadedTestRunner来统一调度,它会统一为线程启动进行异步控制。对于测试者而言,只需把注意力放在自己关注的单元测试上。 并且,它还提供了delay(),isDone()等方法,进一步方便测试者的调试。
    有了GroboUtils,多线程测试从此变得简单而快乐。
    GroboUtils链接:http://groboutils.sourceforge.net/   
阅读全文
0 0

相关文章推荐

img
取 消
img