背景

前段时间在研究手工测试覆盖率问题，尝试将结果记录下来。有什么问题欢迎同学指正. : )

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

实现

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

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

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'])
}

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 报告

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

遗留问题:
Jacoco 报告生成中文乱码问题 (已解决，感谢@chenhengjie123)
参考文章:
JaCoCo-原理篇
Android 手工测试代码覆盖率增强版