基于JaCoCo的Android测试覆盖率统计（二）

本文章是我上一篇文章的升级版本，详见地址：https://www.cnblogs.com/xiaoluosun/p/7234606.html

为什么要做这个？

1. 辛辛苦苦写了几百条测试用例，想知道这些用例的覆盖率能达到多少？
2. 勤勤恳恳验证好几天，也没啥bug了，可不可以上线？有没有漏测的功能点？
3. 多人协同下测试，想了解团队每个人的测试进度、已覆盖功能点、验证过的设备机型和手机系统等等。

数据采集和上报

既然要做覆盖率分析，数据的采集非常重要，除了JaCoCo生成的.ec文件之外，还需要拿到额外一些信息，如被测设备系统版本、系统机型、App的版本、用户唯一标识（UID）、被测环境等等。

什么时候触发数据的上报呢？这个机制很重要，如果设计的不合理，覆盖率数据可能会有问题。

最早使用的上报策略是：加在监听设备按键的位置，如果点击设备back键或者home键把App置于后台，则上报覆盖率数据。
这种设计肯定是会有问题的，因为有些时候手机设备用完就扔那了，根本没有置于后台，第二天可能才会继续使用，这时候上报的数据就变成了第二天的。还可能用完之后杀死了App，根据就不会上报，覆盖率数据造成丢失；

所以优化后的上报策略是：定时上报，每一分钟上报一次，只要App进程活着就会上报。
那怎么解决用完就杀死App的问题呢？解决办法是App重新启动后查找ec文件目录，如果有上次的记录就上报，这样就不会丢覆盖率数据了。

生成覆盖率文件

/**
 * Created by sun on 17/7/4.
 */

public class JacocoUtils {
    static String TAG = "JacocoUtils";

    //ec文件的路径
    private static String DEFAULT_COVERAGE_FILE_PATH = "/mnt/sdcard/coverage.ec";

    /**
     * 生成ec文件
     *
     * @param isNew 是否重新创建ec文件
     */
    public static void generateEcFile(boolean isNew) {
//        String DEFAULT_COVERAGE_FILE_PATH = NLog.getContext().getFilesDir().getPath().toString() + "/coverage.ec";
        Log.d(TAG, "生成覆盖率文件: " + DEFAULT_COVERAGE_FILE_PATH);
        OutputStream out = null;
        File mCoverageFilePath = new File(DEFAULT_COVERAGE_FILE_PATH);
        try {
            if (isNew && mCoverageFilePath.exists()) {
                Log.d(TAG, "JacocoUtils_generateEcFile: 清除旧的ec文件");
                mCoverageFilePath.delete();
            }
            if (!mCoverageFilePath.exists()) {
                mCoverageFilePath.createNewFile();
            }
            out = new FileOutputStream(mCoverageFilePath.getPath(), true);

            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));

            // ec文件自动上报到服务器
            UploadService uploadService = new UploadService(mCoverageFilePath);
            uploadService.start();
        } catch (Exception e) {
            Log.e(TAG, "generateEcFile: " + e.getMessage());
        } finally {
            if (out == null)
                return;
            try {
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

采集到想要的数据上传服务器

/**
 * Created by sun on 17/7/4.
 */

public class UploadService extends Thread{

    private File file;
    public UploadService(File file) {
        this.file = file;
    }

    public void run() {
        Log.i("UploadService", "initCoverageInfo");
        // 当前时间
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Calendar cal = Calendar.getInstance();
        String create_time = format.format(cal.getTime()).substring(0,19);

        // 系统版本
        String os_version = DeviceUtils.getSystemVersion();

        // 系统机型
        String device_name = DeviceUtils.getDeviceType();

        // 应用版本
        String app_version = DeviceUtils.getAppVersionName(LuojiLabApplication.getInstance());

        // 应用版本
        String uid = String.valueOf(AccountUtils.getInstance().getUserId());

        // 环境
        String context = String.valueOf(BuildConfig.SERVER_ENVIRONMENT);

        Map<String, String> params = new HashMap<String, String>();
        params.put("os_version", os_version);
        params.put("device_name", device_name);
        params.put("app_version", app_version);
        params.put("uid", uid);
        params.put("context", context);
        params.put("create_time", create_time);

        try {
            post("https://xxx.com/coverage/uploadec", params, file);
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    /**
     * 通过拼接的方式构造请求内容，实现参数传输以及文件传输
     *
     * @param url    Service net address
     * @param params text content
     * @param files  pictures
     * @return String result of Service response
     * @throws IOException
     */
    public static String post(String url, Map<String, String> params, File files)
            throws IOException {
        String BOUNDARY = java.util.UUID.randomUUID().toString();
        String PREFIX = "--", LINEND = "
";
        String MULTIPART_FROM_DATA = "multipart/form-data";
        String CHARSET = "UTF-8";


        Log.i("UploadService", url);
        URL uri = new URL(url);
        HttpURLConnection conn = (HttpURLConnection) uri.openConnection();
        conn.setReadTimeout(10 * 1000); // 缓存的最长时间
        conn.setDoInput(true);// 允许输入
        conn.setDoOutput(true);// 允许输出
        conn.setUseCaches(false); // 不允许使用缓存
        conn.setRequestMethod("POST");
        conn.setRequestProperty("connection", "keep-alive");
        conn.setRequestProperty("Charsert", "UTF-8");
        conn.setRequestProperty("Content-Type", MULTIPART_FROM_DATA + ";boundary=" + BOUNDARY);

        // 首先组拼文本类型的参数
        StringBuilder sb = new StringBuilder();
        for (Map.Entry<String, String> entry : params.entrySet()) {
            sb.append(PREFIX);
            sb.append(BOUNDARY);
            sb.append(LINEND);
            sb.append("Content-Disposition: form-data; name="" + entry.getKey() + """ + LINEND);
            sb.append("Content-Type: text/plain; charset=" + CHARSET + LINEND);
            sb.append("Content-Transfer-Encoding: 8bit" + LINEND);
            sb.append(LINEND);
            sb.append(entry.getValue());
            sb.append(LINEND);
        }

        DataOutputStream outStream = new DataOutputStream(conn.getOutputStream());
        outStream.write(sb.toString().getBytes());
        // 发送文件数据
        if (files != null) {
            StringBuilder sb1 = new StringBuilder();
            sb1.append(PREFIX);
            sb1.append(BOUNDARY);
            sb1.append(LINEND);
            sb1.append("Content-Disposition: form-data; name="uploadfile"; filename=""
                    + files.getName() + """ + LINEND);
            sb1.append("Content-Type: application/octet-stream; charset=" + CHARSET + LINEND);
            sb1.append(LINEND);
            outStream.write(sb1.toString().getBytes());

            InputStream is = new FileInputStream(files);
            byte[] buffer = new byte[1024];
            int len = 0;
            while ((len = is.read(buffer)) != -1) {
                outStream.write(buffer, 0, len);
            }

            is.close();
            outStream.write(LINEND.getBytes());
        }


        // 请求结束标志
        byte[] end_data = (PREFIX + BOUNDARY + PREFIX + LINEND).getBytes();
        outStream.write(end_data);
        outStream.flush();
        // 得到响应码
        int res = conn.getResponseCode();
        Log.i("UploadService", String.valueOf(res));
        InputStream in = conn.getInputStream();
        StringBuilder sb2 = new StringBuilder();
        if (res == 200) {
            int ch;
            while ((ch = in.read()) != -1) {
                sb2.append((char) ch);
            }
        }
        outStream.close();
        conn.disconnect();
        return sb2.toString();
    }
}

上报数据的定时器

/**
 * 定时器，每分钟调用一次生成覆盖率方法
 *
 */
public boolean timer() {
    JacocoUtils.generateEcFile(true);
}

启用JaCoCo

安装plugin

apply plugin: 'jacoco'

jacoco {
    toolVersion = '0.7.9'
}

 

启用覆盖率开关

此处是在debug时启用覆盖率的收集

Android 9.0以上版本因为限制私有API的集成，所以如果打开了开关，9.0以上系统使用App时会有系统级toast提示“Detected problems with API compatibility”，但不影响功能。

buildTypes {
    debug {
        testCoverageEnabled = true
    }
}

分析源码和二进制，生成覆盖率报告

执行命令生成

./gradlew jacocoTestReport

这块做的时候遇到三个问题。
第一个问题是App已经拆成组件了，每个主要模块都是一个可独立编译的业务组件。如果按照之前的方法只能统计到主工程的覆盖率，业务组件的覆盖率统计不到。
解决办法是是先拿到所有业务组件的名称和路径（我们在settings.gradle里有定义），然后循环添加成一个list，files方法支持list当做二进制目录传入。

第二个问题是部分业务组件是用Kotlin开发的，所以要同时兼容Java和Kotlin两种编程语言。
解决办法跟问题一的一样，files同时支持Kotlin的二进制目录传入。

第三个问题是覆盖率数据是碎片式的，每天会有上万个覆盖率文件生成，之前只做过单个文件的覆盖率计算，如何批量计算覆盖率文件？
解决办法是使用fileTree方法的includes，用正则表达式*号，批量计算特定目录下符合规则的所有.ec文件。

executionData = fileTree(dir: "$buildDir", includes: [
    "outputs/code-coverage/connected/*coverage.ec"
])

完整代码

task jacocoTestReport(type: JacocoReport) {
    def lineList = new File(project.rootDir.toString() + '/settings.gradle').readLines()
    def coverageCompName = []
    for (i in lineList) {
        if (!i.isEmpty() && i.contains('include')) {
            coverageCompName.add(project.rootDir.toString() + '/' + i.split(':')[1].replace("'", '') + '/')
        }
    }

    def coverageSourceCompName = []
    for (i in lineList) {
        if (!i.isEmpty() && i.contains('include')) {
            coverageSourceCompName.add('../' + i.split(':')[1].replace("'", '') + '/')
        }
    }

    reports {
        xml.enabled = true
        html.enabled = true
    }
    def fileFilter = ['**/R*.class',
                      '**/*$InjectAdapter.class',
                      '**/*$ModuleAdapter.class',
                      '**/*$ViewInjector*.class',
                      '**/*Binding*.class',
                      '**/*BR*.class'
    ]

    def coverageSourceDirs = []
    for (i in coverageSourceCompName) {
        def sourceDir = i + 'src/main/java'
        coverageSourceDirs.add(sourceDir)
    }

    def coverageClassDirs = []
    for (i in coverageCompName) {
        def classDir = fileTree(dir: i + 'build/intermediates/classes/release', excludes: fileFilter)
        coverageClassDirs.add(classDir)
    }

    def coverageKotlinClassDirs = []
    for (i in coverageCompName) {
        def classKotlinDir = fileTree(dir: i + 'build/tmp/kotlin-classes/release', excludes: fileFilter)
        coverageKotlinClassDirs.add(classKotlinDir)
    }

    classDirectories = files(coverageClassDirs, coverageKotlinClassDirs)
    sourceDirectories = files(coverageSourceDirs)
//    executionData = files("$buildDir/outputs/code-coverage/connected/coverage.ec")
    executionData = fileTree(dir: "$buildDir", includes: [
            "outputs/code-coverage/connected/*coverage.ec"
    ])

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

数据分析和处理

待补充。。。。

应用环境的覆盖率分析

 

设备系统的覆盖率分析

 

用户UID的覆盖率分析

 

应用版本的覆盖率分析