要资料 文章 文库 视频 Code iProcess 课程 认证 咨询 工具 讲座吧   成长之路  
会员   
 
  
每天15篇文章
不仅获得谋生技能
更可以追随信仰
 
 
     
   
分享到
基于 JUnit 的全局单元测试程序
 
发布于2012-11-21 ,来源:IBM
 

背景介绍

最近参与了一个新产品的研发工作。新产品是采用模块式开发方式,拥有众多的功能模块,每一个模块是一个独立的 Java 工程。在产品中,为了保证各个模块的功能,目前其都有相应的 JUnit 测试程序。随着产品功能的逐渐完善,我们发现,程序中光是 JUnit Test 测试文件,全部加起来已经有几百个。由于这些文件分布在几十个不同的工程不同的子目录结构中,目前并没有很好的工具可以将所有的单元测试一次运行。而手工的运行这些单元测试是非常繁琐的,对程序员来说是浪费时间的;又或者可以用脚本完成运行所有测试文件的目的,但是由于我们采取的是敏捷开发的模式,JUnit Test 测试集合会不断的持续增长,每增加一个 JUnit Test 文件,就需要立即修改脚本;一旦忘记修改,这个新加的测试文件可能就无法被执行可见,用脚本来执行测试文件也并不是很好的手段,依然给我们的开发带来额外工作。这里我们有了一个想法,做一个全局的单元测试程序,去自动的检索工程集中所有的 JUnit Test 测试程序。这个全局单元测试程序将基于 JUnit4 去运行。

核心机制:JUnit4 支持一次运行多个测试程序

首先我们要了解 JUnit4 支持多个 Class 集合作为输入,并且调用 org.junit.runner.Runner.run() 方法运行输入的测试类集合。JUnit4 中已经定义了一些默认的 Runner,可以分别处理不同的输入类集合:比如 BlockJUnit4ClassRunner,就是默认处理带有 @Test 的 JUnit4 测试类的运行器;Suite,可以处理兼容 JUnit3 的测试类的运行器,等等。

我们可以来看下面的 Runner 结构图:

图 1. JUnit Runner 结构图

Runner 类定义了运行测试用例的接口,Suite 类继承自 Runner 类,Suite 类支持 JUnit3 风格的测试类,可以用来执行多个测试用例。因此我们的想法是,自定义一个继承自 Suite 类的 Runner,就是上图中得 AllClassRunner 类。这个 Runner 的输入将是工程集中所有找到的 JUnit Test Class 集合,这样就可以一次运行工程中不同工程不同目录下的所有 JUnit Test 文件了。下面是我们的 AllClassRunner 类的代码:

清单 1. AllClassRunner 类的代码

 public class AllJunitTestRunner extends Suite { 	
   public AllJunitTestRunner(Class<?> clazz, RunnerBuilder builder) throws 
       InitializationError { 
	   // 调用父类 Suite 方法直接运行所有符合要求的 JUnit Test 对象
       super(builder, clazz, loadAllTestClass(filterClassNameList 
	   (clazz, loadAllClassesName(clazz)))); 
    } 
 } 

loadAllClassesName 方法将会找到工程集中所有的 Class 文件名的集合,filterClassNameList 将会对找到的 Class 文件集合进行过滤,过滤条件是针对文件名称。loadAllTestClass 则会找到所有符合条件的 JUnitTest Class 集合。

如何找到所有的需要的 JUnit Test 测试类集合

我们来看下面的流程图:

图 2. 找到需要的 JUnit Test Class 对象集合的流程图

流程图要素介绍:

  • 找到工程集内所有的 .class 文件名
  • 对找到的文件名集合根据过滤条件进行初步过滤
  • 根据 .class 文件名转换到相应的 Class 对象
  • 判断是否属于 Abstract 类,如果不是的话,继续判断
  • 判断是否属于 Inner 类,如果不是的话,继续判断
  • 判断是否属于 JUnit3 或者 JUnit4 风格的类,如果是的话,加入结果集
  • 经过上述步骤,将找到所有需要的 JUnit Test class 集合。将找到的 Class 集合放入到自定义 Runner 中,可以达到一次运行工程集内所有测试程序的目的。

如何找出所有的 Class 文件名集合

首先根据默认的 Java classpath 属性,找到当前运行的 JUnit Test 文件所在工程集中所有的文件及文件夹:

清单 2. 找到工程集中所有 Jar 及 .Class 所在目录集合

public static String getClasspath() { 
    return System.getProperty(CONSTANT.DEFAULT_CLASSPATH_PROPERTY); 
 } 

这里得到的将是一个路径集合的 String 对象,包括文件目录及 .jar 文件(jar 文件内也包含 Class 文件名)。我们需要做的,是找到文件目录下的 Class 文件,因此通过 split 这个路径集合,剔除里面的 .jar 文件,我们将得到一个包含工程集中所有 Class 文件的目录集合。

因为 Class 文件可能会嵌套的包含在我们找到的目录集合中,所以我们需要递归的去找到所有的 Class 文件,并将 Class 文件的 Class 名放到一个集合中,示例代码如下:

清单 3. 递归找到工程集中所有的 Class 对象集合

for (String path : Util.splitClassPath(Util.getClasspath())) { 
    // 此处不处理 Jar 包文件,感兴趣的读者可以考虑自己添加对 Jar 包中 JUnit Test 文件的处理
    if (!(path.toLowerCase().endsWith(CONSTANT.JAR_SUFFIX))) { 
	 Util.loadAllClassNames(path, path, classesFileNameList); 
    } 
 } 

 public static void loadAllClassNames(String rootPath, String currentPath, 
    List<String> classNameList) { 
    File currentFile = new File(currentPath); 
 if (currentFile.isFile()) { 
 // 如果是文件的话,直接将路径名转换为文件名,并加入结果集
        if (Util.isClassFile(currentFile.getName())) { 
	    classNameList.add( 
            Util.replaceFileSeparator( 
            Util.removeClassSuffix( 
            // 只获取文件的名字,并将路径中的反斜杠”/”转换为文件名中的”.”
            // 比如获取文件名为”com.aa.bb.cc”
            Util.getFileNameWithoutRootPath(currentFile, rootPath)))); 
	 } 
 } else { 
 // 如果是文件夹的话,则取所有的子文件,递归处理所有取到的子文件
	 for (File file : currentFile.listFiles()) { 
	    if (file.isFile()) { 
		 if (Util.isClassFile(file.getName())) { 	
		 classNameList.add(Util.replaceFileSeparator(Util.removeClassSuffix 
		 (Util.getFileNameWithoutRootPath(file, rootPath)))); 
	        } 
	    } else { 
		 loadAllClassNames(rootPath, file.getAbsolutePath(), classNameList); 
	    } 
	 } 
    } 
 }

上面我们得到的将是所有一个 List<String> 对象,包含所有的 .class 文件。

如何过滤 Class 文件名

可以自定义一系列的过滤条件,比如对于 package “com.aa.bb.cc”下的所有 JUnit Test 文件都不测试,那么可以写如下的 filter:

清单 4. 对 Class 名字使用过滤条件的示例代码

public static boolean classNameIsInArray(String className) { 
    String filters = "com.aa.bb.cc1.*;com.aa.bb.cc2.*"; 
    String[] filterList = filters.split(";"); 

    if (filters == null || filterList.length  < 1) { 
	 return false; 
    } 
    for (String pattern : filterList) { 
	 if (className.matches(pattern)) { 
		 return true; 
	 } 
    } 
    return false; 
 }

如何过滤 Abstract 类

我们知道一个 JUnit Test 文件绝对不可能是 Abstract 类,因此可以把 Abstract 类从 Class 集合中首先过滤掉。示例代码如下:

清单 5. 过滤 Abstract 类的示例代码

 public static boolean isAbstractClass(Class<?> clazz) { 
	 return (clazz.getModifiers()&Modifier.ABSTRACT) != 0; 
 }

如何过滤 Inner 类

JUnit Test 类中一般来说不允许再定义一个子类,因此对于 Inner class 来说,也是我们的剔除对象。示例代码展示如何找到 Inner 类。

清单 6. 过滤 Inner 类的示例代码

 public static final String INNER_CLASS_CHAR = "$"; 
 public static boolean isInnerClass(String className) { 
	 return className.contains(INNER_CLASS_CHAR); 
 }

如何找到 JUnit3 文件

首先我们来看一个典型的基于 JUnit3 的单元测试程序:

清单 7. 典型 JUnit3 风格的测试代码

 import junit.framework.TestCase; 
 import static org.junit.Assert.*; 
 public class AddOperationTest extends TestCase{ 

      public void setUp() throws Exception { 
      } 

      public void tearDown() throws Exception { 
      } 
      
      // 测试方法必须以 test 开头
      public void testAdd() { 
          int x = 0; 
          int y = 0; 
          AddOperation instance = new AddOperation(); 
          int expResult = 0; 
          int result = instance.add(x, y); 
          assertEquals(expResult, result);          
      } 
 }

我们可以看到上面的单元测试拥有如下特征:

1.继承自 junit.framework.TestCase 类;

2.要测试的方法以 test 开头。

在这里我们只需要知道一个 .class 文件是否是 JUnit3 的测试程序,因此第二条特征暂时用不上,我们用是否继承自 TestCase 类来作为判断标准,代码如下:

清单 8. 找出 JUnit3 风格的 JUnit Test 测试文件的示例代码

 public static boolean isJUnit3TestClass(Class<?> clazz) { 
 // class.isAssignableFrom() 方法可以找到即使是父类的父类的继承关系
 // 因此认为如果输入的子类继承自 JUnit Test3.8 的 TestCase 类,则认为是 JUnit3 风格的 JUnit Test 类对象
    return TestCase.class.isAssignableFrom(clazz); 
 }

如果是继承自 TestCase 这个类,则返回 true,代表是 JUnit3 的单元测试; 否则返回 false;.

如何找到 JUnit4 文件

对于 JUnit4,我们知道它最大的特征是引入了 Annotation 机制,简化了原来的单元测试的用法。我们可以来看下面的例子:

清单 9. 典型 JUnit4 风格的测试代码

 import junit.framework.TestCase; 
 import org.junit.After; 
 import org.junit.Before; 
 import org.junit.Test; 
 import static org.junit.Assert.*; 

 public class AddOperationTest extends TestCase{ 
      @Before 
      public void setUp() throws Exception { 
      } 

      @After 
      public void tearDown() throws Exception { 
      } 

      @Test 
      public void add() { 
          int x = 0; 
          int y = 0; 
          AddOperation instance = new AddOperation(); 
          int expResult = 0; 
          int result = instance.add(x, y); 
          assertEquals(expResult, result);          

      }  
 }

我们可以看到上面的 JUnit4 测试程序拥有如下特征:

1.继承自 junit.framework.TestCase 类;

2.拥有至少一个有 @Test 的注释的测试方法,且方法名称任意

因此对于 JUnit4 的 Class 文件来说,我们需要判断的是它的方法内是否有 @Test Annotation,如果没有的话,就不是一个有效的 JUnit4 测试文件。示例代码如下:

清单 10. 找出 JUnit4 风格的 JUnit Test 测试文件的示例代码

 public static boolean isJUnit4TestClass(Class<?> clazz) { 
 try { 
 for (Method method : clazz.getMethods()) { 
     // 如果在 class 对象所有的方法中发现 @Test 注释,则认为是 JUnit4 风格的 JUnit Test 对象
	 if (method.getAnnotation(Test.class) != null) { 
	    return true; 
	 } 
    } 
 } catch (NoClassDefFoundError ignore) { 
    return false; 
 } 
 return false; 
 }

使用各种过滤条件

前面我们已经得到了一个在本工程集内的所有 Class 文件的集合,现在我们可以使用各种过滤条件对集合进行过滤,示例代码如下:

清单 11. 联合使用各种过滤条件找出需要的 JUnit Test 的示例代码

 for (String className : classesFileNameList) { 
    Class<?> classFromName = null; 
 try { 
     // 从 class 名字转换为 class 对象				
	 classFromName = Class.forName(className); 
    } catch (ClassNotFoundException e) { 
	 // 如果转换失败,则跳过
         continue; 
 } 
 // JUnit Test class 对象不可能是内部 class,所以跳过检测所有的内部 class 
    if (!Util.isInnerClass(className)) { 
	 Class<?> classFromName = Class.forName(className); 
	 if (classFromName.isLocalClass()|| 
            classFromName.isAnonymousClass()) { 
            // JUnit Test class 对象也不可能是 local 或者 Anonymous 对象,跳过
            continue; 
	 } 
	 if (!Util.isAbstractClass(classFromName) && 
       (Util.isJUnit4TestClass(classFromName)|| Util.isJUnit38TestClass(classFromName))) 
	   {                             
        toBeRanTestClassList.add(classFromName); 
	   } 
    } 			
 }

这里我们找到的 toBeRanTestClassList 集合就是我们期望测试的 JUnit Test Class 对象集合。

JUnit 自动执行所有测试

现在我们已经有了自己的 AllJUnitTestRunner,也找到了工程集内所有的 JUnit Test Class 集合。下面要做的就是如何运行找到的 Class 集合。具体代码如下:

清单 12. 我们的期望值 - 最终的 JUnit Test 示例代码

 import org.junit.runner.RunWith; 
 import junit.AllJunitTestRunner; 
 @RunWith(AllJunitTestRunner.class) 
 public class AllJunitTest { 

 }

只需要一个空的 JUnitTest 测试文件,并将 AllJUnitTestRunner 作为这个测试文件的 Runner。那么在运行这个测试程序时,它将调用我们定义的 Runner 去自动运行所有我们期望的 JUnit Test 测试程序。是不是很方便呢?可以说基本达到了我们预期的目的。

改进点

我们知道在 JUnit4 中支持自定义的 Annotation,因此对于我们的各种过滤项,应该可以通过定义新的 Annotation 方式从而在最终的 JUnit Test 程序中任意定义,这样比硬编码在全局单元测试程序模块内更加方便使用。

递归查找整个工程集内所有的 class 文件名会对查找速度产生影响。本人觉得在递归的同时应该可以再次对路径名等进行过滤,避免在不必要的目录内不停的查找,以提高性能。

以上是本人目前想到的 2 个改进点,希望大家踊跃讨论,提高程序的性能及易用性。

总结

本文主要利用了 Class 文件的各种特征及 JUnit3、JUnit4 的特征,及 JUnit4 中可以一次执行多个 JUnit Test 文件的特性,达到一次执行全部工程集内的所有测试文件的目的。目前,在实际项目执行中起到了非常大的作用。对于所有新增的功能点,新增的测试文件,在正式上传到服务器之前都只需要执行一个 JUnit Test 文件,就可以发现是否影响原有功能,增加了程序开发过程的自动性,节约了大量程序开发纠错的时间,提高了产品的质量。




LoadRunner性能测试基础
软件测试结果分析和质量报告
面向对象软件测试技术研究
设计测试用例的四条原则
功能测试中故障模型的建立
性能测试综述
更多...   


性能测试方法与技术
测试过程与团队管理
LoadRunner进行性能测试
WEB应用的软件测试
手机软件测试
白盒测试方法与技术

相关咨询服务
建立软件测试规范
性能评测与调优


某博彩行业 数据库自动化测试
IT服务商 Web安全测试
IT服务商 自动化测试框架
海航股份 单元测试、重构
测试需求分析与测试用例分析
互联网web测试方法与实践
基于Selenium的Web自动化测试
更多...   
 
 
 
 
 
每天2个文档/视频
扫描微信二维码订阅
订阅技术月刊
获得每月300个技术资源
 
 

关于我们 | 联系我们 | 京ICP备10020922号 京公海网安备110108001071号