软件测试论坛 › [软件测试新手上路] › 使用 Jacoco 实现 Android 端手工测试覆盖率统计

悠悠小仙仙 发表于 2017-6-26 10:18:59

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

背景

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

1. 将3个类文件放入项目test文件夹；
https://testerhome.com/uploads/photo/2017/da5ab97b-4b0e-4299-bdb6-50538a4095bb.png!large

具体各个类的代码如下:
FinishListener:
package 你的包名;
public interface FinishListener {
    void onActivityFinished();
    void dumpIntermediateCoverage(String filePath);
}InstrumentedActivity：
package你的包名;
import 你的启动的activity;
import android.util.Log;

public class InstrumentedActivity extends MainActivity {
    public static String TAG = "InstrumentedActivity";

    private你的包名.test.FinishListener mListener;

    public void setFinishListener(FinishListener listener) {
      mListener = listener;
    }


    @Override
    public void onDestroy() {
      Log.d(TAG + ".InstrumentedActivity", "onDestroy()");
      super.finish();
      if (mListener != null) {
            mListener.onActivityFinished();
      }
    }

} JacocoInstrumentation:
package 包名.test;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import android.app.Activity;
import android.app.Instrumentation;
import android.content.Intent;
import android.os.Bundle;
import android.os.Looper;
import android.util.Log;

public class JacocoInstrumentation extends Instrumentation implements
      FinishListener {
    public static String TAG = "JacocoInstrumentation:";
    private static String DEFAULT_COVERAGE_FILE_PATH = "/mnt/sdcard/coverage.ec";

    private final Bundle mResults = new Bundle();

    private Intent mIntent;
    private static final boolean LOGD = true;

    private boolean mCoverage = true;

    private String mCoverageFilePath;


    /**
   * Constructor
   */
    public JacocoInstrumentation() {

    }

    @Override
    public void onCreate(Bundle arguments) {
      Log.d(TAG, "onCreate(" + arguments + ")");
      super.onCreate(arguments);
      DEFAULT_COVERAGE_FILE_PATH = getContext().getFilesDir().getPath().toString() + "/coverage.ec";

      File file = new File(DEFAULT_COVERAGE_FILE_PATH);
      if (!file.exists()) {
            try {
                file.createNewFile();
            } catch (IOException e) {
                Log.d(TAG, "异常 : " + e);
                e.printStackTrace();
            }
      }
      if (arguments != null) {
            mCoverageFilePath = arguments.getString("coverageFile");
      }

      mIntent = new Intent(getTargetContext(), InstrumentedActivity.class);
      mIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
      start();
    }

    @Override
    public void onStart() {
      if (LOGD)
            Log.d(TAG, "onStart()");
      super.onStart();

      Looper.prepare();
      InstrumentedActivity activity = (InstrumentedActivity) startActivitySync(mIntent);
      activity.setFinishListener(this);
    }

    private void generateCoverageReport() {
      Log.d(TAG, "generateCoverageReport():" + getCoverageFilePath());
      OutputStream out = null;
      try {
            out = new FileOutputStream(getCoverageFilePath(), false);
            Object agent = Class.forName("org.jacoco.agent.rt.RT")
                  .getMethod("getAgent")
                  .invoke(null);

            out.write((byte[]) agent.getClass().getMethod("getExecutionData", boolean.class)
                  .invoke(agent, false));
      } catch (Exception e) {
            Log.d(TAG, e.toString(), e);
      } finally {
            if (out != null) {
                try {
                  out.close();
                } catch (IOException e) {
                  e.printStackTrace();
                }
            }
      }
    }

    private String getCoverageFilePath() {
      if (mCoverageFilePath == null) {
            return DEFAULT_COVERAGE_FILE_PATH;
      } else {
            return mCoverageFilePath;
      }
    }

    private boolean setCoverageFilePath(String filePath){
      if(filePath != null && filePath.length() > 0) {
            mCoverageFilePath = filePath;
            return true;
      }
      return false;
    }


    @Override
    public void onActivityFinished() {
      if (LOGD)
            Log.d(TAG, "onActivityFinished()");
      if (mCoverage) {
            generateCoverageReport();
      }
      finish(Activity.RESULT_OK, mResults);
    }

    @Override
    public void dumpIntermediateCoverage(String filePath){
      // TODO Auto-generated method stub
      if(LOGD){
            Log.d(TAG,"Intermidate Dump Called with file name :"+ filePath);
      }
      if(mCoverage){
            if(!setCoverageFilePath(filePath)){
                if(LOGD){
                  Log.d(TAG,"Unable to set the given file path:"+filePath+" as dump target.");
                }
            }
            generateCoverageReport();
            setCoverageFilePath(DEFAULT_COVERAGE_FILE_PATH);
      }
    }

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

添加的代码内容:
apply plugin: 'jacoco'

jacoco {
    toolVersion = "0.7.9"
}
android {
    buildTypes {
            debug { testCoverageEnabled = true
    /**打开覆盖率统计开关/
      }
}

def coverageSourceDirs = [
      '../app/src/main/java'
]

task jacocoTestReport(type: JacocoReport) {
    group = "Reporting"
    description = "Generate Jacoco coverage reports after running tests."
    reports {
      xml.enabled = true
      html.enabled = true
    }
    classDirectories = fileTree(
            dir: './build/intermediates/classes/debug',
            excludes: ['**/R*.class',
                     '**/*$InjectAdapter.class',
                     '**/*$ModuleAdapter.class',
                     '**/*$ViewInjector*.class'
            ])
    sourceDirectories = files(coverageSourceDirs)
    executionData = files("$buildDir/outputs/code-coverage/connected/flavors/coverage.ec")

    doFirst {
      new File("$buildDir/intermediates/classes/").eachFileRecurse { file ->
            if (file.name.contains('

)) {
                file.renameTo(file.path.replace('

, '

))
            }
      }
    }
}
dependencies {
      compile fileTree(dir: 'libs', include: ['*.jar'])
}

悠悠小仙仙 发表于 2017-6-26 10:21:07

3. 修改AndroidManifest.xml文件
添加以及修改部分:<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
<activity android:label="InstrumentationActivity"    android:name="包名.test.InstrumentedActivity" />
<instrumentation
    android:handleProfiling="true"
    android:label="CoverageInstrumentation"
    android:name="包名.test.JacocoInstrumentation"
    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报告
https://testerhome.com/uploads/photo/2017/f7f36654-8284-49d5-8c07-7461d1d18963.png!large
打开index.html，就可以看到具体的覆盖率数据了
https://testerhome.com/uploads/photo/2017/768f883d-9dd3-4ebe-a70d-bfbcc247a015.png!large

jingzizx 发表于 2017-6-26 13:18:01

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

八戒你干嘛 发表于 2017-6-26 15:30:32

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

草帽路飞UU 发表于 2017-6-26 15:31:28

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

乐哈哈yoyo 发表于 2017-6-26 15:32:16

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

悠悠小仙仙 发表于 2017-6-26 15:32:52

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

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

查看完整版本: 使用 Jacoco 实现 Android 端手工测试覆盖率统计