Android自动化测试生成单元测试结果报告

最新推荐文章于 2023-05-18 11:40:35 发布
最新推荐文章于 2023-05-18 11:40:35 发布
阅读量717 收藏
点赞数 1
分类专栏： android

转自：http://blog.csdn.net/hunterno4/article/details/14485663


使用robotium进行Android应用进行自动化测试，之前用TMTS框架，但收集到的单元测试结果常常会少掉一些用例集。。穷则思变，Android的测试框架主要是通过InstrumentationTestRunner对被测应用进行控制与执行，因此可以对InstrumentationTestRunner进行扩展以完成测试结果收集，然后通过jenkins的Publish JUnit test result report插件得到结果报告。

1.新建一个java package，新建一个java类

源码来自开源项目：https://code.google.com/p/nbandroid-utils/

源码中生成的TEST-all.xml结果文件位于/data/data/com.example/files目录下，要导出结果文件的话，需要手机拥有root权限，比较麻烦，因此下面修改了文件存放路径，有SD卡则文件位于SD卡的/robotium目录下

[java]  view plain copy
  1. package com.example.test.instrumentation;  
  2.   
  3. import java.io.File;  
  4. import java.io.FileWriter;  
  5. import java.io.IOException;  
  6. import java.io.Writer;  
  7.   
  8. import org.xmlpull.v1.XmlPullParserFactory;  
  9. import org.xmlpull.v1.XmlSerializer;  
  10.   
  11. import android.content.Context;  
  12. import android.os.Bundle;  
  13. import android.os.Environment;  
  14.   
  15. /** 
  16.  * This test runner creates a TEST-all.xml in the files directory of the application under test. The output is compatible with that of the junitreport ant task, the format 
  17.  * that is understood by Hudson. Currently this implementation does not implement the all aspects of the junitreport format, but enough for Hudson to parse the test results.  
  18.  */  
  19. public class InstrumentationTestRunner extends android.test.InstrumentationTestRunner {  
  20.     private Writer mWriter;  
  21.     private XmlSerializer mTestSuiteSerializer;  
  22.     private long mTestStarted;  
  23.     private static final String JUNIT_XML_FILE = "TEST-all.xml";  
  24.       
  25.       
  26.     @Override  
  27.     public void onStart() {  
  28.         try{  
  29.             File fileRobo = new File(getTestResultDir(getTargetContext()));  
  30.             if(!fileRobo.exists()){  
  31.                 fileRobo.mkdir();  
  32.             }  
  33.             if(isSDCardAvaliable()){      
  34.                 File resultFile = new File(getTestResultDir(getTargetContext()),JUNIT_XML_FILE);  
  35.                 startJUnitOutput(new FileWriter(resultFile));  
  36.             }else{  
  37.                 startJUnitOutput(new FileWriter(new File(getTargetContext().getFilesDir(), JUNIT_XML_FILE)));  
  38.             }              
  39.         }  
  40.         catch(IOException e){  
  41.             throw new RuntimeException(e);  
  42.         }  
  43.         super.onStart();  
  44.     }  
  45.   
  46.     void startJUnitOutput(Writer writer) {  
  47.         try {  
  48.             mWriter = writer;  
  49.             mTestSuiteSerializer = newSerializer(mWriter);  
  50.             mTestSuiteSerializer.startDocument(null, null);  
  51.             mTestSuiteSerializer.startTag(null, "testsuites");  
  52.             mTestSuiteSerializer.startTag(null, "testsuite");  
  53.         } catch (Exception e) {  
  54.             throw new RuntimeException(e);  
  55.         }  
  56.     }  
  57.       
  58.     /** 
  59.      * 判断SD卡是否存在 
  60.      * @return 
  61.      */  
  62.     private boolean isSDCardAvaliable(){  
  63.         return Environment.getExternalStorageState()  
  64.                     .equals(Environment.MEDIA_MOUNTED);   
  65.     }  
  66.       
  67.     /** 
  68.      * 获取测试结果报告文件所在的路径 
  69.      * @param context  被测工程的context 
  70.      * @return  返回测试结果报告文件所在的路径 
  71.      */  
  72.     private String getTestResultDir(Context context){  
  73.         String packageName = "/" + "robotium";  
  74.         String filepath = context.getCacheDir().getPath() + packageName;  
  75.           
  76.         if(android.os.Build.VERSION.SDK_INT < 8){  
  77.             if(isSDCardAvaliable()){  
  78.                 filepath = Environment.getExternalStorageDirectory().getAbsolutePath()+ packageName;  
  79.             }  
  80.         }else{  
  81.             if(isSDCardAvaliable()){  
  82.                 filepath = Environment.getExternalStorageDirectory().getAbsolutePath()+ packageName;  
  83.             }  
  84.         }         
  85.         return filepath;  
  86.     }  
  87.       
  88.     private XmlSerializer newSerializer(Writer writer) {  
  89.         try {  
  90.             XmlPullParserFactory pf = XmlPullParserFactory.newInstance();  
  91.             XmlSerializer serializer = pf.newSerializer();  
  92.             serializer.setOutput(writer);  
  93.             return serializer;  
  94.         } catch (Exception e) {  
  95.             throw new RuntimeException(e);  
  96.         }          
  97.     }  
  98.       
  99.     @Override  
  100.     public void sendStatus(int resultCode, Bundle results) {  
  101.         super.sendStatus(resultCode, results);  
  102.         switch (resultCode) {  
  103.             case REPORT_VALUE_RESULT_ERROR:  
  104.             case REPORT_VALUE_RESULT_FAILURE:  
  105.             case REPORT_VALUE_RESULT_OK:  
  106.             try {  
  107.                 recordTestResult(resultCode, results);  
  108.                 } catch (IOException e) {  
  109.                     throw new RuntimeException(e);  
  110.                 }  
  111.                 break;  
  112.             case REPORT_VALUE_RESULT_START:  
  113.                 recordTestStart(results);  
  114.             default:  
  115.                 break;  
  116.         }  
  117.     }  
  118.       
  119.     void recordTestStart(Bundle results) {  
  120.         mTestStarted = System.currentTimeMillis();  
  121.     }  
  122.   
  123.     void recordTestResult(int resultCode, Bundle results) throws IOException {  
  124.         float time = (System.currentTimeMillis() - mTestStarted) / 1000.0f;  
  125.         String className = results.getString(REPORT_KEY_NAME_CLASS);  
  126.         String testMethod = results.getString(REPORT_KEY_NAME_TEST);  
  127.         String stack = results.getString(REPORT_KEY_STACK);  
  128.         int current = results.getInt(REPORT_KEY_NUM_CURRENT);  
  129.         int total = results.getInt(REPORT_KEY_NUM_TOTAL);  
  130.           
  131.         mTestSuiteSerializer.startTag(null, "testcase");  
  132.         mTestSuiteSerializer.attribute(null, "classname", className);  
  133.         mTestSuiteSerializer.attribute(null, "name", testMethod);  
  134.           
  135.         if (resultCode != REPORT_VALUE_RESULT_OK) {  
  136.             mTestSuiteSerializer.startTag(null, "failure");  
  137.             if (stack != null) {  
  138.                 String reason = stack.substring(0, stack.indexOf('\n'));  
  139.                 String message = "";  
  140.                 int index = reason.indexOf(':');  
  141.                 if (index > -1) {  
  142.                     message = reason.substring(index+1);  
  143.                     reason = reason.substring(0, index);  
  144.                 }  
  145.                 mTestSuiteSerializer.attribute(null, "message", message);  
  146.                 mTestSuiteSerializer.attribute(null, "type", reason);  
  147.                 mTestSuiteSerializer.text(stack);  
  148.             }  
  149.             mTestSuiteSerializer.endTag(null, "failure");  
  150.         } else {  
  151.             mTestSuiteSerializer.attribute(null, "time", String.format("%.3f", time));  
  152.         }  
  153.         mTestSuiteSerializer.endTag(null, "testcase");          
  154.         if (current == total) {  
  155.             mTestSuiteSerializer.startTag(null, "system-out");  
  156.             mTestSuiteSerializer.endTag(null, "system-out");  
  157.             mTestSuiteSerializer.startTag(null, "system-err");  
  158.             mTestSuiteSerializer.endTag(null, "system-err");  
  159.             mTestSuiteSerializer.endTag(null, "testsuite");  
  160.             mTestSuiteSerializer.flush();  
  161.         }  
  162.     }  
  163.   
  164.     @Override  
  165.     public void finish(int resultCode, Bundle results) {  
  166.         endTestSuites();  
  167.         super.finish(resultCode, results);  
  168.     }  
  169.   
  170.     void endTestSuites() {  
  171.         try {  
  172.             mTestSuiteSerializer.endTag(null, "testsuites");  
  173.             mTestSuiteSerializer.endDocument();  
  174.             mTestSuiteSerializer.flush();  
  175.             mWriter.flush();  
  176.             mWriter.close();  
  177.         } catch (IOException e) {  
  178.             throw new RuntimeException(e);  
  179.         }  
  180.     }  
  181. }  

2.修改AndroidManifest.xml文件

将原来的：

[html]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. <instrumentation  
  2.         android:name="android.test.InstrumentationTestRunner"  
  3.         android:targetPackage="com.example" />  
修改为：

[html]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. <instrumentation  
  2.         android:name="com.example.test.instrumentation.InstrumentationTestRunner"  
  3.         android:targetPackage="com.example" />  


3.修改Run Configurations
右键测试工程>Run as >Run Configurations
在Test栏中，勾选Run all tests in the selected project,or package
这样每次在Eclipse中运行时才会使用新的InstrumentationTestRunner
在Instrumentation runner处下拉选择新写的InstrumentationTestRunner
点击Apply完成设置

4.命令行下运行测试用例

Running all tests: adb shell am instrument -w com.android.foo/com.example.test.instrumentation.InstrumentationTestRunner

Running a single testcase: adb shell am instrument -w -e class com.android.foo.FooTest com.android.foo/com.example.test.instrumentation.InstrumentationTestRunner 

Running multiple tests: adb shell am instrument -w -e class com.android.foo.FooTest,com.android.foo.TooTest com.android.foo/com.example.test.instrumentation.InstrumentationTestRunner 

命令行下运行测试用例与平时一样，只要将原来的InstrumentationTestRunner换成新的InstrumentationTestRunner就行，

需要注意的是，由于每次命令行执行完毕，都会覆盖原有的TEST-all.xml文件，即如果采用Running a single testcase方式运行多个测试用例集，则最后结果只会记录最后一个用例集。

因此可以使用传参数的形式分别命名输出的文件名

[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1.   
[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. private static final String OUT_FILE_ARG = "outfile";  
[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1.   
[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. @Override  
  2. public void onCreate(Bundle arguments) {  
  3. if ( arguments != null ) {  
  4. mOutFileName = arguments.getString(OUT_FILE_ARG);  
  5. }  
  6. if ( mOutFileName == null ) {  
  7. mOutFileName = OUT_FILE_DEFAULT;  
  8. }  
  9. super.onCreate(arguments);  
  10. }  

此时运行命令换为adb shell am instrument -w -e outfile "TEST-***.xml" -e class com.android.foo.FooTest,com.android.foo.TooTest com.android.foo/com.example.test.instrumentation.InstrumentationTestRunner


5.运行完成后将手机中的文件导出
adb -s $ANDROID_AVD_DEVICE pull /mnt/sdcard/rototium/TEST-all.xml

其中$ANDROID_AVD_DEVICE为参数化的手机序列号


6.在jenkins中任务构建完成后即可使用Publish JUnit test result report插件分析得出单元测试报告了
fanjieshanghai
关注
专栏目录
Android 自动化单元测试
南柯好萌的博客
08-09 976
Android 自动化单元测试
Android单元测试学习总结
最新发布
2401_86968743的博客
09-07 1391
Android单元测试主要分为以下两种(Junit Test)， 本地单元测试是纯java代码的测试，只运行在本地电脑的JVM环境上，不依赖于Android框架的任何api, 因此执行速度快，效率较高，但是无法测试Android相关的代码。(Android Test)，是针对Android相关代码的测试，需要运行在真机设备或模拟器上，运行速度较慢，但是可以测试UI的交互以及对设备信息的访问，得到接近真实的测试结果。在Android Studio中新建一个项目的时候，app的gradle。
android 自动化测试学习总结
开发简记
12-29 1658
年底总是有些乱乱的感觉，项目有些空闲，所有上班时间必须思考好今天干什么，否则一天都会很痛苦……        最近几天了解了下android自动化测试相关的知识。        以下对几种测试工具的介绍摘自网络：        现在，已经有大量的Android自动化测试架构或工具可供我们使用，其中包括：Activity Instrumentation,MonkeyRunner，Robot
Android单元测试总结
天花板的随笔
06-24 4038
一、概述： 使用AndroidTest，我们可以获取到Android运行的环境，并且通过在测试文件中实例化我们需要测试的类，然后自己模拟一些参数去调用实例中的方法，来达到测试代码的目的。一个AndroidTest文件，就相当于一个运行进程一样，可以在真机上运行，并且可以把测试跑后的结果统计出来，作为研发自测重要的一个根据。 二、创建测试单元 我们可以针对我们代码中那些很关键的控制性类创建一个测试单元，这样创建的测试单元就可以包含很多内容。创建的方式也很简单，在需要创建的类边上进入提示，如下： 点击Crea
python+appium+Android 自动化测试框架
03-31
Python结合Appium与Android自动化测试框架的构建是一个高效且强大的测试解决方案，尤其在移动应用测试领域。本框架的核心是利用Python作为编程语言，Appium作为跨平台的自动化测试工具，以及Android SDK为运行环境，...
web版本自动化测试报告
01-11
本报告主要聚焦于"web版本自动化测试报告"，旨在详细介绍如何利用自动化工具和框架对Web应用程序进行有效的测试，以及测试结果的分析和总结。 一、自动化测试的重要性 1. 提升效率：相对于手动测试，自动化测试可以...
Android 自动化测试框架
12-17
本文将详细介绍几个常用的Android自动化测试框架，包括Monkey、MonkeyRunner、UIAutomator、Robotium和Appium。 1. **Monkey** Monkey是Android SDK自带的一个命令行工具，主要用于压力测试。它通过向系统发送随机...
AndroidStudio单元测试⽣成测试报告以及⽣成单元测试代码覆盖率报告
白龙的博客
06-21 1159
单元测试覆盖率统计
单元测试(基于安卓项目)总结
分享+记录
05-18 1174
负责公司的单元测试体系的搭建，大约有一两个月的时间了，从最初的框架的调研，到中期全员的培训，以及后期对几十个项目单元测试的引入和推进，也算是对安卓的单元测试有了一些初步的收获以及一些新的认知，因此写下这篇文章来进行一个记录和总结。以下的所有内容纯属个人观点，欢迎讨论。
使用android-junit-report.jar导出单元测试报告
weixin_33941350的博客
05-05 116
2019独角兽企业重金招聘Python工程师标准>>> ...
intellij ideal下用spring test + junit进行单元测试并生成代码覆盖率报告
secoler的博客
02-28 2669
通过Spring Test + junit可以自动注入bean，抛开容器进行单元测试。步骤：（以下步骤均在intellj ideal下操作）1、新建test目录，设置为Test Sources Root2、在test目录下新建config目录，将配置文件(.xml .properties)放到该目录下备注：biz-context.xml中与容器相关的配置需要删除，jdbc之前是由weblogi...
Android自动化测试工具综述与应用指南
本文是一篇关于Android自动化测试的详细总结，旨在介绍Android平台上的自动化测试工具及其使用方法。首先，文章从自动化测试的基本概念出发，阐述了自动化测试的定义，即通过机器执行代替人工测试，以提高测试效率。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值