使用 Jacoco 实现 Android 端手工测试覆盖率统计

悠悠小仙仙

背景

前段时间在研究手工测试覆盖率问题，尝试将结果记录下来。有什么问题欢迎同学指正. : )
由于现在单元测试在我们这小公司无法推行，且为了解决新功能测试以及回归测试在手工测试的情况下，即便用例再为详尽，也会存在遗漏的用例。通过统计手工测试覆盖率的数据，可以及时的完善用例。 经过了解准备使用Jacoco完成这个需求.Jacoco是Java Code Coverage的缩写，在统计完成Android代码覆盖率的时候使用的是Jacoco的离线插桩方式，在测试前先对文件进行插桩，在手工测试过程中会生成动态覆盖信息，最后统一对覆盖率进行处理，并生成报告；通过了解现在实现Android覆盖率的方法主要有两种方式，一是通过activity退出的时候添加覆盖率的统计，但是这种情况会修改app的源代码。另外一种是使用的是Android测试框架Instrumentation。这次需求的实现使用的是Instrumentation.。
实现

1. 将3个类文件放入项目test文件夹；


具体各个类的代码如下:
FinishListener:

1. package 你的包名;
   
2. public interface FinishListener {
   
3.     void onActivityFinished();
   
4.     void dumpIntermediateCoverage(String filePath);
   
5. }

复制代码

InstrumentedActivity：

1. package你的包名;
   
2. import 你的启动的activity;
   
3. import android.util.Log;
   
4. 
   
5. public class InstrumentedActivity extends MainActivity {
   
6.     public static String TAG = "InstrumentedActivity";
   
7. 
   
8.     private你的包名.test.FinishListener mListener;
   
9. 
   
10.     public void setFinishListener(FinishListener listener) {
    
11.         mListener = listener;
    
12.     }
    
13. 
    
14. 
    
15.     @Override
    
16.     public void onDestroy() {
    
17.         Log.d(TAG + ".InstrumentedActivity", "onDestroy()");
    
18.         super.finish();
    
19.         if (mListener != null) {
    
20.             mListener.onActivityFinished();
    
21.         }
    
22.     }
    
23. 
    
24. }

复制代码

JacocoInstrumentation:

1. package 包名.test;
   
2. import java.io.File;
   
3. import java.io.FileOutputStream;
   
4. import java.io.IOException;
   
5. import java.io.OutputStream;
   
6. import android.app.Activity;
   
7. import android.app.Instrumentation;
   
8. import android.content.Intent;
   
9. import android.os.Bundle;
   
10. import android.os.Looper;
    
11. import android.util.Log;
    
12. 
    
13. public class JacocoInstrumentation extends Instrumentation implements
    
14.         FinishListener {
    
15.     public static String TAG = "JacocoInstrumentation:";
    
16.     private static String DEFAULT_COVERAGE_FILE_PATH = "/mnt/sdcard/coverage.ec";
    
17. 
    
18.     private final Bundle mResults = new Bundle();
    
19. 
    
20.     private Intent mIntent;
    
21.     private static final boolean LOGD = true;
    
22. 
    
23.     private boolean mCoverage = true;
    
24. 
    
25.     private String mCoverageFilePath;
    
26. 
    
27. 
    
28.     /**
    
29.      * Constructor
    
30.      */
    
31.     public JacocoInstrumentation() {
    
32. 
    
33.     }
    
34. 
    
35.     @Override
    
36.     public void onCreate(Bundle arguments) {
    
37.         Log.d(TAG, "onCreate(" + arguments + ")");
    
38.         super.onCreate(arguments);
    
39.         DEFAULT_COVERAGE_FILE_PATH = getContext().getFilesDir().getPath().toString() + "/coverage.ec";
    
40. 
    
41.         File file = new File(DEFAULT_COVERAGE_FILE_PATH);
    
42.         if (!file.exists()) {
    
43.             try {
    
44.                 file.createNewFile();
    
45.             } catch (IOException e) {
    
46.                 Log.d(TAG, "异常 : " + e);
    
47.                 e.printStackTrace();
    
48.             }
    
49.         }
    
50.         if (arguments != null) {
    
51.             mCoverageFilePath = arguments.getString("coverageFile");
    
52.         }
    
53. 
    
54.         mIntent = new Intent(getTargetContext(), InstrumentedActivity.class);
    
55.         mIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
    
56.         start();
    
57.     }
    
58. 
    
59.     @Override
    
60.     public void onStart() {
    
61.         if (LOGD)
    
62.             Log.d(TAG, "onStart()");
    
63.         super.onStart();
    
64. 
    
65.         Looper.prepare();
    
66.         InstrumentedActivity activity = (InstrumentedActivity) startActivitySync(mIntent);
    
67.         activity.setFinishListener(this);
    
68.     }
    
69. 
    
70.     private void generateCoverageReport() {
    
71.         Log.d(TAG, "generateCoverageReport():" + getCoverageFilePath());
    
72.         OutputStream out = null;
    
73.         try {
    
74.             out = new FileOutputStream(getCoverageFilePath(), false);
    
75.             Object agent = Class.forName("org.jacoco.agent.rt.RT")
    
76.                     .getMethod("getAgent")
    
77.                     .invoke(null);
    
78. 
    
79.             out.write((byte[]) agent.getClass().getMethod("getExecutionData", boolean.class)
    
80.                     .invoke(agent, false));
    
81.         } catch (Exception e) {
    
82.             Log.d(TAG, e.toString(), e);
    
83.         } finally {
    
84.             if (out != null) {
    
85.                 try {
    
86.                     out.close();
    
87.                 } catch (IOException e) {
    
88.                     e.printStackTrace();
    
89.                 }
    
90.             }
    
91.         }
    
92.     }
    
93. 
    
94.     private String getCoverageFilePath() {
    
95.         if (mCoverageFilePath == null) {
    
96.             return DEFAULT_COVERAGE_FILE_PATH;
    
97.         } else {
    
98.             return mCoverageFilePath;
    
99.         }
    
100.     }
     
101. 
     
102.     private boolean setCoverageFilePath(String filePath){
     
103.         if(filePath != null && filePath.length() > 0) {
     
104.             mCoverageFilePath = filePath;
     
105.             return true;
     
106.         }
     
107.         return false;
     
108.     }
     
109. 
     
110. 
     
111.     @Override
     
112.     public void onActivityFinished() {
     
113.         if (LOGD)
     
114.             Log.d(TAG, "onActivityFinished()");
     
115.         if (mCoverage) {
     
116.             generateCoverageReport();
     
117.         }
     
118.         finish(Activity.RESULT_OK, mResults);
     
119.     }
     
120. 
     
121.     @Override
     
122.     public void dumpIntermediateCoverage(String filePath){
     
123.         // TODO Auto-generated method stub
     
124.         if(LOGD){
     
125.             Log.d(TAG,"Intermidate Dump Called with file name :"+ filePath);
     
126.         }
     
127.         if(mCoverage){
     
128.             if(!setCoverageFilePath(filePath)){
     
129.                 if(LOGD){
     
130.                     Log.d(TAG,"Unable to set the given file path:"+filePath+" as dump target.");
     
131.                 }
     
132.             }
     
133.             generateCoverageReport();
     
134.             setCoverageFilePath(DEFAULT_COVERAGE_FILE_PATH);
     
135.         }
     
136.     }
     
137. 
     
138. }

复制代码

2. 修改build.gradle文件
增加Jacoco插件，打开覆盖率统计开关，生成日志报告.

添加的代码内容:

1. apply plugin: 'jacoco'
   
2. 
   
3. jacoco {
   
4.     toolVersion = "0.7.9"
   
5. }
   
6. android {
   
7.     buildTypes {
   
8.             debug { testCoverageEnabled = true
   
9.     /**打开覆盖率统计开关/
   
10.         }
    
11. }
    
12. 
    
13. def coverageSourceDirs = [
    
14.         '../app/src/main/java'
    
15. ]
    
16. 
    
17. task jacocoTestReport(type: JacocoReport) {
    
18.     group = "Reporting"
    
19.     description = "Generate Jacoco coverage reports after running tests."
    
20.     reports {
    
21.         xml.enabled = true
    
22.         html.enabled = true
    
23.     }
    
24.     classDirectories = fileTree(
    
25.             dir: './build/intermediates/classes/debug',
    
26.             excludes: ['**/R*.class',
    
27.                        '**/*$InjectAdapter.class',
    
28.                        '**/*$ModuleAdapter.class',
    
29.                        '**/*$ViewInjector*.class'
    
30.             ])
    
31.     sourceDirectories = files(coverageSourceDirs)
    
32.     executionData = files("$buildDir/outputs/code-coverage/connected/flavors/coverage.ec")
    
33. 
    
34.     doFirst {
    
35.         new File("$buildDir/intermediates/classes/").eachFileRecurse { file ->
    
36.             if (file.name.contains('
    
37. 
    
38. )) {
    
39.                 file.renameTo(file.path.replace('
    
40. 
    
41. , '
    
42. 
    
43. ))
    
44.             }
    
45.         }
    
46.     }
    
47. }
    
48. dependencies {
    
49.         compile fileTree(dir: 'libs', include: ['*.jar'])
    
50. }

复制代码

悠悠小仙仙

乐哈哈yoyo 发表于 2017-6-26 15:32
测试执行过程中会覆盖安装多次APK，请问覆盖率文件会被覆盖吗？

如果怕被覆盖可以设置DEFAULT_COVERAGE_FILE_PATH 保存的路径。因为现在的文件是存到apkfile里面的。如果删除apk，文件也会被删除。

乐哈哈yoyo

测试执行过程中会覆盖安装多次APK，请问覆盖率文件会被覆盖吗？

草帽路飞UU

赞，不过各个方法一点注释没有，小白表示完全不知道为啥这么写的

八戒你干嘛

感觉还是修改源码更方便，可以不用考虑启动方式

jingzizx

大赞一个!
目前确实如果有这种方式，统计工作会得到很大的缓解

悠悠小仙仙

3. 修改AndroidManifest.xml文件
添加以及修改部分:

1. <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
   
2. <activity android:label="InstrumentationActivity"    android:name="包名.test.InstrumentedActivity" />
   
3. <instrumentation
   
4.     android:handleProfiling="true"
   
5.     android:label="CoverageInstrumentation"
   
6.     android:name="包名.test.JacocoInstrumentation"
   
7.     android:targetPackage="包名"/>

复制代码

4. 我们需要通过adb shell am instrument 包名/包名.test.JacocoInstrumentation 启动app;

5. 进行app手工测试，测试完成后退出App，覆盖率文件会保存在手机/data/data/yourPackageName/files/coverage.ec目录

6. 导出coverage.ec使用gradle jacocoTestReport分析覆盖率文件并生成html报告

7. 查看覆盖率html报告

app\build\reports\jacoco\jacocoTestReport\html目录下看到html报告

打开index.html，就可以看到具体的覆盖率数据了