首页 > 代码库 > "Timeout"在测试框架里是如何被实现的

"Timeout"在测试框架里是如何被实现的

        今天组里的小伙伴问了我一个问题:“我这里有一个底层驱动的接口,我想在测试它的时候加上超时限制,时间一过就fail掉它,执行后面的测试用例。怎么办到呢?”。我问:“它自己没有超时响应的机制么? 超时抛exception或者返回错误提示什么的?”,小伙伴回答是“好像没有。” 我接着问: “这个接口是做什么的,是核心交易么?” “算是吧,调用还挺频繁的。”小伙伴回答。“那这个接口决不能让它通过测试啊!”我大声回答,旁边n人侧目。“好吧。那我如何实现超时fail呢?” 小伙伴继续问。。。“呃。。。让我慢慢道来。”

      超时处理其实是编程过程中经常要面对的问题。在我们调用某个函数的时候,调用方把控制权交给了被调用方,但被调用方很多时候是不可控的,如果被调用方长时间不给调用方返回结果,调用方就要想别的办法,不然就hang死在那里了。这就是超时处理最初始的需求,它的本质是要求把同步调用变成异步调用。把同步变异步其实是个较大的话题,不同的高级语言,框架,甚至操作系统都进行了各式各样的封装,提供了各式各样的接口,十分精彩,但这并不是今天的重点,因此不会展开说了。下面举几个例子来看看“timeout”是怎么实现的。先拿JAVA语言来说吧:

     首先要说明的是,在单线程下,不借助一些特殊工具,“超时处理”是很难实现的,请见下面的代码:

RemoteServer itest = new RemoteServer()String result = itest.callRemote()  //callRemote()是一个远端接口

如果callRemote()方法永远不给返回值,那程序就一直停留 result = itest.callRemote() 这一行不往下走了。

如何实现下面语法中想要的结果呢,如果callRemote()永远不会抛出TimeoutException的话?

try{
RemoteServer itest = new RemoteServer()
     result = itest.callRemote()
}catch(TimeoutException e) 
{ e.printStackTrace() }

多线程?这是个好主意!你最初的想法可能是:让一个子线程在调用前开始计时,如果超时了通知主线程。如果是我,我会一般想到两种通知的方式:一种是抛出异常,让主线程捕获,另一种是Listener的方式实现callback。

如果你使用第一种抛异常的方式,见如下代码:

public class TimeCount implements Runnable {    private long timeOut;    private long beginTime;    public  TimeCount(long timeOut,long beginTime){        this.timeOut = timeOut;        this.beginTime = beginTime;    }    public void run() throws TimeOutException{        while(true) {            if((System.currentTimeMillis()-beginTime)>timeOut){                throw new TimeOutException("Timeout!");            }        }    }}

恭喜你,Java不允许run() 方法向上抛出异常。就算你@override 它也不行。这也是JDK早期的线程模型一个重要槽点。

OK,那我只能使用listener的方式了。

Private XXListener lstr;    public void run() throws TimeOutException{        while(true) {            if((System.currentTimeMillis()-beginTime)>timeOut){                lstr.notify("Time out!");                }        }    }

但是这样如果没有现成的Listener,你就要去实现它,还是很复杂的(有兴趣可以看看这篇文章),同时,对被测类产生了一定入侵。可见,上面两种方法都不是什么好方法。那么有没有什么较好的方法呢?Java其实对多任务调度实现了非常好的封装在(java.util.concurrent包里),我们可以使用下面代码方便的实现异步。

先看一下被测类:

import java.util.*;public class TimeOutCall {        public String CallWithTimeOut( long timeSetting ) //被测物方法,输入参数可以设置多长时间返回。       {               long startTime = System.currentTimeMillis ();               while(true )              {                      if(System.currentTimeMillis() - startTime < timeSetting )                            continue;                      else                            return "Result returned!" ;              }       }}


 
 
 

 

再看一下实现超时的调用类:

import java.util.concurrent.ExecutorService;import java.util.concurrent.Callable;import java.util.concurrent.Executors;import java.util.concurrent.Future;import java.util.concurrent.TimeUnit;import java.util.concurrent.TimeoutException;public class CallTest {    public static   void main(String [] args)    {        ExecutorService service = Executors. newSingleThreadExecutor();        Callable<String> callable  = new Callable<String>(){ //实现Callable接口的匿名类            public String call() throws Exception{                TimeOutCall toc = new TimeOutCall();                return toc.CallWithTimeOut(3000);  //3秒返回结果            }        };        Future<String> future = service.submit( callable);        service.shutdown();        try {            if(service.awaitTermination (1000, TimeUnit.MILLISECONDS) == false)//等待1秒后抛出异常。                throw new TimeoutException();            System. out.println(future .get());        } catch (Exception e) {            // TODO Auto-generated catch block            e.printStackTrace();        }    }}

上述代码中我们创建了一个ExecutorService类,并且将一个Callable接口类型的作业提交给了类,而Future可以异步的等待Callable作业的执行结果。想查看作业执行时间的话,ExecutorService提供了一个相当方便的方法 awaitTermination来检测是否作业在开始后一段时间还在继续执行,通过对方法第一个参数的设置,我们很容易能够设置超时的时限。

 

事实上,Junit也是用类似的方法实现超时检测的,在Junit中,我们可以方便的使用Annotation给一个测试方法加入超时检测:

@Test(timeout =1000)public void testXXX(){...}

而它在代码中对方法超时的实现核心代码如下(org.junit.internal.runners.MethodRoadie.java中):

 private void runWithTimeout(final long timeout) {        runBeforesThenTestThenAfters(new Runnable() {            public void run() {                ExecutorService service = Executors.newSingleThreadExecutor();                Callable<Object> callable = new Callable<Object>() {                    public Object call() throws Exception {                        runTestMethod();                        return null;                    }                };                Future<Object> result = service.submit(callable);                service.shutdown();                try {                    boolean terminated = service.awaitTermination(timeout,                            TimeUnit.MILLISECONDS);                    if (!terminated) {                        service.shutdownNow();                    }                    result.get(0, TimeUnit.MILLISECONDS); // throws the exception if one occurred during the invocation                } catch (TimeoutException e) {                    addFailure(new TestTimedOutException(timeout, TimeUnit.MILLISECONDS));                } catch (Exception e) {                    addFailure(e);                }            }        });    }

不过,如果你在Junit中使用了@BeforeClass 和@AfterClass,并且有多个测试用例都必须检测超时,则建议使用Rules来设置整体超时时间。

大家也可以参考StackOverFlow上的这个链接,看一下讨论过程,相信会有一个更加深入的理解:

http://stackoverflow.com/questions/2758612/executorservice-that-interrupts-tasks-after-a-timeout

 

上文说过,不同语言,不同操作系统,timeout实现起来很不一样。比如python,如果在UnixLike系统下,可以用python内置的signal包来方便的实现超时,我们来看下面的例子:

import signal, osdef handler(signum, frame): #产生超时后调用。    print Signal handler called with signal, signum    raise IOError("Couldn‘t open device!")# Set the signal handler and a 5-second alarmsignal.signal(signal.SIGALRM, handler) #指定handlersignal.alarm(5)  #设置5秒超时# This open() may hang indefinitelyfd = os.open(/dev/ttyS0, os.O_RDWR)signal.alarm(0)

在使用的时候,我们可以很方便的把它也封装成Decorator(等同于Java的Annotation)

但是,在Windows下,就没有那么幸运了,因为signal包直接使用了unixlike操作系统的信号量机制,这时候实现超时就会相对麻烦一些。什么?多线程?答案又一次对了。我们可以使用multiprocessing 

包中的函数来实现超时检测。下面是粗略的代码实现(真的是粗略的实现)要想深入了解,请看python多线程的在线文档

 

__author__ = lucasliufrom multiprocessing import Processimport timedef timefucntion(sleeptime ):    time.sleep(sleeptime)    print timefuction returned after, sleeptime,secondsif __name__ == __main__:    p = Process(target=timefucntion,args=(3,))    starttime = time.time()    timeoutsetting = 2    p.start()    p.join(timeout=timeoutsetting)    if abs(time.time() - starttime - timeoutsetting)<0.1:        print timeout        p.terminate()

 

      那么在常见python的测试框架里,timeout又是如何实现的呢?有点儿遗憾,python的内置单测框架unittest不支持超时检测。因此我们来看Robotframework是如何实现超时的:一句话,就是根据不同的操作系统,用不同的方法实现超时,并在框架上层统一起来,对用户透明。源码量稍微有点儿大,就不在这里搬运了。有兴趣可以去看Robotframework的 robot.running.timeouts包里的代码,看完一定会有收获。

     至于ruby,就封装的更好了。直接有一个timeout库,引入后可以极为方便的实现timeout,如下面代码:如果do sothing的时间超过了 timeoutsetting的设置就会抛出异常。所以,用ruby的同学相对幸福一些。

require timeoutbegintimeout(timeoutsetting ){    do something}rescue Exception  puts "timeout"ensure  puts "finish"end

 

"Timeout"在测试框架里是如何被实现的