代码覆盖率是开发过程中常用的软件质量指标，可让您确定已测试（或执行）的代码的程度。为了实现最佳代码覆盖率，测试实现（或测试套件）测试大部分已实现代码是必不可少的。

有许多适用于 Java、C#、JavaScript 等语言的代码覆盖工具。使用最合适的代码覆盖工具对于了解已测试代码的百分比并采取适当的措施以确保您实现理想的代码覆盖非常重要。

为了优化代码测试，许多公司使用 JaCoCo-Maven 插件来帮助生成详细的代码覆盖率报告。JaCoCo-Maven 插件是用于 Java 项目的免费代码覆盖率库。它基于对 EclEmma 团队创建的现有集成库的研究。在更大程度上，代码覆盖率确实可以简要概述产品质量，因为覆盖率越高，未经测试的代码进入发布周期的机会就越小。

在本文中，我们将详细了解 JaCoCo-Maven 插件以及如何使用 Maven 实现该插件。我们还将集成一个 Maven 项目，并通过执行 Selenium 为测试生成详细的代码覆盖率报告。

什么是代码覆盖率？

在软件开发中，代码覆盖率是用来描述在执行测试套件时应用程序的源代码被执行的程度的度量。生成报告以查看和分析软件应用程序的代码覆盖率。此代码覆盖率报告可用于确保代码质量。

JaCoCo-Maven 插件用于生成代码覆盖率报告。代码覆盖率高的源代码在测试期间执行的代码更多。例如，如果您正在测试的软件包含 100 行代码，而软件中验证的代码行数为 90，则该软件应用程序的代码覆盖率将为 90%。

代码覆盖的好处

代码覆盖率对于开发人员、测试人员和 QA 工程师来说是一个非常有用的指标。以下是代码覆盖率的一些显着优势：

• 代码覆盖率报告在检测和消除死代码方面提供了有用的见解。这可以通过遵循实施最佳实践来避免，这反过来又会提高代码的可维护性和更好的产品质量。
• 质量保证可以帮助检测未使用测试实现覆盖的代码。
• 开发人员可以更快地完成软件开发过程，从而提高他们的生产力、可扩展性和效率。这会缩短上市时间 (TTM)。

众所周知，代码覆盖率对于每个软件产品都非常重要。现在我们已经快速回顾了代码覆盖的各个方面，让我们深入探讨我们的核心主题，即使用 JaCoCo-Maven 插件生成代码覆盖报告。

JaCoCo-Maven 插件是什么？

JaCoCo-Maven（Java Code Coverage 的缩写）插件是一个开源的 Java 代码覆盖工具。它创建代码覆盖率报告并与 Eclipse IDE 等 IDE（集成开发环境）很好地集成。

它还可以与 CI/CD 工具（例如 Jenkins、Circle CI 等）和项目管理工具（例如 SonarQube 等）顺利集成。它是 Eclipse Foundation 的一部分，并取代了 Eclipse 中的 EclEmma 代码覆盖工具。

JaCoCo-Maven 插件如何工作？

• JaCoCo-Maven 插件通过运行时代理检测 Java 代码来运行覆盖。简而言之，当它启动时，您将此代理附加到 JVM（Java 虚拟机）。该代理称为 JaCoCo 代理。第一次执行 start-agent 启动这个 JaCoCo runtime agent。
• 每当加载一个类时，JaCoCo 都可以检测该类，以便它可以查看何时调用该类以及在测试过程中调用了哪些（代码）行。通过保持这个跟踪，它建立了代码覆盖统计，这是在第二次执行（即生成报告）期间即时完成的。
• 默认情况下，文件会在 JVM 终止时立即创建，但也可以在服务器模式下运行代理。这会触发结果转储，并在终止前创建报告。下面显示的是 JaCoCo 插件的内部结构：

• 您可以在 JaCoCo-Maven 插件的配置中定义目标和规则。这为您提供了设置限制的灵活性，并有助于检查代码覆盖率。
• Maven-surefire 插件是默认的 Maven 插件。这会在 JVM 中运行测试并提供覆盖率报告。而 JaCoCo 插件检测已经由插件（例如 Surefire 插件）执行的代码。因此，检查 maven-surefire 插件的依赖性是一个很好的做法。

为什么 JaCoCo-Maven 插件有利于代码覆盖率？

JaCoCo-Maven 插件适用于代码覆盖，原因如下：

• 在处理任何项目时，开发人员大多更喜欢 IDE，因为它简化了编码和测试体验。JaCoCo 可以通过从其市场下载 EclEmma 以 EclEmma 的名称安装在 Eclipse IDE 上。
• 很容易将 JaCoCo 插件添加到所有类型的构建中，包括 ANT、Maven 和 Gradle。它还可以与 Jenkins、Circle CI 等 CI/CD 工具集成。这使其适用于许多用例。
• JaCoCo 生成的代码覆盖率报告是一个简单且信息丰富的 HTML 文件，可以在任何浏览器或 IDE 中查看。
• JaCoCo 还提供离线检测（即，在运行任何测试之前对所有类进行检测）。
• 报告分析也很容易，因为它是基于颜色的，并提供代码覆盖率的准确百分比。

如何使用 Maven 设置 JaCoCo 插件

要在 Maven 项目中获取代码覆盖率报告，我们首先需要为该项目设置 JaCoCo Maven 插件。通过集成 JaCoCo 插件，可以将代码覆盖率分析的结果作为 HTML 报告进行审查。可以从 MVN 存储库下载 JaCoCo-Maven 插件的当前版本。

以下是将 JaCoCo Maven 插件与 Maven 项目集成的步骤：

1. 每个Maven项目都有一个pom.xml文件，用来声明所有的依赖和插件。JaCoCo-Maven 插件在同一POM.xml文件中声明。相同的 XML 代码是：

<plugin>
  <groupId>org.jacoco</groupId>
  <artifactId>jacoco-maven-plugin</artifactId>
  <version>0.8.6</version>
</plugin>

这是在构建标签下添加的基本 XML 代码，用于在基于 Maven 的项目中指定 JaCoCo 插件。我们可以通过在执行标签中指定目标和规则来增强功能（比如提及何时应该生成报告等）。

2.在version标签之后，我们添加execution标签。此标记准备属性或执行以指向 JaCoCo 代理，并作为 VM（在本例中为 JVM）参数传递。

3. 对于运行简单的单元测试，执行标签中设置的两个目标都可以正常工作。最低限度是设置一个准备代理和报告目标。

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

• 准备代理目标：准备代理目标准备 JaCoCo 运行时代理以记录执行数据。它记录了执行的行数，回溯等。默认情况下，执行数据写入文件target/jacoco-ut.exec。
• 报告目标：报告目标根据 JaCoCo 运行时代理记录的执行数据创建代码覆盖率报告。由于我们指定了阶段属性，因此将在测试阶段编译后创建报告。默认情况下，执行数据从文件中读取target/jacoco-ut.exec，代码覆盖率报告写入目录target/site/jacoco/index.html。

4. 对于运行简单的单元测试，上述配置工作正常。但是，我们需要对代码覆盖率报告施加约束（例如，指定目标目录等）。这可以通过配置标签来完成：

<plugin>
  <groupId>org.jacoco</groupId>
  <artifactId>jacoco-maven-plugin</artifactId>
  <version>0.8.6</version>
  <executions>
  	<execution>
      	<id>prepare-agent</id>
            <goals>
            		<goal>prepare-agent</goal>
            </goals>
            <configuration>
<destFile>${project.build.directory}/coverage-reports/jacoco-ut.exec</destFile>
                <propertyName>surefireArgLine</propertyName>
            </configuration>
      </execution>
      <execution>
            <id>report</id>
            <phase>test</phase>
               <goals>
               	<goal>report</goal>
               </goals>
               <configuration>
<dataFile>${project.build.directory}/coverage-reports/jacoco-ut.exec</dataFile>
<outputDirectory>${project.reporting.outputDirectory}/jacoco-ut</outputDirectory>
               </configuration>
        </execution>
    </executions>
 </plugin>

第一次执行的配置

根据上面的代码，您可以看到destFile指定了一些标签，例如 等。以下是标签的简要说明：

• destFile tag：destFile标签用于设置包含执行数据的文件的路径。
• propertyName-surefireArgLine tag：此标记设置包含 JaCoCo 运行时代理设置的属性的名称。这还会在运行单元测试时设置 VM 参数行。

第二次执行的配置

根据上面的代码，您可以看到dataFile指定了 等标签。以下是标签的简要说明：

• dataFile tag：标签dataFile用于设置包含执行数据的文件的路径。
• outputDirectory 标签：此标签设置代码覆盖率报告的输出目录。

5. 我们还可以在我们的配置标签中添加规则来检查代码覆盖率。这可以如下所示完成：

<plugin>
  <groupId>org.jacoco</groupId>
  <artifactId>jacoco-maven-plugin</artifactId>
  <version>0.8.6</version>
  <executions>
  	<execution>
      	<id>prepare-agent</id>
            <goals>
            		<goal>prepare-agent</goal>
            </goals>
            <configuration>
<destFile>${project.build.directory}/coverage-reports/jacoco-ut.exec</destFile>
                <propertyName>surefireArgLine</propertyName>
            </configuration>
      </execution>
      <execution>
            <id>report</id>
            <phase>test</phase>
               <goals>
               	<goal>report</goal>
               </goals>
               <configuration>
<dataFile>${project.build.directory}/coverage-reports/jacoco-ut.exec</dataFile>
<outputDirectory>${project.reporting.outputDirectory}/jacoco-ut</outputDirectory>
               </configuration>
        </execution>
        <execution>
              <id>jacoco-check</id>
              <goals>
                <goal>check</goal>
              </goals>
              <configuration>
              	<rules>
                 	   <rule>
                    	<element>PACKAGE</element>
                    	<limits>
                      		<limit>
                        		<counter>LINE</counter>
                        		<value>COVEREDRATIO</value>
                        		<minimum>0.50</minimum>
                      		</limit>
                   	</limits>
                	   </rule>
            	      </rules>
             </configuration>
 	  </execution>
    </executions>
 </plugin>

第三次执行的配置

在这里，定义了一个新的目标检查。jacoco:check目标必然要验证指定的规则。规则在规则标签中给出。您可以灵活地指定多个规则。

• 元素标签：此标签指定必须应用规则的元素。
• 限制标签：counter、value、minimum等标签，用于限制代码覆盖率。mvn clean verify 之类的命令可用于确保是否遵循规则。

6. JaCoCo-Maven 插件配置中可以定义多个目标和规则。

使用 Maven 和 JaCoCo 插件的代码覆盖率报告

在本节中，我们将演示使用 JaCoCo Maven 插件生成代码覆盖率报告的步骤。演示是通过一个非常简单的测试场景来完成的。那么，让我们开始吧。

先决条件

1. Maven 3.0 或更高版本：Maven 是一个项目开发管理和理解工具。您可以从 Apache Maven 官方网站安装最新版本。
2. Java 1.5 或更高版本：您需要确保您的机器上安装了 Java。如果您没有安装 Java，请从 Java 官方网站下载最新版本的 Java。
3. 面向 Java 开发人员的 Eclipse IDE：尽管您可以使用自己选择的 IDE，但对于本演示，我们使用的是 Eclipse IDE。

创建简单 Maven 项目的步骤

1. 在 Eclipse IDE 中，转到文件 > 新建 > Maven 项目。

2. 出现一个新的对话框。确保勾选“使用默认工作区位置”复选框，然后单击“下一步”。

3. 要选择项目中的原型，org.apache.maven请在过滤器旁边的文本框中键入。选择maven-archetype-quickstart并单击“下一步”。

4. 现在，将“ Group Id ”指定为com.example，将“ Artifact Id ”指定为jacoco-example。“ Artifact Id ”是我们的项目名称。最后，单击“完成”按钮。

5. 您可以在“项目资源管理器”中看到项目文件和文件夹层次结构。

如何在 POM.xml 中指定 JaCoCo Maven 插件

1. 打开POM.xml，滚动到标签。我们将在列出 Maven 插件的部分中指定 JaCoCo-Maven 插件。只需复制以下代码并将其粘贴到上面的标签中：

<plugin>
  <groupId>org.jacoco</groupId>
  <artifactId>jacoco-maven-plugin</artifactId>
  <version>0.8.6</version>
  <executions>
     <!--first execution : for preparing JaCoCo runtime agent-->
      <execution>
      	<id>prepare-agent</id>
            <goals>
            		<goal>prepare-agent</goal>
            </goals>
      </execution>
     <!--second execution : for creating code coverage reports-->
      <execution>
            <id>report</id>
            <phase>test</phase>
               <goals>
               	<goal>report</goal>
               </goals>
        </execution>
    </executions>
 </plugin>

2. 由于我们正在演示使用 JUnit 进行自动化 Web 测试的报告生成，因此我们还将在POM.xml.

以下是 的全部内容POM.xml：

<?xml version="1.0" encoding="UTF-8"?>


<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>


  <groupId>com.example</groupId>
  <artifactId>jacoco-example</artifactId>
  <version>0.0.1-SNAPSHOT</version>

 <name>jacoco-example</name>


  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
  </properties>


<!-- JUnit dependencies added to run test cases -->
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
  </dependencies>


  <build>
      <plugins>
        <!-- Maven plugin for Project Management -->
        <plugin>
          <artifactId>maven-clean-plugin</artifactId>
          <version>3.0.0</version>
        </plugin>
        <!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_jar_packaging -->
        <plugin>
          <artifactId>maven-resources-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.7.0</version>
        </plugin>
        <plugin>
          <artifactId>maven-surefire-plugin</artifactId>
          <version>2.19.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-jar-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-install-plugin</artifactId>
          <version>2.5.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-deploy-plugin</artifactId>
          <version>2.8.2</version>
        </plugin>
            <plugin>
                <groupId>org.jacoco</groupId>
                <artifactId>jacoco-maven-plugin</artifactId>
                <version>0.8.6</version>
                                  
                <executions>
                    <execution>
                        <id>prepare-agent</id>
                        <goals><goal>prepare-agent</goal></goals>
                    </execution>
                    <execution>
                        <id>report</id>
                        <phase>test</phase>
                        <goals><goal>report</goal></goals>
                    </execution>
                </executions>
            </plugin>
      </plugins>
  </build> 
</project>

3.从项目目录，遍历到com.example.jacoco_lambdatest package现有的src/main/java. 创建一个名为 的新 Java 类LambdaTest.java。我们将在其中编写一个简单的setUp()函数来提供所需的 Selenium Grid 功能。

package com.example.Jacoco_lambdatest;

import java.net.MalformedURLException;
import java.net.URL;
import org.junit.Before;
import org.junit.Test;
import org.openqa.selenium.By;
import org.openqa.selenium.remote.DesiredCapabilities;
import org.openqa.selenium.remote.RemoteWebDriver;

public class LambdaTest {
	public static String username = "<LambdaTest_Username>";
	public static String accessKey = "<LambdaTest_AccessKey>";
	
  public static DesiredCapabilities setUp() throws Exception {
     DesiredCapabilities capabilities = new DesiredCapabilities();
      capabilities.setCapability("platform", "Windows 10");
	     capabilities.setCapability("browserName", "Chrome");
	     capabilities.setCapability("version", "87.0"); // If this cap isn't specified, it will just get the any available one
      capabilities.setCapability("resolution","1024x768");
      capabilities.setCapability("build", "First Test");
      capabilities.setCapability("name", "Sample Test");
      capabilities.setCapability("network", true); // To enable network logs
      capabilities.setCapability("visual", true); // To enable step by step screenshot
      capabilities.setCapability("video", true); // To enable video recording
      capabilities.setCapability("console", true); // To capture console logs
      return capabilities;
  }
}

在项目中添加 JUnit 测试用例

1. 我们将创建一个简单的 JUnit 测试用例AppTest.java。这是默认提供的，在src/test/java包名下com.example.jacoco_lambdatest。

package com.example.Jacoco_lambdatest;

import java.net.MalformedURLException;
import java.net.URL;
import org.junit.Before;
import org.junit.Test;
import org.openqa.selenium.By;
import org.openqa.selenium.remote.DesiredCapabilities;
import org.openqa.selenium.remote.RemoteWebDriver;
import com.example.Jacoco_lambdatest.*;

public class AppTest {
	public static RemoteWebDriver driver;
	
	@Test
	public void testScript1() throws Exception {
		try {
	DesiredCapabilities capabilities = LambdaTest.setUp();
	String username =LambdaTest.username;
	String accessKey = LambdaTest.accessKey;
	RemoteWebDriver driver = new RemoteWebDriver(new URL("https://"+username+":"+accessKey+"@hub.lambdatest.com/wd/hub"),capabilities);       driver.get("https://lambdatest.github.io/sample-todo-app/");
     driver.findElement(By.name("li1")).click();
	driver.findElement(By.name("li2")).click();		      driver.findElement(By.id("sampletodotext")).clear();		driver.findElement(By.id("sampletodotext")).sendKeys("Yey, Let's add it to list");
	driver.findElement(By.id("addbutton")).click();
	driver.quit();					
	} catch (Exception e) {
		System.out.println(e.getMessage());
		}
	}
}

生成代码覆盖率报告

1. 单击“ Run As ”按钮并将配置设置为 Maven Test。

2. 相反，您可以打开 cmd（命令行），遍历项目文件夹，然后运行 ​​maven 命令“mvn test”。

3. 运行 JUnit 测试将自动启动 JaCoCo 代理。它将在目标目录中创建一个二进制格式的报告，路径为target/jacoco.exec. 的输出jacoco.exec无法单独解释，但其他工具（如 SonarQube 和插件）可以解释它。正如我们之前指定的那样，jacoco:report目标将以 HTML、CSV 和 XML 等流行格式生成可读的代码覆盖率报告。

4. 构建成功后，转到目标文件夹，然后转到站点 > jacoco 文件夹。代码覆盖率报告（即index.html）位于target/site/jacoco/index.html. 报告看起来像这样：

5. 您可以通过单击com.example.jacoco_lambdatest>LambdaTest报告中的 在微观层面向下钻取。

6. 点击具体功能，您将在 中看到更详细的视图LambdaTest.java。

7. 在这里，您会看到许多不同颜色的钻石，如绿色、黄色和红色。这些是报告中使用的规范，用于表示执行了哪一行代码以及何时执行。我们将在下一节的报告分析中详细了解它。这样，您就已经通过 Jacoco Maven 插件成功生成了代码覆盖率报告。

代码覆盖率报告分析

我们的代码覆盖率报告显示 94% 的指令覆盖率和 100% 的分支覆盖率，这是一个很好的代码覆盖率分数。稍后，我们将通过添加更多测试用例来尝试实现 100% 的代码覆盖率分数。

JaCoCo 在报告中显示的 38 条指令是指字节码指令，而不是 Java 代码指令。JaCoCo 报告通过使用带颜色的菱形表示分支和背景高亮颜色表示行，帮助您直观地分析代码覆盖率。代码覆盖率报告中出现的菱形的简要说明如下：

• 红钻；表示在测试阶段没有执行任何分支。
• 黄色菱形：表示代码被部分覆盖（即部分分支未执行）。
• 绿色菱形：表示测试时所有分支都被行使

相同的颜色代码适用于线覆盖的背景高亮颜色。

该报告主要提供了三个关键指标：

1. 行覆盖率：这反映了基于测试调用的 Java 字节码指令数执行的代码量。
2. 分支覆盖率：这显示了源代码中已执行分支的百分比。这些是典型的 if/else 或 switch 语句。
3. 圈复杂度：这通过覆盖代码中所有可能路径所需的路径数量来反映代码复杂性。它还指需要实施以覆盖整个代码的测试用例的数量。由于代码中没有switch或statement，所以圈复杂度为1；一条执行路径足以覆盖整个代码。

引入更多测试用例以提高代码覆盖率

1. 为了获得更好的代码覆盖率，需要引入更多的测试来测试之前没有通过测试实现覆盖的代码。

2.去AppTest.javainsrc/test/java添加更多的测试用例。

3. 添加的新测试用例AppTest.java如下所示：

@Test
	public void testScript2() throws Exception {
	    try {
	    DesiredCapabilities capabilities = LambdaTest.setUp();
	    String username = LambdaTest.username;
	    String accessKey = LambdaTest.accessKey;
	    RemoteWebDriver driver = new RemoteWebDriver(new URL("https://"+username+":"+accessKey+"@hub.lambdatest.com/wd/hub"),capabilities);		 driver.get("https://lambdatest.github.io/sample-todo-app/");		    driver.findElement(By.name("li2")).click();
	    driver.findElement(By.name("li3")).click();
	   driver.findElement(By.id("sampletodotext")).clear();	driver.findElement(By.id("sampletodotext")).sendKeys("Yes, Let's add it to list");				driver.findElement(By.id("addbutton")).click();
					driver.quit();					
		} catch (Exception e) {
				System.out.println(e.getMessage());
			    }
			}
	

	@Test
	public void testScript3() throws Exception {
		try {
	    DesiredCapabilities capabilities = LambdaTest.setUp();
	    String username = LambdaTest.username;
	    String accessKey = LambdaTest.accessKey;
	    RemoteWebDriver driver = new RemoteWebDriver(new URL("https://"+username+":"+accessKey+"@hub.lambdatest.com/wd/hub"),capabilities);			  driver.get("https://lambdatest.github.io/sample-todo-app/");		    driver.findElement(By.name("li4")).click();
	    driver.findElement(By.id("sampletodotext")).clear();	driver.findElement(By.id("sampletodotext")).sendKeys("Yes, Let's add  it!");
	  driver.findElement(By.id("addbutton")).click();
	  driver.quit();					
	} catch (Exception e) {
		System.out.println(e.getMessage());
			}
			}

4. 让我们运行 Maven JaCoCo 报告来发布新的覆盖率报告。

5. JaCoCo 提供了一种通过声明最低要求来跟踪代码覆盖率分数的简单易行的方法。如果不满足这些要求，则构建失败，否则，构建成功。

6. 这些要求可以在 中指定为规则POM.xml。只需通过在POM.xml. <execution>在第二个标签后添加下面的代码POM.xml。

<!--Third execution : used to put a check on the entire package-->
<execution>
    <id>jacoco-check</id>
    <goals>
        <goal>check</goal>
    </goals>
    <configuration>
        <rules>
            <rule>
                <element>PACKAGE</element>
                <limits>
                    <limit>
                        <counter>LINE</counter>
                        <value>COVEREDRATIO</value>
                        <minimum>0.50</minimum>
                    </limit>
                </limits>
            </rule>
        </rules>
    </configuration>
</execution>

7. 因此，我们将覆盖率限制在 50%。这意味着在测试阶段至少应覆盖 50% 的代码。

8. 你可以运行Maven clean verify来检查jacoco:checkgoal中设置的规则是否满足。

9. 日志显示“已满足所有覆盖率检查”，因为我们的代码覆盖率得分为 94%，高于我们的最低 50%。

LambdaTest Selenium 网格上的自动化测试 

将 Maven 项目与 JaCoCo 插件一起使用

云上的 Selenium 测试可帮助您获得更好的浏览器覆盖率、更高的测试覆盖率和更快的上市时间。Selenium 中的并行测试可帮助您实现上述要求。

LambdaTest Cloud Selenium Grid 是一个基于云的可扩展 Selenium 测试平台，使您能够在 2000 多种不同的浏览器和操作系统上运行自动化脚本。

先决条件

要使用 JUnit 和 Selenium 运行测试脚本，我们需要设置一个环境。您首先需要在 LambdaTest 上创建一个帐户。请记下 LambdaTest 配置文件部分中提供的用户名和访问密钥。

我们将使用此示例项目进行 Java Selenium 测试。

将项目导入 Eclipse IDE

从 GitHub下载项目的 zip 文件后junit-selenium-sample，我们将按照以下步骤将其导入 Eclipse IDE：

1. 转到您的 Eclipse IDE，单击“文件”菜单并选择“导入”。出现一个新的对话框。

2. 在下面的文本框中键入 Maven 并选择“ Existing Maven Projects ”，然后单击“ Next ”。

3. 在接下来的对话框中，单击“浏览”并移动到项目文件夹。此外，勾选提供POM.xml文件路径的复选框，然后单击“完成”。

4. 您的项目将成功加载到 Eclipse IDE 中。

在 POM.xml 文件中添加依赖项

1、打开POM.xml，现在添加JUnit、Selenium、JaCoCo Maven Plugin的依赖。添加依赖到代码后POM.xml应该是这样的：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.lambdatest</groupId>
    <artifactId>lambdatest-junit-sample</artifactId>
    <version>1.0-SNAPSHOT</version>
    <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <surefire.version>2.19.1</surefire.version>
        <config.file>default</config.file>
    </properties>

    <dependencies>
        <!--JUnit dependency-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>1.3.2</version>
            <scope>test</scope>
        </dependency>
        <!--Selenium dependency-->
        <dependency>
            <groupId>org.seleniumhq.selenium</groupId>
            <artifactId>selenium-java</artifactId>
            <version>2.52.0</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.googlecode.json-simple</groupId>
            <artifactId>json-simple</artifactId>
            <version>1.1.1</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <!--Apache Maven Plugins-->
            <plugin>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.0</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
            <plugin>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>2.19.1</version>
            </plugin>
            <!--JaCoCo Maven Plugin-->
            <plugin>
                <groupId>org.jacoco</groupId>
                <artifactId>jacoco-maven-plugin</artifactId>
                <version>0.8.6</version>      
                <executions>
                    <execution>
                        <id>prepare-agent</id>
                      <goals><goal>prepare-agent</goal></goals>
                    </execution>
                    <execution>
                        <id>report</id>
                        <phase>test</phase>
                        <goals><goal>report</goal></goals>
                   </execution>
               </executions>
          </plugin>
        </plugins>
    </build>
</project>

<em><a href="https://github.com/rachnaagrawal/junit-selenium-sample/blob/master/pom.xml" target="_blank" rel="nofollow">Github</a></em>

为 JUnit 自动化测试配置所需的功能

1. 要连接到 LambdaTest Selenium Automation Grid，要做的第一件事是调用远程网络驱动程序。这个远程驱动需要浏览器、浏览器版本、操作系统等一些能力来搭建环境。它的代码如下所示：

WebDriver driver = new RemoteWebDriver(new URL("https://" + username + ":" + accesskey + "@hub.lambdatest.com/wd/hub"),
DesiredCapabilities.firefox()); //A class named DesiredCapabilities is used to create an environment as a Firefox browser.

2、在JUnit自动化测试代码中，可以自定义浏览器、浏览器版本、操作系统信息等能力，通过能力对象传递。

3. LambdaTest 通过提供内置功能生成器使此过程变得非常简单。功能生成器将根据您的输入自动生成所需功能的代码。比如，我们的配置是：

4. 在功能生成器中选择上面指定的配置并将其粘贴到LambdaTestBseTest.java。

在所需的 Java 类中指定 LambdaTest 用户名和访问密钥

1. 在 Project Explorer 中，您将看到三个 Java 类：

• LambdaTestBaseTest.java（包含 Java Selenium 测试所需的设置）。
• Parallelized.java（包含用于在 LambdaTest Selenium 网格上进行并行测试的 Junit 测试）。
• SimpleTest.java（包含简单的单元测试）。

2.LambdaTestBaseTest.java从配置文件中获取所需的数据，如所需的功能、用户名和访问密钥。这是在src/test/resourcesas中提供的config.json。

3. 在 中指定所需的功能、用户名和访问密钥config.json。使用此 JSON 文件是因为您可以在其中提供多个配置以实现与 Selenium 的并行测试，以在其中指定多个配置，config.json然后再获取它们。

[ { "tunnelName":"LambdaTest tunnel", 
"buildName":"running Java Selenium Tests",
"testName":"Jacoco JUnit Test",
"username": "user-name",
"access_key":"access-key", 
 "operatingSystem" : "win10", 
 "browserName" : "chrome",  
 "browserVersion" : "62.0", 
 "resolution" : "1024x768" }]

使用 JUnit 和 Selenium 进行单元测试：

1.SimpleTest.java是用于指定单个单元测试用例的 Java 类，用于使用 JaCoCo Maven 插件进行测试和执行代码覆盖。

package com.lambdatest;

import com.lambdatest.LambdaTestBaseTest;
import org.junit.Test;
import org.openqa.selenium.By;
import static org.junit.Assert.assertEquals;

public class SimpleTest extends LambdaTestBaseTest {
    /**
     * Simple Test case annotation for JUnit Test
     * @throws Exception
     */

   @Test
    public void validateUser() throws Exception {
    	  driver.get("https://lambdatest.github.io/sample-todo-app/");
	  driver.findElement(By.name("li1")).click();
	  driver.findElement(By.name("li2")).click();
	  driver.findElement(By.id("sampletodotext")).clear();
	  driver.findElement(By.id("sampletodotext")).sendKeys("Yey, Let's add it to list");
	  driver.findElement(By.id("addbutton")).click();
    }

}

2. 这是一个简单的 Selenium WebDriver 测试，它将打开一个示例待办应用程序，该应用程序将执行以下任务：

• 将前两项标记为“完成”。”
• 向列表中添加一个新项目。
• 返回添加的项目。

3. 在终端触发命令mvn test构建并运行测试用例。

4. 现在，登录到您的 LambdaTest 帐户并转到“自动化”。您将在构建名称“JUnit JaCoCo Tests”下找到您运行的测试。

5. 单击“JUnit JaCoCo 测试”并详细查看它们。LambdaTest 已录制视频。所以你也可以看到视觉效果。

通过 JaCoCo Maven 插件生成代码覆盖率报告：

1. 现在，由于我们已经在 LambdaTest Selenium Grid 上运行了 JUnit 测试用例，代码覆盖率报告应该通过 JaCoCo Maven 插件生成。
2. 只需转到目标文件夹，您会发现报告的二进制格式为jacoco.exec.
3. target/site/jacoco您可以在文件夹中查看 HTML、CSV 和 XML 格式的代码覆盖率报告，分别为index.html, jacoco.csv、 和。jacoco.xml
4. 现在您还可以尝试提高代码覆盖率分数并分析生成的代码覆盖率报告。

结论

在本文中，我们了解了如何使用 JaCoCo-Maven 插件为 Java 项目生成代码覆盖率报告。我们还利用 LambdaTest Selenium Grid 云的敏捷性和可扩展性来自动化测试流程。但请记住，100% 的代码覆盖率并不代表有效的测试，因为它只显示测试期间执行的代码量。

标签：代码覆盖率,java代码覆盖率报告,jacoco-maven 来源：

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。