JaCoCo 是一个用于计算 Java 代码覆盖率的工具，它可以测量单元测试覆盖了代码的哪些部分。JaCoCo官网：EclEmma - JaCoCo Java Code Coverage Library

目录

1. JaCoCo 基本用法

2.JaCoCo 集成到构建流程

3.设置 JaCoCo 覆盖率目标

4.集成到现有测试框架

5.生成详细的覆盖率报告

6.跨多个测试运行的覆盖率聚合

7.JaCoCo在词序集成(CI)中的应用

8.设置代码覆盖率的排除和包含规则

9.分布式测试覆盖率收集

10.代码覆盖率的增量分析

11.代码覆盖率的分支覆盖分析

12.在Maven中的详细配置示例

1. JaCoCo 基本用法
步骤描述命令
1添加 JaCoCo 插件到项目在 pom.xml 或 build.gradle 文件中添加 JaCoCo 插件
2配置 JaCoCo 插件设置 JaCoCo 插件的配置，如输出目录
3执行测试并生成报告使用 JaCoCo 插件执行测试，并生成覆盖率报告
4查看报告查看生成的 HTML 报告，了解代码覆盖率

代码示例：

Maven方式；在pom.xml文件中添加 JaCoCo 插件：

<build>
    <plugins>
        <plugin>
            <groupId>org.jacoco</groupId>
            <artifactId>jacoco-maven-plugin</artifactId>
            <version>0.8.7</version>
            <executions>
                <execution>
                    <goals>
                        <goal>prepare-agent</goal>
                    </goals>
                </execution>
                <execution>
                    <id>report</id>
                    <phase>test</phase>
                    <goals>
                        <goal>report</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

执行测试并生成报告：

mvn test jacoco:report

Gradle方式；

在 build.gradle 文件中添加 JaCoCo 插件：

plugins {
    id 'jacoco'
}

jacoco {
    toolVersion = "0.8.7"
}

test {
    useJUnitPlatform()
}

tasks.test {
    finalizedBy jacocoTestReport
}

执行测试并生成报告：

gradle test jacocoTestReport

 查看报告：

打开生成的 index.html 文件

2.JaCoCo 集成到构建流程
步骤描述命令说明
1集成到构建脚本将 JaCoCo 集成到项目的构建脚本中，确保每次构建都运行测试并生成覆盖率报告Maven: <build>...</build> 或 Gradle: buildscript {...}
2自动化测试执行在持续集成(CI)服务器上配置自动化测试执行，使用 JaCoCo 插件CI 配置文件中添加 JaCoCo 插件配置
3报告的存档将生成的覆盖率报告存档，以便历史比较和分析使用 CI 工具的归档功能，如 archiveArtifacts
4报告的查看在 CI 服务器上查看覆盖率报告，或将报告部署到服务器供团队查看在 CI 服务器的 Web 界面查看或通过 Web 服务器访问

代码示例：

Maven中配置； 

在 pom.xml 中集成 JaCoCo 并配置 CI 插件（例如 Jenkins）：

<build>
    <plugins>
        <!-- JaCoCo plugin configuration from previous example -->
        <!-- ... -->
    </plugins>
</build>

<reporting>
    <plugins>
        <plugin>
            <groupId>org.jacoco</groupId>
            <artifactId>jacoco-maven-plugin</artifactId>
            <version>0.8.7</version>
        </plugin>
    </plugins>
</reporting>

gradle中；在 build.gradle 中集成 JaCoCo 并配置 CI 插件（例如 Jenkins）：

// JaCoCo plugin configuration from previous example
// ...

// Example of Jenkins pipeline configuration
task jacocoReport(type: JacocoReport, dependsOn: test) {
    executionData test
    reports {
        xml.enabled true
        html.enabled true
    }
}

// Jenkins might automatically call this task as part of the pipeline

在CI服务器上，你可能需要配置一些步骤来确保JaCoCo报告被正确生成和存档。例如，在Jenkins中，你可以使用archiveArtifacts步骤：

pipeline {
    agent any
    stages {
        stage('Build') {
            steps {
                // Build and test steps
                sh 'mvn clean package jacoco:report'
            }
        }
        stage('Archive') {
            steps {
                // Archive JaCoCo reports
                archiveArtifacts artifacts: '**/jacoco.exec', fingerprint: true
            }
        }
    }
    post {
        always {
            // Clean up workspace
            cleanWs()
        }
    }
}

这只是一个基本的示例，实际的CI配置将取决于你使用的CI工具和你的具体需求。

3.设置 JaCoCo 覆盖率目标
步骤描述命令说明
1定义覆盖率目标为项目设置覆盖率目标，如至少80%的行覆盖率在 JaCoCo 插件配置中指定目标
2配置 JaCoCo 插件配置 JaCoCo 插件以检查覆盖率是否达到目标Maven: <configuration>...</configuration> 或 Gradle: jacoco {...}
3测试覆盖率检查在构建过程中执行覆盖率检查，确保测试覆盖率满足目标Maven: <goal>check</goal> 或 Gradle: tasks.check.dependsOn jacocoTestReport
4查看失败的构建如果覆盖率未达到目标，构建将失败，查看失败原因并改进测试查看构建日志中的 JaCoCo 报告部分

代码示例：

Maven中； 在 pom.xml 中配置 JaCoCo 插件以设置覆盖率目标：

<build>
    <plugins>
        <plugin>
            <groupId>org.jacoco</groupId>
            <artifactId>jacoco-maven-plugin</artifactId>
            <version>0.8.7</version>
            <executions>
                <!-- ... -->
            </executions>
            <configuration>
                <rules>
                    <rule>
                        <element>BUNDLE</element>
                        <limits>
                            <limit>
                                <counter>LINE</counter>
                                <value>COVEREDRATIO</value>
                                <minimum>0.80</minimum>
                            </limit>
                        </limits>
                    </rule>
                </rules>
            </configuration>
        </plugin>
    </plugins>
</build>

执行测试并检查覆盖率：

mvn test jacoco:check

在Gradle中； 在 build.gradle 中配置 JaCoCo 插件以设置覆盖率目标：

plugins {
    id 'jacoco'
}

jacoco {
    toolVersion = "0.8.7"
    minimumCoverage = 0.80
}

check.dependsOn jacocoTestReport

执行测试并检查覆盖率：

gradle check

 通过设置覆盖率目标，你可以确保项目在每次构建时都达到一定的质量标准。如果覆盖率未达到目标，构建将失败，从而提醒开发团队需要改进测试。

4.集成到现有测试框架
步骤描述命令说明
1选择测试框架确定项目中使用的测试框架，如 JUnit, TestNG-
2配置 JaCoCo 以支持测试框架确保 JaCoCo 插件与测试框架兼容Maven/Gradle 插件配置中通常自动兼容
3执行测试使用测试框架执行测试用例命令行或 IDE 中运行测试
4生成覆盖率报告测试完成后，使用 JaCoCo 生成覆盖率报告Maven: mvn jacoco:report 或 Gradle: gradle jacocoTestReport

代码示例

对于大多数流行的测试框架，JaCoCo 的集成通常是透明的，不需要特别的配置。以下是一些常见测试框架的集成示例。

如果你的项目使用 JUnit 或者TestNG作为测试框架，JaCoCo 将自动处理 JUnit和TestNG 测试的覆盖率。

执行测试和生成报告的 Maven 命令：

mvn test jacoco:report

 Gradle 命令：

gradle test jacocoTestReport

 在大多数情况下，JaCoCo 插件会自动检测到项目中使用的测试框架，并相应地生成覆盖率报告。如果需要对测试框架进行特别配置，官方文档会提供详细的指导。

5.生成详细的覆盖率报告
步骤描述命令说明
1配置 JaCoCo 插件设置 JaCoCo 插件以生成不同类型的覆盖率报告在构建脚本中配置 jacoco 插件
2执行测试运行测试用例，JaCoCo 会收集覆盖数据使用 Maven 或 Gradle 运行测试命令
3生成报告使用 JaCoCo 命令生成覆盖率报告Maven: mvn jacoco:report 或 Gradle: gradle jacocoTestReport
4查看报告分析生成的报告，了解代码的覆盖率情况打开生成的 HTML 报告文件

代码示例

Maven中；在 pom.xml 中配置 JaCoCo 插件以生成详细的覆盖率报告：

<build>
    <plugins>
        <plugin>
            <groupId>org.jacoco</groupId>
            <artifactId>jacoco-maven-plugin</artifactId>
            <version>0.8.7</version>
            <executions>
                <!-- ... -->
            </executions>
            <configuration>
                <!-- 配置覆盖率报告的输出目录 -->
                <dataFile>target/jacoco.exec</dataFile>
                <outputDirectory>target/jacoco-reports</outputDirectory>
            </configuration>
        </plugin>
    </plugins>
</build>

 执行测试并生成报告：

mvn test jacoco:report

Gradle中； 在 build.gradle 中配置 JaCoCo 插件以生成详细的覆盖率报告：

plugins {
    id 'jacoco' // 确保已经添加了 JaCoCo 插件
}

jacoco {
    toolVersion = "0.8.7"
}

test {
    useJUnitPlatform()
}

tasks.jacocoTestReport {
    reports {
        // 配置 HTML 和 XML 报告的输出
        html.enabled true
        xml.enabled true
    }
}

// 将测试报告任务添加到构建生命周期中
check.dependsOn jacocoTestReport

JaCoCo 支持多种报告格式，包括 HTML、XML 和 CSV。HTML 报告通常用于可视化代码覆盖率，而 XML 报告可以用于自动化分析和集成到 CI 系统中。

6.跨多个测试运行的覆盖率聚合
步骤描述命令说明 
1执行多个测试运行执行多个测试套件或测试运行，以覆盖不同的代码路径使用测试框架执行测试
2收集覆盖率数据收集每次测试运行的覆盖率数据文件（.exec）JaCoCo 插件自动生成 .exec 文件
3聚合覆盖率数据使用 JaCoCo 命令行工具或 Maven/Gradle 插件聚合多个 .exec 文件JaCoCo CLI: java -jar jacococli.jar merge
4生成聚合报告从聚合后的覆盖率数据生成报告Maven: mvn jacoco:report-aggregate 或 JaCoCo CLI

代码示例使用JaCoCo CLI聚合覆盖率数据 

首先，确保你已经收集了多个 .exec 文件。然后使用 JaCoCo 的命令行工具进行聚合：

java -jar jacococli.jar merge *.exec merged.exec

这会将所有 .exec 文件合并成一个名为 merged.exec 的文件。

Maven生成集合报告

在 pom.xml 中配置 JaCoCo 插件以使用聚合的覆盖率数据生成报告：

<build>
    <plugins>
        <plugin>
            <groupId>org.jacoco</groupId>
            <artifactId>jacoco-maven-plugin</artifactId>
            <version>0.8.7</version>
            <executions>
                <execution>
                    <id>default-merge</id>
                    <phase>verify</phase>
                    <goals>
                        <goal>merge</goal>
                    </goals>
                    <configuration>
                        <fileSets>
                            <fileSet>
                                <directory>${project.build.directory}</directory>
                                <includes>
                                    <include>*.exec</include>
                                </includes>
                            </fileSet>
                        </fileSets>
                        <destFile>${project.build.directory}/jacoco-merged.exec</destFile>
                    </configuration>
                </execution>
                <execution>
                    <id>default-report</id>
                    <phase>verify</phase>
                    <goals>
                        <goal>report-aggregate</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

 执行聚合和报告生成：

mvn jacoco:merge jacoco:report-aggregate

Gradle生成聚合报告

在 build.gradle 中配置 JaCoCo 插件以使用聚合的覆盖率数据生成报告：

plugins {
    id 'jacoco'
}

tasks.register('mergeJacocoReports', JacocoMerge) {
    executionData files('build/jacoco/*.exec')
    destinationFile file("$buildDir/jacoco/merged.exec")
}

tasks.jacocoTestReport.dependsOn 'mergeJacocoReports'

 通过聚合多个测试运行的覆盖率数据，你可以获得更全面的代码覆盖率视图，这对于大型项目或需要运行多个测试套件的场景非常有用。

7.JaCoCo在词序集成(CI)中的应用
步骤描述命令说明
1配置 CI 环境在 CI 服务器上安装 Java 和 JaCoCo 插件根据 CI 服务器的文档进行安装
2编写构建脚本创建或修改 CI 项目的构建脚本，以集成 JaCoCo 插件CI 项目的 .yml 或其他配置文件
3执行测试并生成报告在 CI 构建过程中执行测试，并使用 JaCoCo 生成覆盖率报告CI 构建脚本中的测试执行命令
4上传报告将 JaCoCo 生成的覆盖率报告上传到 CI 服务器或外部存储使用 CI 服务器的归档或上传功能
5分析报告在 CI 服务器上分析覆盖率报告，确保代码覆盖率达标查看 CI 服务器提供的报告链接

代码示例：

Jenkins中配置(使用Pipeline)

在 Jenkins 中，你可以使用 Pipeline 功能来集成 JaCoCo。以下是一个 Jenkinsfile 的示例：

pipeline {
    agent any
    stages {
        stage('Checkout') {
            steps {
                // 检出代码
                git 'https://gitlab_ip:port/your/repo.git'
            }
        }
        stage('Test') {
            steps {
                // 使用 Maven 或 Gradle 执行测试并生成 JaCoCo 报告
                sh 'mvn clean test jacoco:report'
            }
        }
        stage('Archive') {
            steps {
                // 归档 JaCoCo 报告
                archiveArtifacts artifacts: 'target/site/jacoco/*.html', fingerprint: true
            }
        }
    }
    post {
        always {
            // 无论构建成功与否，都执行清理操作
            cleanWs()
        }
    }
}

 在 CI 过程中集成 JaCoCo 可以帮助团队持续监控代码的测试覆盖率，确保代码质量，并在代码合并到主分支之前发现潜在的未测试覆盖的代码区域。

8.设置代码覆盖率的排除和包含规则
步骤描述命令说明
1确定覆盖率规则确定哪些代码应该被包含或排除在覆盖率报告之外-
2配置 JaCoCo 插件在构建脚本中配置 JaCoCo 插件以应用包含和排除规则Maven/Gradle 插件配置
3执行测试运行测试用例，JaCoCo 将根据规则收集覆盖数据Maven: mvn test 或 Gradle: gradle test
4生成报告使用 JaCoCo 生成覆盖率报告，报告将遵循配置的规则Maven: mvn jacoco:report 或 Gradle: gradle jacocoTestReport

代码示例：

在 pom.xml 中配置 JaCoCo 插件以设置包含和排除规则：

<build>
    <plugins>
        <plugin>
            <groupId>org.jacoco</groupId>
            <artifactId>jacoco-maven-plugin</artifactId>
            <version>0.8.7</version>
            <configuration>
                <includes>
                    <include>com/mycompany/**</include>
                </includes>
                <excludes>
                    <exclude>com/mycompany/**/internal/*</exclude>
                    <exclude>com/mycompany/**/*Test</exclude>
                </excludes>
            </configuration>
        </plugin>
    </plugins>
</build>

在Gradle中;

在 build.gradle 中配置 JaCoCo 插件以设置包含和排除规则：

plugins {
    id 'jacoco'
}

jacoco {
    // 配置包含规则
    include "**/com/mycompany/**/*.class"
    
    // 配置排除规则
    exclude "**/com/mycompany/**/internal/**/*.class"
    exclude "**/com/mycompany/**/*Test.class"
}

test {
    // 确保测试任务完成后生成 JaCoCo 报告
    useJUnitPlatform()
    finalizedBy jacocoTestReport
}

通过设置包含和排除规则，你可以专注于对重要业务逻辑的测试覆盖率，同时忽略那些不需要或不值得测试的代码，如自动生成的代码、测试代码本身、内部工具类等。

9.分布式测试覆盖率收集
步骤描述命令说明
1配置分布式测试环境确保测试可以在多个分布式节点上执行CI/CD 配置或分布式测试工具配置
2收集单个节点的覆盖率数据每个测试节点独立运行测试并生成 .exec 文件使用 Maven 或 Gradle 在每个节点上执行测试
3合并分布式节点的覆盖率数据使用 JaCoCo 命令行工具或插件合并所有节点的 .exec 文件JaCoCo CLI: java -jar jacococli.jar merge
4生成合并后的覆盖率报告从合并后的覆盖率数据生成最终的覆盖率报告Maven: mvn jacoco:report-aggregate 或 JaCoCo CLI

代码示例

分布式测试环境配置

 在分布式测试环境中，每个测试节点通常会独立执行测试。确保每个节点的 JaCoCo .exec 文件都被保存并可以在之后被合并。

Maven合并分布式节点的覆盖率数据

在 Maven 中，你可以使用 JaCoCo 的 merge 目标来合并所有节点的 .exec 文件：

mvn jacoco:merge@merge-reports -Djacoco.merge.dataFile1=<node1-jacoco-exec-file-path>

其中 <node1-jacoco-exec-file-path> 是第一个节点生成的 .exec 文件的路径。如果有更多节点，可以使用 -Djacoco.merge.dataFile2、-Djacoco.merge.dataFile3 等来指定。

JaCoCo CLI合并分布式节点的覆盖率数据

使用 JaCoCo 的命令行工具合并所有节点的 .exec 文件：

java -jar jacococli.jar merge node1.exec node2.exec merged.exec

这会生成一个名为 merged.exec 的文件，其中包含了所有测试节点的覆盖率数据。

生成合并后的覆盖率报告

一旦你有了合并后的 .exec 文件，就可以使用 JaCoCo 生成最终的覆盖率报告：

对于 Maven：

mvn jacoco:report-aggregate@aggregate-reports -Djacoco.report-aggregate.dataFile=merged.exec

对于 JaCoCo CLI，报告生成通常是通过 Maven 或 Gradle 插件完成的。

在分布式测试环境中，覆盖率数据的合并是确保获得整个应用代码覆盖率视图的关键步骤。

10.代码覆盖率的增量分析
步骤描述命令说明
1收集初始覆盖率数据运行测试用例并收集初始的代码覆盖率数据使用 Maven 或 Gradle 执行测试
2执行代码变更对代码进行修改或增加新功能修改源代码
3重新收集覆盖率数据在变更后再次运行测试并收集覆盖率数据使用 Maven 或 Gradle 执行测试
4进行增量分析比较两次测试运行的覆盖率数据，找出变更影响的范围使用 JaCoCo 的增量分析功能
5查看增量报告分析增量报告，了解新增或遗漏的覆盖区域查看 JaCoCo 生成的增量报告

代码示例

 在 Maven 中，你可以使用 JaCoCo 插件的 prepare-agent 阶段来配置初始的覆盖率数据收集：

<plugin>
    <groupId>org.jacoco</groupId>
    <artifactId>jacoco-maven-plugin</artifactId>
    <version>0.8.7</version>
    <executions>
        <execution>
            <goals>
                <goal>prepare-agent</goal>
                <goal>report</goal>
            </goals>
        </execution>
    </executions>
</plugin>

然后，进行代码变更并再次运行测试：

mvn test jacoco:report

 在 Gradle 中，JaCoCo 插件会自动配置测试覆盖率的收集：

plugins {
    id 'jacoco'
}

test {
    useJUnitPlatform()
}

tasks.jacocoTestReport {
    dependsOn test
}

执行测试：

gradle test jacocoTestReport

增量分析

 aCoCo 支持增量分析，但需要手动比较不同测试运行生成的 .exec 文件。你可以使用 JaCoCo 的命令行工具或自定义脚本来比较这些文件，找出新增加的测试覆盖或遗漏的覆盖区域。

java -jar jacococli.jar diff old.exec new.exec

 增量分析有助于开发人员理解他们的代码变更如何影响测试覆盖率，从而更精确地评估变更对测试覆盖的影响。

11.代码覆盖率的分支覆盖分析
步骤描述命令说明
1配置 JaCoCo 插件确保 JaCoCo 插件配置为收集分支覆盖数据在构建脚本中设置 dataFormat 为 BINARY 或 XML
2执行测试运行测试用例，JaCoCo 将收集包括分支覆盖在内的覆盖数据使用 Maven 或 Gradle 执行测试命令
3生成分支覆盖报告使用 JaCoCo 命令或插件生成分支覆盖报告Maven: mvn jacoco:report 或 Gradle: gradle jacocoTestReport
4查看报告分析生成的报告，特别关注分支覆盖率打开 HTML 报告中的“Branches”部分

代码示例

在 pom.xml 中配置 JaCoCo 插件以收集分支覆盖数据：

<build>
    <plugins>
        <plugin>
            <groupId>org.jacoco</groupId>
            <artifactId>jacoco-maven-plugin</artifactId>
            <version>0.8.7</version>
            <configuration>
                <dataFormat>XML</dataFormat>
            </configuration>
            <executions>
                <!-- ... -->
            </executions>
        </plugin>
    </plugins>
</build>

执行测试并生成报告：

mvn test jacoco:report

在 build.gradle 中配置 JaCoCo 插件以收集分支覆盖数据：

plugins {
    id 'jacoco'
}

jacoco {
    toolVersion = "0.8.7"
}

test {
    useJUnitPlatform()
}

tasks.jacocoTestReport {
    reports {
        xml.enabled = true
        html.enabled = true
    }
    dependsOn test
}

执行测试并生成报告：

gradle test jacocoTestReport

分支覆盖率是衡量测试质量的一个重要指标，它显示了测试用例是否覆盖了所有的逻辑分支。JaCoCo 的分支覆盖报告可以帮助开发人员识别未被测试覆盖的代码路径，从而提高测试的全面性。

还有行覆盖率分析在html报告中的"Lines"部分；指令覆盖率分析在报告的“Instructions”部分；限定条件覆盖分析在报告的“Conditions”部分，还有类覆盖率和包覆盖率分析等。

12.在Maven中的详细配置示例

接下来给一个相对比较详细完整的JaCoCo在Maven中的配置；

<project>
    <!-- ... other configurations ... -->

    <build>
        <plugins>
            <!-- JaCoCo Maven Plugin Configuration -->
            <plugin>
                <groupId>org.jacoco</groupId>
                <artifactId>jacoco-maven-plugin</artifactId>
                <version>0.8.7</version>
                <executions>
                    <!-- Prepare JaCoCo agent before integration-test phase -->
                    <execution>
                        <id>pre-unit-test</id>
                        <goals>
                            <goal>prepare-agent</goal>
                        </goals>
                        <configuration>
                            <!-- Sets the path to the file which will contain the execution data -->
                            <destFile>${project.build.directory}/coverage-reports/jacoco-ut.exec</destFile>
                            <propertyName>surefireArgLine</propertyName>
                        </configuration>
                    </execution>
                    
                    <!-- Generate coverage report after integration-test phase -->
                    <execution>
                        <id>post-unit-test</id>
                        <phase>test</phase>
                        <goals>
                            <goal>report</goal>
                        </goals>
                        <configuration>
                            <!-- Sets the path to the file which will contain the execution data -->
                            <dataFile>${project.build.directory}/coverage-reports/jacoco-ut.exec</dataFile>
                            <!-- Output directory for the reports -->
                            <outputDirectory>${project.reporting.outputDirectory}/jacoco-ut</outputDirectory>
                        </configuration>
                    </execution>
                    
                    <!-- Example of integration test coverage -->
                    <execution>
                        <id>pre-integration-test</id>
                        <phase>pre-integration-test</phase>
                        <goals>
                            <goal>prepare-agent</goal>
                        </goals>
                        <configuration>
                            <!-- Pass the property to surefire via system property -->
                            <propertyName>failsafeArgLine</propertyName>
                        </configuration>
                    </execution>
                    <execution>
                        <id>post-integration-test</id>
                        <phase>post-integration-test</phase>
                        <goals>
                            <goal>report</goal>
                        </goals>
                        <configuration>
                            <dataFile>${project.build.directory}/coverage-reports/jacoco-it.exec</dataFile>
                            <outputDirectory>${project.reporting.outputDirectory}/jacoco-it</outputDirectory>
                        </configuration>
                    </execution>
                </executions>
                
                <configuration>
                    <!-- Specify the rules -->
                    <rules>
                        <rule>
                            <element>BUNDLE</element>
                            <limits>
                                <limit>
                                    <counter>COMPLEXITY</counter>
                                    <value>COVEREDRATIO</value>
                                    <minimum>0.60</minimum>
                                </limit>
                            </limits>
                        </rule>
                    </rules>
                </configuration>
            </plugin>
        </plugins>
    </build>

    <!-- ... other configurations ... -->
</project>

在这个配置中：

  • prepare-agent 用于在测试执行前准备 JaCoCo 代理。
  • report 用于在测试执行后生成覆盖率报告。
  • destFile 指定了 JaCoCo 代理生成的执行数据文件的位置。
  • propertyName 指定了包含 JaCoCo 配置的系统属性名称，这个属性会被传递给测试插件。
  • rules 部分定义了覆盖率规则，这里设置了一个复杂度覆盖率的最低阈值。
  • outputDirectory 指定了覆盖率报告的输出目录。

请注意，这个配置是一个示例，实际的配置可能需要根据项目的特定需求进行调整。此外，版本号 0.8.7 应该替换为 JaCoCo 插件的最新版本。在实际应用中，你可能还需要配置 surefire-plugin 和 failsafe-plugin 以确保它们使用 JaCoCo 提供的系统属性来执行测试。

# 代码覆盖率 # 单元测试
Logo
GitCode 开源社区

旨在为数千万中国开发者提供一个无缝且高效的云端环境，以支持学习、使用和贡献开源项目。

更多推荐

[转载]在Windows环境下安装GNU Radio

转自：在Windows环境下安装GNURadio_恐弱智_新浪博客GNU Radio是用Python开发的，大部分开源的工程能够在Linux环境下运行良好，而Windows下却运行的很勉强，而且安装配置都很复杂。GNU Radio算是个例外了，不光提供了Windows的二进制安装，还有比较详细的说明。我是Python小白，所以折腾了好久才弄好，特意记录下来，免得以后再装还折腾。GNU Radio的

avatar GitCode 开源社区

centOS 8 使用dnf安装Docker

DNF是什么？CentOS 8使用YUM软件包管理器版本v4.0.4。现在，该版本使用DNF(已删除YUM)。DNF是软件包管理器。它会在Linux发行版上安装，执行更新并删除软件包。使用DNF安装Docker跳过具有损坏依赖性的程序包一个有效的解决方案是使您的CentOS 8系统使用以下--nobest命令安装最符合条件的版本：sudo dnf install docker...

avatar GitCode 开源社区

定时同步数据库表(mysql+linux+crontab)

sync.sh里面的参数需要改变，ip/username/password/database/tablesync.sh#!/bin/sh# Please change the IP and password of the data source db.# Then change the table name.filename=/home/nington/db/$(date +%Y-%m

avatar GitCode 开源社区