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

手工测试覆盖

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

FinishListener

package 包名.test;

public interface FinishListener {
    void onActivityFinished();
    void dumpIntermediateCoverage(String filePath);
}

InstrumentedActivity

package 包名.test;
import 包名.activity.LoginActivity;



import android.util.Log;

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

    private 包名.test.FinishListener mListener;

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


    @Override
    public void onDestroy() {
        super.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 文件

apply plugin: 'jacoco'
jacoco {
    toolVersion = "0.7.9"
}
buildTypes {
        debug {
            testCoverageEnabled = true
            /**打开覆盖率统计开关**/
        }
        }
dependencies {
	implementation('org.jacoco:org.jacoco.report:0.8.4') {
	exclude group: 'org.jacoco', module: 'org.jacoco.core'
}
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.setFrom(fileTree(
            dir: './build/intermediates/javac/debug',
            excludes: ['**/R*.class',
                       '**/*$InjectAdapter.class',
                       '**/*$ModuleAdapter.class',
                       '**/*$ViewInjector*.class'
            ]))
    sourceDirectories.setFrom(files(coverageSourceDirs))
    executionData.setFrom(files("$buildDir/outputs/code-coverage/connected/coverage.ec"))

    doFirst {
        new File("$buildDir/intermediates/javac/").eachFileRecurse { file ->
            if (file.name.contains('$$')) {
                file.renameTo(file.path.replace('$$', '$'))
            }
        }
    }
}

3. 修改 AndroidManifest.xml 文件

    <instrumentation
        android:handleProfiling="true"
        android:name="包名.test.JacocoInstrumentation"
        android:functionalTest="false"
        android:label="tihis test"
        android:targetPackage="包名">
    </instrumentation>
   <application
  <activity android:label="InstrumentationActivity"    android:name="包名.test.InstrumentedActivity" />
    </application>

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

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

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

导出到路径 “…\app\build\outputs\code-coverage\connected”

7. 查看覆盖率 html 报告

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