Testng 简明教程

TestNG - Quick Guide

TestNG - Overview

测试是对应用程序功能进行检查的过程，以确保其按要求工作。单元测试在开发人员级别发挥作用，在这里采取适当的措施来测试每个单独的实体（类或方法），以确保最终产品符合要求。

与任何其他测试框架相比，JUnit 已促使开发人员理解测试（尤其是单元测试）的用处。通过利用相当简单、实用且严格的架构，JUnit 已能够“感染”大量的开发人员。仔细阅读我们关于 JUnit 的教程，以很好地理解它的特性。与此同时，JUnit 也有一些缺点，如下列出 −

  1. 最初设计为仅启用单元测试，现在用于各种测试。

  2. Cannot do dependency testing.

  3. Poor configuration control (setUp/tearDown).

  4. 侵入式（强制你扩展类，并以某种方式命名你的方法）。

  5. 静态编程模型（强迫你无谓地重新编译）。

  6. 在复杂项目中管理不同的测试套件可能非常棘手。

What is TestNG?

根据其文档，对 TestNG 的定义如下 -

TestNG 是受 JUnit 和 NUnit 启发的测试框架，但引入了一些使其更强大且更易于使用的新功能。

TestNG 是一个开源自动化测试框架；其中 NG 表示下一代。TestNG 类似于 JUnit（特别是 JUnit 4），但它不是 JUnit 扩展。它受 JUnit 启发。它的设计目标是比 JUnit 更优秀，尤其是在测试集成类时。TestNG 的创建者是 Cedric Beust。

TestNG 消除了旧框架的大部分限制，使得开发人员能够编写更灵活且功能更强大的测试。由于它大量借用 Java 注解（在 JDK 5.0 中引入）来定义测试，它还可以向您展示如何在真实生产环境中使用 Java 语言的这一新特性。

TestNG Features

  1. Supports annotations.

  2. TestNG 使用更多 Java 和 OO 特性。

  3. 支持测试集成类（例如，默认情况下，不必为每个测试方法都创建一个新的测试类实例）。

  4. 将编译时的测试代码与运行时的配置/数据信息分开。

  5. Flexible runtime configuration.

  6. 引入“测试组”。一旦你编译了你的测试，你可以要求 TestNG 只运行所有的“前端”测试，或者“快速”、“慢速”、“数据库”测试等等。

  7. 支持相关的测试方法、并行测试、负载测试和部分故障。

  8. Flexible plug-in API.

  9. 支持多线程测试。

TestNG - Environment

TestNG 是一个 Java 框架，因此第一个要求是在你的机器中安装了 JDK。

System Requirement

JDK

1.5 or above.

Memory

No minimum requirement.

Disk Space

No minimum requirement.

Operating System

No minimum requirement.

Step 1 - Verify Java Installation in Your Machine

打开控制台，并根据系统中安装的操作系统执行 java 命令。

OS

Task

Command

Windows

Open Command Console

c:> java -version

Linux

Open Command Terminal

$ java -version

Mac

Open Terminal

machine:~ joseph$ java -version

让我们验证所有操作系统的输出 −

OS

Output

Windows

java 版本 "1.7.0_25"Java™ SE Runtime Environment (构建 1.7.0_25-b15)Java HotSpot™ 64 位服务器 VM (构建 23.25-b01，混合模式)

Linux

java 版本 "1.7.0_25"Java™ SE Runtime Environment (构建 1.7.0_25-b15)Java HotSpot™ 64 位服务器 VM (构建 23.25-b01，混合模式)

Mac

java 版本 "1.7.0_25"Java™ SE Runtime Environment (构建 1.7.0_25-b15)Java HotSpot™ 64 位服务器 VM (构建 23.25-b01，混合模式)

如果你没有 Java，请从 https://www.oracle.com/technetwork/java/javase/downloads/index.html 安装 Java 软件开发工具包 (SDK)。我们假设 Java 1.7.0_25 即本教程的已安装版本。

Step 2: Set JAVA Environment

将 JAVA_HOME 环境变量设置为你机器上安装 Java 的基本目录位置。例如，

OS

Output

Windows

将环境变量 JAVA_HOME 设置为 C:\Program Files\Java\jdk1.7.0_25。

Linux

Export JAVA_HOME=/usr/local/java-current.

Mac

Export JAVA_HOME=/Library/Java/Home.

将 Java 编译器位置追加到系统路径中。

OS

Output

Windows

在系统变量 Path 的末尾追加字符串 C:\Program Files\Java\jdk1.7.0_25\bin。

Linux

Export PATH=$PATH:$JAVA_HOME/bin/

Mac

Not required

如上所述，使用命令 java -version 验证 Java 安装。

Step 3: Download TestNG Archive

从 http://www.testng.org 下载最新版本的 TestNG jar 文件。在编写本教程时，我们下载了 testng-6.8.jar 并将其复制到了 C:\> TestNG 文件夹。

OS

Archive name

Windows

testng-6.8.jar

Linux

testng-6.8.jar

Mac

testng-6.8.jar

Step 4: Set TestNG Environment

将 TESTNG_HOME 环境变量设置为你机器上存储 TestNG jar 的基本目录位置。下表显示了如何设置 Windows、Linux 和 Mac 中的环境变量，假设我们已将 testng-6.8.jar 存储在位置 C:\>TestNG 中。

OS

Description

Windows

将环境变量 TESTNG_HOME 设置为 C:\TESTNG。

Linux

Export TESTNG_HOME=/usr/local/TESTNG

Mac

Export TESTNG_HOME=/Library/TESTNG

Step 5: Set CLASSPATH Variable

将 CLASSPATH 环境变量设置为你 TestNG jar 位置。

OS

Description

Windows

将环境变量 CLASSPATH 设置为 %CLASSPATH%;%TESTNG_HOME%\testng-6.8.jar。

Linux

Export CLASSPATH=$CLASSPATH:$TESTNG_HOME/testng-6.8.jar.

Mac

Export CLASSPATH=$CLASSPATH:$TESTNG_HOME/testng-6.8.jar.

Step 6: Test TestNG Setup

在 C:>TestNG_WORKSPACE. 处创建一个名为 TestNGSimpleTest 的 Java 类文件。

import org.testng.annotations.Test;
import static org.testng.Assert.assertEquals;

public class TestNGSimpleTest {
   @Test
   public void testAdd() {
      String str = "TestNG is working fine";
      AssertEquals("TestNG is working fine", str);
   }
}

TestNG 可以通过多种不同方式调用 -

  1. With a testng.xml file.

  2. With ANT.

  3. From the command line.

让我们使用 testng.xml 文件调用。在 C:>TestNG_WORKSPACE 中创建一个名为 testng.xml 的 xml 文件来执行测试用例。

<?xml version = "1.0" encoding = "UTF-8"?>
<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd" >

<suite name = "Suite1">
   <test name = "test1">
      <classes>
         <class name = "TestNGSimpleTest"/>
      </classes>
   </test>
</suite>

Step 7: Verify the Result

按照如下方式使用 javac 编译器编译类 −

C:\TestNG_WORKSPACE>javac TestNGSimpleTest.java

现在，调用 testng.xml 以查看结果 -

C:\TestNG_WORKSPACE>java -cp "C:\TestNG_WORKSPACE" org.testng.TestNG testng.xml

验证输出。

===============================================
Suite1
Total tests run: 1, Failures: 0, Skips: 0
===============================================

TestNG - Writing Tests

在 TestNG 中编写测试基本上涉及以下步骤 -

  1. 编写测试的业务逻辑并在你的代码中插入 TestNG 注解。

  2. 在 testng.xml 文件或 build.xml 中添加有关测试的信息（例如，类名、你希望运行的组等）。

  3. Run TestNG.

在这里，我们将看到一个使用 POJO 类、业务逻辑类和一个由 TestNG 运行的测试 xml 的 TestNG 测试的完整示例。

在 C:&gt;TestNG_WORKSPACE 中创建 EmployeeDetails.java ，它是一个 POJO 类。

public class EmployeeDetails {

   private String name;
   private double monthlySalary;
   private int age;

   // @return the name

   public String getName() {
      return name;
   }

   // @param name the name to set

   public void setName(String name) {
      this.name = name;
   }

   // @return the monthlySalary

   public double getMonthlySalary() {
      return monthlySalary;
   }

   // @param monthlySalary the monthlySalary to set

   public void setMonthlySalary(double monthlySalary) {
      this.monthlySalary = monthlySalary;
   }

   // @return the age

   public int getAge() {
      return age;
   }

   // @param age the age to set

   public void setAge(int age) {
      this.age = age;
   }
}

EmployeeDetails 类用于 -

  1. 获取/设置员工姓名值。

  2. 获取/设置员工月薪值。

  3. 获取/设置员工年龄值。

在 C:&gt;TestNG_WORKSPACE 中创建 EmpBusinessLogic.java ，其中包含业务逻辑。

public class EmpBusinessLogic {

   // Calculate the yearly salary of employee
   public double calculateYearlySalary(EmployeeDetails employeeDetails) {
      double yearlySalary = 0;
      yearlySalary = employeeDetails.getMonthlySalary() * 12;
      return yearlySalary;
   }

   // Calculate the appraisal amount of employee
   public double calculateAppraisal(EmployeeDetails employeeDetails) {

      double appraisal = 0;

      if(employeeDetails.getMonthlySalary() < 10000) {
         appraisal = 500;

      } else {
         appraisal = 1000;
      }

      return appraisal;
   }
}

EmpBusinessLogic 类用于计算 -

  1. 员工的年薪。

  2. 员工的评估金额。

现在，让我们在 C:\>TestNG_WORKSPACE 中创建一个名为 TestEmployeeDetails.java 的 TestNG 类。TestNG 类是一个包含至少一个 TestNG 注解的 Java 类。此类包含要测试的测试用例。TestNG 测试可以通过 @BeforeXXX 和 @AfterXXX 注解进行配置（我们将在 TestNG - Execution Procedure 一章中看到这一点），它允许在某个点之前和之后执行一些 Java 逻辑。

import org.testng.Assert;
import org.testng.annotations.Test;

public class TestEmployeeDetails {
   EmpBusinessLogic empBusinessLogic = new EmpBusinessLogic();
   EmployeeDetails employee = new EmployeeDetails();

   @Test
   public void testCalculateAppriasal() {

      employee.setName("Rajeev");
      employee.setAge(25);
      employee.setMonthlySalary(8000);

      double appraisal = empBusinessLogic.calculateAppraisal(employee);
      Assert.assertEquals(500, appraisal, 0.0, "500");
   }

   // Test to check yearly salary
   @Test
   public void testCalculateYearlySalary() {

      employee.setName("Rajeev");
      employee.setAge(25);
      employee.setMonthlySalary(8000);

      double salary = empBusinessLogic.calculateYearlySalary(employee);
      Assert.assertEquals(96000, salary, 0.0, "8000");
   }
}

TestEmployeeDetails 类用于测试 EmpBusinessLogic 类的方法。它执行以下操作 -

  1. 测试员工的年薪。

  2. 测试员工的评估金额。

在运行测试前，必须使用一个特殊的 XML 文件（通常名为 testng.xml）来配置 TestNG。该文件的语法非常简单，其内容如下所示。在 C:&gt;TestNG_WORKSPACE 中创建该文件。

<?xml version = "1.0" encoding = "UTF-8"?>
<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd" >

<suite name = "Suite1">
   <test name = "test1">
      <classes>
         <class name = "TestEmployeeDetails"/>
      </classes>
   </test>
</suite>

上述文件的详细信息如下：

  1. 一个套件由一个 XML 文件表示。它可以包含一个或多个测试，并由 <suite> 标记定义。

  2. <test> 标记表示一个测试，可以包含一个或多个 TestNG 类。

  3. <class> 标记表示一个 TestNG 类。它是包含至少一个 TestNG 注解的 Java 类。它可以包含一个或多个测试方法。

使用 javac 编译测试用例类。

C:\TestNG_WORKSPACE>javac EmployeeDetails.java EmpBusinessLogic.java TestEmployeeDetails.java

现在使用以下命令对 TestNG 进行测试：

C:\TestNG_WORKSPACE>java -cp "C:\TestNG_WORKSPACE" org.testng.TestNG testng.xml

如果一切顺利，你应该可以在控制台中看到自己测试的结果。此外，TestNG 会在当前目录中自动创建一个名为 test-output 的文件夹，并在其中创建一个非常不错的 HTML 报告。如果你将其打开并加载 index.html，你将会看到一个与下图中类似的页面：

writing tests

TestNG - Basic Annotations

在 JUnit 3 中指示测试方法的传统方法是用 test 为其名称加前缀。这是一种非常有效的方法，可以将类中的某些方法标记为具有特殊含义，但该命名方式的可扩展性不是很好（如果我们想要为不同的框架添加更多标记，该怎么办？），并且不够灵活（如果我们想要向测试框架传递其他参数，该怎么办？）。

注解正式添加到 JDK 5 中的 Java 语言，并且 TestNG 选择使用注解来注释测试类。

以下是 TestNG 支持的注解列表：

Sr.No.

Annotation & Description

1

@BeforeSuite 带注解的方法将在该套件中所有测试运行之前仅运行一次。

2

@AfterSuite 带注解的方法将在该套件中所有测试运行之后仅运行一次。

3

@BeforeClass 带注解的方法将在调用当前类中的第一个测试方法之前仅运行一次。

4

@AfterClass 带注解的方法将在调用当前类中的所有测试方法之后仅运行一次。

5

@BeforeTest 带注解的方法将在运行属于 <test> 标记内的类的任何测试方法之前运行。

6

@AfterTest 带注解的方法将在运行属于 <test> 标记内的类的所有测试方法之后运行。

7

@BeforeGroups 此配置方法将在之前运行的组列表。保证在属于任何这些组的第一个测试方法调用之前不久运行该方法。

8

@AfterGroups 此配置方法将在之后运行的组列表。保证在属于任何这些组的最后一个测试方法调用之后不久运行该方法。

9

@BeforeMethod 说明注释方法将在每个测试方法之前运行。

10

@AfterMethod 说明注释方法将在每个测试方法之后运行。

11

@DataProvider 将方法标记为为测试方法提供数据的方法。说明注释方法必须返回一个 Object[][ ]，其中每个 Object[ ] 可以指派给测试方法的参数列表。想要从此 DataProvider 接收数据而需使用等于此说明名称的数据提供程序名称的 @Test 方法。

12

@Factory 将方法标记为返回将由 TestNG 用作测试类的对象的方法。该方法必须返回 Object[ ]。

13

@Listeners 定义测试类上的侦听器。

14

@Parameters 描述如何向 @Test 方法传递参数。

15

@Test 将类或方法作为测试的一部分进行标记。

Benefits of Using Annotations

以下是使用说明的优点：

  1. TestNG 通过查找说明来识别它感兴趣的方法。因此，方法名称不受任何模式或格式的限制。

  2. 我们可以向说明传递其他参数。

  3. 说明类型很强，因此编译器会立即标记任何错误。

  4. 测试类不再需要扩展任何内容（如 JUnit 3 的 TestCase）。

TestNG - Excecution Procedure

本章介绍了 TestNG 中方法的执行过程。它介绍了所调用方法的顺序。以下是 TestNG 测试 API 方法的执行过程，并带有一个示例。

在 C:&gt;TestNG_WORKSPACE 中创建一个名为 TestngAnnotation.java 的 java 类文件来测试说明。

import org.testng.annotations.Test;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeTest;
import org.testng.annotations.AfterTest;
import org.testng.annotations.BeforeSuite;
import org.testng.annotations.AfterSuite;

public class TestngAnnotation {
   // test case 1
   @Test
   public void testCase1() {
      System.out.println("in test case 1");
   }

   // test case 2
   @Test
   public void testCase2() {
      System.out.println("in test case 2");
   }

   @BeforeMethod
   public void beforeMethod() {
      System.out.println("in beforeMethod");
   }

   @AfterMethod
   public void afterMethod() {
      System.out.println("in afterMethod");
   }

   @BeforeClass
   public void beforeClass() {
      System.out.println("in beforeClass");
   }

   @AfterClass
   public void afterClass() {
      System.out.println("in afterClass");
   }

   @BeforeTest
   public void beforeTest() {
      System.out.println("in beforeTest");
   }

   @AfterTest
   public void afterTest() {
      System.out.println("in afterTest");
   }

   @BeforeSuite
   public void beforeSuite() {
      System.out.println("in beforeSuite");
   }

   @AfterSuite
   public void afterSuite() {
      System.out.println("in afterSuite");
   }

}

接下来，让我们在 C:&gt;TestNG_WORKSPACE 中创建文件 testng.xml 来执行说明。

<?xml version = "1.0" encoding = "UTF-8"?>
<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd" >

<suite name = "Suite1">
   <test name = "test1">
      <classes>
         <class name = "TestngAnnotation"/>
      </classes>
   </test>
</suite>

使用 javac 编译测试用例类。

C:\TestNG_WORKSPACE>javac TestngAnnotation.java

现在，运行 testng.xml，这将运行所提供的测试用例类中定义的测试用例。

C:\TestNG_WORKSPACE>java org.testng.TestNG testng.xml

验证输出。

in beforeSuite
in beforeTest
in beforeClass
in beforeMethod
in test case 1
in afterMethod
in beforeMethod
in test case 2
in afterMethod
in afterClass
in afterTest
in afterSuite

===============================================
Suite
Total tests run: 2, Failures: 0, Skips: 0
===============================================

根据上述输出，执行过程如下：

  1. 首先，beforeSuite() 方法仅执行一次。

  2. 最后，afterSuite() 方法仅执行一次。

  3. 即使 beforeTest()、BeforeClass()、AfterClass() 和 afterTest() 方法也仅执行一次。

  4. beforeMethod() 方法对每个测试用例执行，但在执行测试用例之前执行。

  5. afterMethod() 方法针对每个测试用例执行，但在执行测试用例之后执行。

  6. 在 beforeMethod() 和 afterMethod() 之间，每个测试用例执行。

TestNG - Executing Tests

使用 TestNG 类执行测试用例。此类是 TestNG 框架中运行测试的主要入口点。用户可以创建自己的 TestNG 对象并以多种不同方式调用它，例如：

  1. On an existing testng.xml.

  2. 对于完全由 Java 创建的合成 testng.xml。

  3. 通过直接设置测试类。

你还可以定义要包括或排除哪些组、分配参数等。命令行参数为：

  1. -d outputdir：指定输出目录。

  2. -testclass class_name：指定一个或多个类名。

  3. -testjar jar_name：指定包含测试的 jar。

  4. -sourcedir src1;src2：; 分隔的源目录列表（仅在使用 javadoc 注解时使用）。

  5. -target

  6. -groups

  7. -testrunfactory

  8. -listener

我们将在下面的示例中使用现有的 testng.xml 创建 TestNG 对象。

Create a Class

在 C:&gt;TestNG_WORKSPACE 中创建一个要测试的 java 类，例如 MessageUtil.java 。

/*
* This class prints the given message on console.
*/

public class MessageUtil {

   private String message;

   //Constructor
   //@param message to be printed
   public MessageUtil(String message) {
      this.message = message;
   }

   // prints the message
   public String printMessage() {
      System.out.println(message);
      return message;
   }
}

Create Test Case Class

  1. 创建一个 java 测试类，例如 SampleTest.java 。

  2. 将 testPrintMessage() 测试方法添加到你的测试类。

  3. 在方法 testPrintMessage() 中添加一个注释 @Test。

  4. 实现测试条件，并使用 TestNG 的 assertEquals API 检查条件。

在 C:&gt;TestNG_WORKSPACE 中创建一个名为 SampleTest.java 的 java 类文件。

import org.testng.Assert;
import org.testng.annotations.Test;

public class SampleTest {

   String message = "Hello World";
   MessageUtil messageUtil = new MessageUtil(message);

   @Test
   public void testPrintMessage() {
      Assert.assertEquals(message, messageUtil.printMessage());
   }
}

Create testng.xml

接下来，让我们在 C:&gt;TestNG_WORKSPACE 中创建 testng.xml 文件，以执行测试用例。此文件以 XML 捕获了你的整个测试。此文件使你可以在一个文件中轻松描述所有测试套件及其参数，你可以将其签入你的代码仓库或通过电子邮件发送给同事。它还使您可以轻松提取你的测试的子集或拆分几个运行时配置（例如，testngdatabase.xml 将仅运行对你的数据库进行施压的测试）。

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

<suite name = "Sample test Suite">
   <test name = "Sample test">
      <classes>
         <class name = "SampleTest" />
      </classes>
   </test>
</suite>

使用 javac 编译测试用例。

C:\TestNG_WORKSPACE>javac MessageUtil.java SampleTest.java

现在，运行 testng.xml，它将运行在 <test> 标签中定义的测试用例。

C:\TestNG_WORKSPACE>java -cp "C:\TestNG_WORKSPACE" org.testng.TestNG testng.xml

验证输出。

Hello World

===============================================
Sample test Suite
Total tests run: 1, Failures: 0, Skips: 0
===============================================

TestNG - Suite Test

test suite 是一个测试用例集合，用于测试软件程序的行为或一组行为。在 TestNG 中，我们不能在测试源代码中定义套件，但它由一个 XML 文件表示，因为套件是执行的特性。它还允许灵活配置要运行的测试。套件可以包含一个或多个测试，并由 <suite> 标签定义。

<suite> 是 testng.xml 的根标签。它描述了一个测试套件，该套件又由几个 <test> 部分组成。

下表列出了 <suite> 接受的所有合法属性。

Sr.No.

Attribute & Description

1

name 此套件的名称。它是一个 mandatory 属性。

2

verbose 此运行的级别或详细程度。

3

parallel TestNG 是否应该运行不同的线程来运行此套件。

4

thread-count 启用并行模式后要使用的线程数（否则会忽略）。

5

annotations 你在测试中使用的注释类型。

6

time-out 此测试中找到的所有测试方法上都将使用的默认超时。

在本章中，我们将向你展示一个有两个测试类 Test1 和 Test2 的示例，以使用测试套件一起运行它们。

Create a Class

创建一个要测试的 java 类，比如，在 C:&gt;JUNIT_WORKSPACE 中创建 MessageUtil.java 。

/*
* This class prints the given message on console.
*/

public class MessageUtil {
   private String message;

   // Constructor
   // @param message to be printed
   public MessageUtil(String message) {
      this.message = message;
   }

   // prints the message
   public String printMessage() {
      System.out.println(message);
      return message;
   }

   // add "Hi!" to the message
   public String salutationMessage() {
      message = "Hi!" + message;
      System.out.println(message);
      return message;
   }
}

Create Test Case Classes

在 C:&gt;TestNG_WORKSPACE 中创建一个名为 Test1.java 的 java 类文件。

import org.testng.Assert;
import org.testng.annotations.Test;

public class Test1 {
   String message = "Manisha";
   MessageUtil messageUtil = new MessageUtil(message);

   @Test
   public void testPrintMessage() {
      System.out.println("Inside testPrintMessage()");
      Assert.assertEquals(message, messageUtil.printMessage());
   }
}

在 C:&gt;TestNG_WORKSPACE 中创建一个名为 Test2.java 的 java 类文件。

import org.testng.Assert;
import org.testng.annotations.Test;

public class Test2 {
   String message = "Manisha";
   MessageUtil messageUtil = new MessageUtil(message);

   @Test
   public void testSalutationMessage() {
      System.out.println("Inside testSalutationMessage()");
      message = "Hi!" + "Manisha";
      Assert.assertEquals(message,messageUtil.salutationMessage());
   }
}

现在，我们在 C:&gt;TestNG_WORKSPACE 中编写 testng.xml，它将包含 <suite> 标记，如下所示 −

<?xml version = "1.0" encoding = "UTF-8"?>
<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd" >

<suite name = "Suite1">

   <test name = "exampletest1">
      <classes>
         <class name = "Test1" />
      </classes>
   </test>

   <test name = "exampletest2">
      <classes>
         <class name = "Test2" />
      </classes>
   </test>

</suite>

Suite1 包含 exampletest1 和 exampletest2 。

使用 javac 编译所有 Java 类。

C:\TestNG_WORKSPACE>javac MessageUtil.java Test1.java Test2.java

现在，运行 testng.xml，这将运行所提供的测试用例类中定义的测试用例。

C:\TestNG_WORKSPACE>java -cp "C:\TestNG_WORKSPACE" org.testng.TestNG testng.xml

验证输出。

Inside testPrintMessage()
Manisha
Inside testSalutationMessage()
Hi!Manisha

===============================================
Suite1
Total tests run: 2, Failures: 0, Skips: 0
===============================================

您也可以检查 test-output 文件夹。在 Suite1 文件夹下，可以看到创建了两个 html 文件，exampletest1.html 和 exampletest2.html，它们将如下所示 −

suite test1
suite test2

TestNG - Ignore a Test

有时，我们的代码没有准备就绪，并且编写来测试该方法/代码的测试用例将会失败。在这种情况下，注释 @Test(enabled = false) 有助于禁用此测试用例。

如果使用 @Test(enabled = false) 对测试方法进行注释，那么将绕过尚未准备好要测试的测试用例。

现在，让我们看看 @Test(enabled = false) 的运作方式。

Create a Class

在 C:&gt;TestNG_WORKSPACE 中创建一个要测试的 java 类，例如 MessageUtil.java 。

/*
* This class prints the given message on console.
*/

public class MessageUtil {

   private String message;

   //Constructor
   //@param message to be printed
   public MessageUtil(String message) {
      this.message = message;
   }

   // prints the message
   public String printMessage() {
      System.out.println(message);
      return message;
   }

   // add "Hi!" to the message
   public String salutationMessage() {
      message = "Hi!" + message;
      System.out.println(message);
      return message;
   }
}

Create Test Case Class

  1. 创建一个 Java 测试类，例如 IgnoreTest.java 。

  2. 将测试方法 testPrintMessage() 和 testSalutationMessage() 添加到测试类中。

  3. 将注释 @Test(enabled = false) 添加到方法 testPrintMessage() 中。

在 C:&gt;TestNG_WORKSPACE 中创建一个名为 IgnoreTest.java 的 Java 类文件。

import org.testng.Assert;
import org.testng.annotations.Test;

public class IgnoreTest {
   String message = "Manisha";
   MessageUtil messageUtil = new MessageUtil(message);

   @Test(enabled = false)
   public void testPrintMessage() {
      System.out.println("Inside testPrintMessage()");
      message = "Manisha";
      Assert.assertEquals(message, messageUtil.printMessage());
   }

   @Test
   public void testSalutationMessage() {
      System.out.println("Inside testSalutationMessage()");
      message = "Hi!" + "Manisha";
      Assert.assertEquals(message, messageUtil.salutationMessage());
   }
}

Create testng.xml

在 C:&gt;TestNG_WORKSPACE 中创建 testng.xml 来执行测试用例。

<?xml version = "1.0" encoding = "UTF-8"?>
<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd" >

<suite name = "Suite1">
   <test name = "test1">
      <classes>
         <class name = "IgnoreTest" />
      </classes>
   </test>
</suite>

使用 javac 编译 MessageUtil 和测试用例类。

C:\TestNG_WORKSPACE>javac MessageUtil.java IgnoreTest.java

现在，运行 testng.xml，它不会运行在提供的测试用例类中定义的测试用例 testPrintMessage()。

C:\TestNG_WORKSPACE>java -cp "C:\TestNG_WORKSPACE" org.testng.TestNG testng.xml

验证输出。未测试测试用例 testPrintMessage()。

Inside testSalutationMessage()
Hi!Manisha

===============================================
Suite1
Total tests run: 1, Failures: 0, Skips: 0
===============================================

您还可以忽略将在下一章中讨论的一组测试。

TestNG - Group Test

组测试是 TestNG 中一项新颖的功能，在 JUnit 框架中不存在。它允许您将方法分派到适当的部分，并对测试方法执行复杂的组装。

您不仅可以声明属于组的方法，还可以指定包含其他组的组。然后，可以调用 TestNG 并要求 TestNG 包含一组特定的组（或正则表达式），同时排除另一组。

组测试提供了最大程度的灵活性，以划分您的测试，如果您想成批运行两组不同的测试，则不需要重新编译任何内容。

群组在 testng.xml 文件中使用 <groups> 标记指定。它可以在 <test> 或 <suite> 标记下找到。<suite> 标记中指定的群组适用于其下的所有 <test> 标记。

现在，让我们举个例子来看看群组测试如何工作。

Create a Class

创建一个待测试的 java 类，例如 MessageUtil.java 中的 C:&gt; TestNG_WORKSPACE 。

/*
* This class prints the given message on console.
*/
public class MessageUtil {
   private String message;

   // Constructor
   // @param message to be printed
   public MessageUtil(String message) {
      this.message = message;
   }

   // prints the message
   public String printMessage() {
      System.out.println(message);
      return message;
   }

   // add "tutorialspoint" to the message
   public String salutationMessage() {
      message = "tutorialspoint" + message;
      System.out.println(message);
      return message;
   }

   // add "www." to the message
   public String exitMessage() {
      message = "www." + message;
      System.out.println(message);
      return message;
   }
}

Create Test Case Class

  1. 创建一个 java 测试类，例如 GroupTestExample.java。

  2. 将测试方法 testPrintMessage() 和 testSalutationMessage() 添加到测试类。

  3. 将测试方法分为两类 - Check-in tests (checkintest) - 在提交新代码之前应该运行这些测试。它们通常应该很快，并且只需确保没有基本功能被破坏。 Functional tests (functest) - 这些测试应该涵盖软件的所有功能，并且每天至少运行一次，尽管理想情况下你希望连续运行它们。

在 C:&gt;TestNG_WORKSPACE 中创建名为 GroupTestExample.java 的 java 类文件。

import org.testng.Assert;
import org.testng.annotations.Test;

public class GroupTestExample {
   String message = ".com";
   MessageUtil messageUtil = new MessageUtil(message);

   @Test(groups = { "functest", "checkintest" })

   public void testPrintMessage() {
      System.out.println("Inside testPrintMessage()");
      message = ".com";
      Assert.assertEquals(message, messageUtil.printMessage());
   }

   @Test(groups = { "checkintest" })

   public void testSalutationMessage() {
      System.out.println("Inside testSalutationMessage()");
      message = "tutorialspoint" + ".com";
      Assert.assertEquals(message, messageUtil.salutationMessage());
   }

   @Test(groups = { "functest" })

   public void testingExitMessage() {
      System.out.println("Inside testExitMessage()");
      message = "www." + "tutorialspoint"+".com";
      Assert.assertEquals(message, messageUtil.exitMessage());
   }
}

Create testng.xml

在 C:&gt; TestNG_WORKSPACE 中创建 testng.xml，以执行测试用例。在这里，我们将只执行属于 functest 组的那些测试。

<?xml version = "1.0" encoding = "UTF-8"?>
<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd" >

<suite name = "Suite1">
   <test name = "test1">

      <groups>
         <run>
            <include name = "functest" />
         </run>
      </groups>

      <classes>
         <class name = "GroupTestExample" />
      </classes>

   </test>
</suite>

使用 javac 编译 MessageUtil 和测试用例类。

C:\TestNG_WORKSPACE>javac MessageUtil.java GroupTestExample.java

现在，运行 testng.xml，它将只运行方法 testPrintMessage()，因为它属于 functest 组。

C:\TestNG_WORKSPACE>java -cp "C:\TestNG_WORKSPACE" org.testng.TestNG testng.xml

验证输出。只执行方法 testPrintMessage()。

Inside testPrintMessage()
.com
Inside testExitMessage()
www..com

===============================================
Suite1
Total tests run: 2, Failures: 1, Skips: 0
===============================================

Group of Groups

群组还可以包含其他群组。这些组被称为 MetaGroups 。例如，你可能希望定义一个包含 checkintest 和 functest 的所有群组。让我们修改我们的 testng.xml 文件如下所示 -

<?xml version = "1.0" encoding = "UTF-8"?>
<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd" >
<suite name = "Suite1">
   <test name = "test1">

      <groups>

         <define name = "all">
            <include name = "functest"/>
            <include name = "checkintest"/>
         </define>

         <run>
            <include name = "all"/>
         </run>

      </groups>

      <classes>
         <class name = "GroupTestExample" />
      </classes>

   </test>
</suite>

执行上述 testng.xml 将执行所有三个测试，并将给出以下结果 -

Inside testPrintMessage()
.com
Inside testSalutationMessage()
tutorialspoint.com
Inside testExitMessage()
www.tutorialspoint.com

===============================================
Suite1
Total tests run: 3, Failures: 0, Skips: 0
===============================================

Exclusion Groups

你可以使用 <exclude> 标记忽略一个组，如下所示 -

<?xml version = "1.0" encoding = "UTF-8"?>
<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd" >
<suite name = "Suite1">
   <test name = "test1">

      <groups>
         <define name = "all">
            <exclude name = "functest"/>
            <include name = "checkintest"/>
         </define>

         <run>
            <include name = "all"/>
         </run>
      </groups>

      <classes>
         <class name = "GroupTestExample" />
      </classes>

   </test>
</suite>

TestNG - Exception Test

TestNG 提供了一个跟踪代码异常处理的选项。你可以测试一个代码是否抛出一个需要的异常。这里 expectedExceptions 参数与 @Test 注释一起使用。现在，让我们看看 @Test(expectedExceptions) 的作用。

Create a Class

创建一个待测试的 java 类，例如 C:&gt; TestNG_WORKSPACE 中的 MessageUtil.java 。在 printMessage() 方法中添加一个错误条件。

/*
* This class prints the given message on console.
*/
public class MessageUtil {

   private String message;

   //Constructor
   //@param message to be printed
   public MessageUtil(String message) {
      this.message = message;
   }

   // prints the message
   public void printMessage() {
      System.out.println(message);
      int a =0;
      int b = 1/a;
   }

   // add "Hi!" to the message
   public String salutationMessage() {
      message = "Hi!" + message;
      System.out.println(message);
      return message;
   }
}

Create Test Case Class

  1. 创建一个 java 测试类，例如 ExpectedExceptionTest.java 。

  2. 将预期的异常 ArithmeticException 添加到 testPrintMessage() 测试用例。

在 C:&gt; TestNG_WORKSPACE 中创建名为 ExpectedExceptionTest.java 的 java 类文件。

import org.testng.Assert;
import org.testng.annotations.Test;

public class ExpectedExceptionTest {
   String message = "Manisha";
   MessageUtil messageUtil = new MessageUtil(message);

   @Test(expectedExceptions = ArithmeticException.class)
   public void testPrintMessage() {
      System.out.println("Inside testPrintMessage()");
      messageUtil.printMessage();
   }

   @Test
   public void testSalutationMessage() {
      System.out.println("Inside testSalutationMessage()");
      message = "Hi!" + "Manisha";
      Assert.assertEquals(message,messageUtil.salutationMessage());
   }
}

Create Test Runner

在 C:&gt;TestNG_WORKSPACE 中创建 testng.xml 来执行测试用例。

<?xml version = "1.0" encoding = "UTF-8"?>
<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd" >

<suite name = "Suite1">
   <test name = "test1">
      <classes>
         <class name = "ExpectedExceptionTest" />
      </classes>
   </test>
</suite>

使用 javac 编译 MessageUtil 和测试用例类。

C:\TestNG_WORKSPACE>javac MessageUtil.java TestJunit.java

现在，运行测试运行器，它将运行在提供的测试用例类中定义的测试用例。

C:\TestNG_WORKSPACE>java -cp "C:\TestNG_WORKSPACE" org.testng.TestNG testng.xml

验证输出。testPrintMessage() 测试用例将通过。

Inside testPrintMessage()
Manisha
Inside testSalutationMessage()
Hi!Manisha

===============================================
Suite1
Total tests run: 2, Failures: 0, Skips: 0
===============================================

TestNG - Dependency Test

有时，您可能需要按照特定顺序在测试用例中调用方法，或者可能希望在方法之间共享某些数据和状态。此类依赖关系受 TestNG 支持，因为它支持在测试方法之间声明显式依赖关系。

TestNG 允许您使用以下方法指定依赖关系：

  1. 在 @Test 注释中使用 dependsOnMethods 特性，或

  2. 在 @Test 注释中使用 dependsOnGroups 特性。

Example Using dependsOnMethods

Create a Class

在 C:&gt;TestNG_WORKSPACE 中创建一个要测试的 java 类，例如 MessageUtil.java 。

public class MessageUtil {
   private String message;

   // Constructor
   // @param message to be printed
   public MessageUtil(String message) {
      this.message = message;
   }

   // prints the message
   public String printMessage() {
      System.out.println(message);
      return message;
   }

   // add "Hi!" to the message
   public String salutationMessage() {
      message = "Hi!" + message;
      System.out.println(message);
      return message;
   }
}

Create Test Case Class

  1. 创建一个 Java 测试类，例如 DependencyTestUsingAnnotation.java。

  2. 向您的测试类中添加测试方法 testPrintMessage() 和 testSalutationMessage()，以及 initEnvironmentTest()。

  3. 将特性 dependsOnMethods = {"initEnvironmentTest"} 添加到 testSalutationMessage() 方法的 @Test 注释中。

在 C:&gt;TestNG_WORKSPACE 中创建 Java 类文件名称 DependencyTestUsingAnnotation.java 。

import org.testng.Assert;
import org.testng.annotations.Test;

public class DependencyTestUsingAnnotation {
String message = "Manisha";
MessageUtil messageUtil = new MessageUtil(message);

   @Test
   public void testPrintMessage() {
      System.out.println("Inside testPrintMessage()");
      message = "Manisha";
      Assert.assertEquals(message, messageUtil.printMessage());
   }

   @Test(dependsOnMethods = { "initEnvironmentTest" })
   public void testSalutationMessage() {
      System.out.println("Inside testSalutationMessage()");
      message = "Hi!" + "Manisha";
      Assert.assertEquals(message, messageUtil.salutationMessage());
   }

   @Test
   public void initEnvironmentTest() {
      System.out.println("This is initEnvironmentTest");
   }
}

Create testng.xml

在 C:&gt;TestNG_WORKSPACE 中创建 testng.xml 来执行测试用例。

<?xml version = "1.0" encoding = "UTF-8"?>
<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd" >

<suite name = "Suite1">
   <test name = "test1">
      <classes>
         <class name = "DependencyTestUsingAnnotation" />
      </classes>
   </test>
</suite>

使用 javac 编译 MessageUtil 和测试用例类。

C:\TestNG_WORKSPACE>javac MessageUtil.java DependencyTestUsingAnnotation.java

现在，运行 testng.xml，它将在执行 initEnvironmentTest() 方法后才运行 testSalutationMessage() 方法。

C:\TestNG_WORKSPACE>java -cp "C:\TestNG_WORKSPACE" org.testng.TestNG testng.xml

验证输出。

This is initEnvironmentTest
Inside testPrintMessage()
Manisha
Inside testSalutationMessage()
Hi!Manisha

===============================================
Suite1
Total tests run: 3, Failures: 0, Skips: 0
===============================================

Example Using dependsOnGroups

您还可以拥有依赖于整个组的方法。我们举一个例子来说明这一点。

Create a Class

在 C:&gt;TestNG_WORKSPACE 中创建一个要测试的 java 类，例如 MessageUtil.java 。

public class MessageUtil {
   private String message;

   // Constructor
   // @param message to be printed
   public MessageUtil(String message) {
      this.message = message;
   }

   // prints the message
   public String printMessage() {
      System.out.println(message);
      return message;
   }

   // add "Hi!" to the message
   public String salutationMessage() {
      message = "Hi!" + message;
      System.out.println(message);
      return message;
   }
}

Create Test Case Class

  1. 创建一个 Java 测试类，例如 DependencyTestUsingAnnotation.java。

  2. 向您的测试类中添加测试方法 testPrintMessage() testSalutationMessage()，以及 initEnvironmentTest()，并将它们添加到组“init”中。

  3. 将特性 dependsOnMethods = {"init. "}* 添加到 testSalutationMessage() 方法的 @Test 注释中。

在 C:&gt;TestNG_WORKSPACE 中创建一个名为 DependencyTestUsingAnnotation.java 的 Java 类文件。

import org.testng.Assert;
import org.testng.annotations.Test;

public class DependencyTestUsingAnnotation {
   String message = "Manisha";
   MessageUtil messageUtil = new MessageUtil(message);

   @Test(groups = { "init" })
   public void testPrintMessage() {
      System.out.println("Inside testPrintMessage()");
      message = "Manisha";
      Assert.assertEquals(message, messageUtil.printMessage());
   }

   @Test(dependsOnGroups = { "init.*" })
   public void testSalutationMessage() {
      System.out.println("Inside testSalutationMessage()");
      message = "Hi!" + "Manisha";
      Assert.assertEquals(message, messageUtil.salutationMessage());
   }

   @Test(groups = { "init" })
   public void initEnvironmentTest() {
      System.out.println("This is initEnvironmentTest");
   }
}

在此示例中，testSalutationMessage() 被声明为依赖于任何组，匹配正则表达式“init.*”，这可确保总是在 testSalutationMessage() 之前调用方法 testPrintMessage() 和 initEnvironmentTest()。

如果依赖的方法失败，并且您对它有硬依赖关系（alwaysRun=false，这是默认值），那么依赖于它的方法不会标记为 FAIL，而是标记为 SKIP。跳过的方法将在最终报告中报告为这种状态（在 HTML 中既不是红色也不是绿色），这很重要，因为跳过的方法不一定是失败的。

Create testng.xml

在 C:&gt;TestNG_WORKSPACE 中创建 testng.xml 来执行测试用例。

<?xml version = "1.0" encoding = "UTF-8"?>
<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd" >

<suite name = "Suite1">
   <test name = "test1">
      <classes>
         <class name = "DependencyTestUsingAnnotation" />
      </classes>
   </test>
</suite>

使用 javac 编译 MessageUtil 和测试用例类。

C:\TestNG_WORKSPACE>javac MessageUtil.java DependencyTestUsingAnnotation.java

现在，运行 testng.xml，它将在执行 initEnvironmentTest() 方法后才运行 testSalutationMessage() 方法。

C:\TestNG_WORKSPACE>java -cp "C:\TestNG_WORKSPACE" org.testng.TestNG testng.xml

验证输出。

This is initEnvironmentTest
Inside testPrintMessage()
Manisha
Inside testSalutationMessage()
Hi!Manisha

===============================================
Suite1
Total tests run: 3, Failures: 0, Skips: 0
===============================================

dependsOnGroups Vs dependsOnMethods

  1. 在使用组时，我们不再会遇到重构问题。只要我们不修改 dependsOnGroups 或 groups 特性，我们的测试就会继续运行，并且正确设置了依赖关系。

  2. 每当需要在依赖关系图中添加新方法时，我们所需要做的就是将其放在正确组中，并确保它依赖于正确的组。我们不需要修改任何其他方法。

TestNG - Parameterized Test

TestNG 中另一项有趣的功能是 parametric testing 。大多数情况下，您会遇到需要大量测试的业务逻辑的情况。 Parameterized tests 允许开发人员使用不同的值反复运行同一测试。

TestNG 让您通过两种不同方式直接将参数传给测试方法 -

  1. With testng.xml

  2. With Data Providers

Passing Parameters with testng.xml

使用这种方法，您可以在 testng.xml 文件中定义简单参数，然后在源文件中引用这些参数。我们举一个示例来说明如何使用这种方法传递参数。

Create Test Case Class

  1. 创建一个 java 测试类，例如，ParameterizedTest1.java。

  2. 向测试类添加 test method parameterTest()。此方法以一个字符串作为输入参数。

  3. 向此方法添加注释 @Parameters("myName")。该参数将从 testng.xml 传递一个值，我们将在下一步中看到。

创建一个名为 ParameterizedTest1.java 的 java 类文件，放在 C:&gt;TestNG_WORKSPACE 中。

import org.testng.annotations.Parameters;
import org.testng.annotations.Test;

public class ParameterizedTest1 {
   @Test
   @Parameters("myName")
   public void parameterTest(String myName) {
      System.out.println("Parameterized value is : " + myName);
   }
}

Create testng.xml

在 C:&gt;TestNG_WORKSPACE 中创建 testng.xml 来执行测试用例。

<?xml version = "1.0" encoding = "UTF-8"?>
<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd" >

<suite name = "Suite1">
   <test name = "test1">

      <parameter name = "myName" value="manisha"/>

      <classes>
         <class name = "ParameterizedTest1" />
      </classes>

   </test>
</suite>

我们还可以在 <suite> 级别定义参数。假设我们在 <suite> 和 <test> 级别都定义了 myName。在这种情况下，常规范围规则适用。这意味着 <test> 标签内的任何类都会看到 <test> 中定义的参数值，而 testng.xml 文件中的其余类将看到 <suite> 中定义的值。

使用 javac 编译测试用例类。

C:\TestNG_WORKSPACE>javac ParameterizedTest1.java

现在，运行 testng.xml，该文件将运行 parameterTest 方法。TestNG 将尝试首先在 <test> 标签中查找名为 myName 的参数，如果找不到，它将在包含它的 <suit> 标签中搜索。

C:\TestNG_WORKSPACE>java -cp "C:\TestNG_WORKSPACE" org.testng.TestNG testng.xml

验证输出。

Parameterized value is : manisha

===============================================
Suite1
Total tests run: 1, Failures: 0, Skips: 0
===============================================

TestNG 会自动尝试将 testng.xml 中指定的值转换为参数的类型。以下为支持的类型 -

  1. String

  2. int/Integer

  3. boolean/Boolean

  4. byte/Byte

  5. char/Character

  6. double/Double

  7. float/Float

  8. long/Long

  9. short/Short

Passing Parameters with Dataproviders

当您需要传递复杂参数或需要通过 Java 创建的参数（复杂对象、从属性文件或数据库读取的对象等）时，可以使用数据提供器传递参数。

数据提供器是一个用 @DataProvider 注释的方法。此注释只有一个字符串属性：其名称。如果未提供名称，则数据提供程序的名称自动默认为方法的名称。数据提供程序返回一个对象数组。

以下示例演示了如何使用数据提供程序。第一个示例是关于将 Vector、String 或 Integer 作为参数使用 @DataProvider 的，第二个示例是关于将对象作为参数使用 @DataProvider 的。

Example 1

在这里，@DataProvider 将 Integer 和 Boolean 作为参数传递。

Create Java class

创建一个名为 PrimeNumberChecker.java 的 java 类。此类检查数字是否为质数。在 C:&gt;TestNG_WORKSPACE 中创建此类。

public class PrimeNumberChecker {
   public Boolean validate(final Integer primeNumber) {

      for (int i = 2; i < (primeNumber / 2); i++) {
         if (primeNumber % i == 0) {
            return false;
         }
      }
      return true;
   }
}

Create Test Case Class

  1. 创建一个 java 测试类，例如，ParamTestWithDataProvider1.java。

  2. 定义方法 primeNumbers()，它被定义为使用注解的数据提供者。此方法返回一个对象数组。

  3. 将测试方法 testPrimeNumberChecker() 添加到你的测试类中。此方法接受一个整数和一个布尔值作为输入参数。此方法验证传递的参数是否为素数。

  4. 将注解 @Test(dataProvider = "test1") 添加到此方法。属性 dataProvider 映射到“test1”。

在 C:&gt;TestNG_WORKSPACE 中创建一个名为 ParamTestWithDataProvider1.java 的 java 类文件。

import org.testng.Assert;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;

public class ParamTestWithDataProvider1 {
   private PrimeNumberChecker primeNumberChecker;

   @BeforeMethod
   public void initialize() {
      primeNumberChecker = new PrimeNumberChecker();
   }

   @DataProvider(name = "test1")
   public static Object[][] primeNumbers() {
      return new Object[][] {{2, true}, {6, false}, {19, true}, {22, false}, {23, true}};
   }

   // This test will run 4 times since we have 5 parameters defined
   @Test(dataProvider = "test1")
   public void testPrimeNumberChecker(Integer inputNumber, Boolean expectedResult) {
      System.out.println(inputNumber + " " + expectedResult);
      Assert.assertEquals(expectedResult, primeNumberChecker.validate(inputNumber));
   }
}

Create testng.xml

在 C:&gt;TestNG_WORKSPACE 中创建一个 testng.xml 来执行测试用例。

<?xml version = "1.0" encoding = "UTF-8"?>
<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd" >

<suite name = "Suite1">
   <test name = "test1">
      <classes>
         <class name = "ParamTestWithDataProvider1" />
      </classes>
   </test>
</suite>

使用 javac 编译测试用例类。

C:\TestNG_WORKSPACE>.javac ParamTestWithDataProvider1.java PrimeNumberChecker.java

现在，运行 testng.xml。

C:\TestNG_WORKSPACE>java -cp "C:\TestNG_WORKSPACE" org.testng.TestNG testng.xml

验证输出。

   2 true
   6 false
   19 true
   22 false
   23 true

===============================================
   Suite1
   Total tests run: 5, Failures: 0, Skips: 0
===============================================

Example 2

此处，@DataProvider 将对象作为参数传递。

Create Java class

在 C:&gt;TestNG_WORKSPACE 中创建一个 java 类 Bean.java，它是一个具有 get/set 方法的简单对象。

public class Bean {
   private String val;
   private int i;

   public Bean(String val, int i) {
      this.val = val;
      this.i = i;
   }

   public String getVal() {
      return val;
   }

   public void setVal(String val) {
      this.val = val;
   }

   public int getI() {
      return i;
   }

   public void setI(int i) {
      this.i = i;
   }
}

Create Test Case Class

  1. 创建一个 java 测试类，例如 ParamTestWithDataProvider2.java。

  2. 定义方法 primeNumbers()，它被定义为使用注解的数据提供者。此方法返回一个对象数组。

  3. 将测试方法 testMethod() 添加到你的测试类中。此方法接受一个对象 bean 作为参数。

  4. 将注解 @Test(dataProvider = "test1") 添加到此方法。属性 dataProvider 映射到“test1”。

在 C:&gt;TestNG_WORKSPACE 中创建一个名为 ParamTestWithDataProvider2.java 的 java 类文件。

import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;

public class ParamTestWithDataProvider2 {
   @DataProvider(name = "test1")
   public static Object[][] primeNumbers() {
      return new Object[][] { { new Bean("hi I am the bean", 111) } };
   }

   @Test(dataProvider = "test1")
   public void testMethod(Bean myBean) {
      System.out.println(myBean.getVal() + " " + myBean.getI());
   }
}

Create testng.xml

在 C:&gt;TestNG_WORKSPACE 中创建 testng.xml 来执行测试用例。

<?xml version = "1.0" encoding = "UTF-8"?>
<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd" >

<suite name = "Suite1">
   <test name = "test1">
      <classes>
         <class name = "ParamTestWithDataProvider2" />
      </classes>
   </test>
</suite>

使用 javac 编译测试用例类。

C:\TestNG_WORKSPACE>javac ParamTestWithDataProvider2.java Bean.java

现在，运行 testng.xml。

C:\TestNG_WORKSPACE>java -cp "C:\TestNG_WORKSPACE" org.testng.TestNG testng.xml

验证输出。

   hi I am the bean 111

===============================================
   Suite1
   Total tests run: 1, Failures: 0, Skips: 0
===============================================

TestNG - Run Junit Tests

既然你已经了解了 TestNG 及其各种测试，你现在一定很担心如何重构现有的 JUnit 代码。不必担心，因为 TestNG 提供了一种以自己的速度从 JUnit 转向 TestNG 的方法。你可以使用 TestNG 来执行现有的 JUnit 测试用例。

TestNG 可以自动识别和运行 JUnit 测试，这样你就可以将 TestNG 用作所有现有测试的运行器，并使用 TestNG 编写新的测试。你所需要做的就是将 JUnit 库放在 TestNG 类路径上，以便它可以找到和使用 JUnit 类，在 Ant 中将你的测试运行器从 JUnit 更改为 TestNG，然后在“混合”模式下运行 TestNG。这样，你可以将所有测试放在同一个项目中，甚至同一个包中，并开始使用 TestNG。此方法还允许你将现有的 JUnit 测试逐步转换为 TestNG。

让我们举个例子来演示 TestNG 的这种惊人功能。

Create JUnit Test Case Class

在 C:&gt;TestNG_WORKSPACE 中创建一个 java 类，它是一个 JUnit 测试类，TestJunit.java。

import org.junit.Test;
import static org.testng.AssertJUnit.assertEquals;

public class TestJunit {
   @Test
   public void testAdd() {
      String str = "Junit testing using TestNG";
      AssertEquals("Junit testing using TestNG",str);
   }
}

现在，我们在 C:&gt;TestNG_WORKSPACE 中编写 testng.xml，它将包含 <suite> 标记，如下所示 −

<?xml version = "1.0" encoding = "UTF-8"?>
<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd">

<suite name = "Converted JUnit suite" >
   <test name = "JUnitTests" junit="true">
      <classes>
         <class name = "TestJunit" />
      </classes>
   </test>
</suite>

要执行 JUnit 测试用例，请定义属性 junit="true"，如上例中的 xml。JUnit 测试用例类 TestJunit 在类名中定义。

对于 JUnit 4，TestNG 将使用 org.junit.runner.JUnitCore 运行器来运行你的测试。

使用 javac 编译所有 Java 类。

C:\TestNG_WORKSPACE>javac TestJunit.java

现在，运行 testng.xml，它将运行 JUnit 测试用例，如同 TestNG。

C:\TestNG_WORKSPACE>java -cp "C:\TestNG_WORKSPACE:C:\TestNG_WORKSPACE\lib\junit-4.11.jar" org.testng.TestNG testng.xml

我们在此将 junit-4.11.jar 放在 C:\TestNG_WORKSPACE\lib\junit-4.11.jar 中。

验证输出。

===============================================
   Converted JUnit suite

   Total tests run: 1, Failures: 0, Skips: 0
===============================================

TestNG - Test Results

报告是任何测试执行中最重要的部分，因为它可以帮助用户理解测试执行的结果、失败点和失败原因。另一方面，日志记录对于关注执行流或在发生任何故障时进行调试非常重要。

TestNG 默认情况下会为其测试执行生成不同类型的报告。这包括 HTML 和 XML 报告输出。TestNG 还允许其用户编写自己的报告程序并将其与 TestNG 一起使用。您还可以选择编写自己的记录器，TestNG 会在运行时通知这些记录器。

有两种方法可以使用 TestNG 生成报告：

  1. Listeners − 要实现监听器类，该类必须实现 org.testng.ITestListener 接口。当测试开始、结束、失败、跳过或通过时，TestNG 会在运行时通知这些类。

  2. Reporters − 要实现一个报告类，该类必须实现 org.testng.IReporter 接口。当整个套件运行结束时，会调用这些类。调用时会将包含整个测试运行信息的 object 传递给该类。

在本章中，我们将有四个不同的示例来演示报告和记录的四种不同情况 −

Sr.No.

Case & Example

1

Custom Logging 此示例说明如何编写你自己的记录器。

2

Custom Reporter 此示例说明如何编写你自己的报告器。

3

HTML and XML report 此示例说明 TestNG 生成的默认 HTML 和 XML 报告。

4

JUnit Reports 此示例说明如何从 TestNG 报告生成 JUnit 报告。

TestNG - Plug With ANT

在本章中，我们将演示如何使用 ANT 运行 TestNG。让我们按照下面给出的步骤进行操作 −

Step 1: Download Apache Ant

下载 Apache Ant 的最新版本

OS

Archive Name

Windows

apache-ant-1.8.4-bin.zip

Linux

apache-ant-1.8.4-bin.tar.gz

Mac

apache-ant-1.8.4-bin.tar.gz

Step 2: Set Ant Environment

设置 ANT_HOME 环境变量，指向 ANT 库存储在你机器上的基本目录位置。假设我们已将 Ant 库存储在 apache-ant-1.8.4 文件夹中。

OS

Output

Windows

将环境变量 ANT_HOME 设置为 C:\Program Files\Apache Software Foundation\apache-ant-1.8.4

Linux

Export ANT_HOME=/usr/local/apache-ant-1.8.4

Mac

Export ANT_HOME=/Library/apache-ant-1.8.4

将 Ant 编译器位置附加到系统路径，如下所示 −

OS

Description

Windows

在系统变量 Path 的末尾追加字符串 %ANT_HOME\bin 。

Linux

Export PATH=$PATH:$ANT_HOME/bin/

Mac

Not required.

Step 3: Download TestNG Archive

下载所需的 jar 文件 http://www.testng.org.

OS

Archive name

Windows

testng-6.8.jar

Linux

testng-6.8.jar

Mac

testng-6.8.jar

Step 4: Create Project Structure

  1. 在 C:&amp;gt;TestNG_WORKSPACE 中创建文件夹 TestNGWithAnt 。

  2. 在 C:&amp;gt;TestNG_WORKSPACE&gt;TestNGWithAnt 中创建文件夹 src 。

  3. 在 C:&amp;gt;TestNG_WORKSPACE&gt;TestNGWithAnt 中创建文件夹 test 。

  4. 在 C:&amp;gt;TestNG_WORKSPACE&gt;TestNGWithAnt 中创建文件夹 lib 。

  5. 在 C:&amp;gt;TestNG_WORKSPACE&gt;TestNGWithAnt&gt;src 文件夹中创建 MessageUtil 类。

/*
* This class prints the given message on console.
*/

public class MessageUtil {

   private String message;

   //Constructor
   //@param message to be printed
   public MessageUtil(String message) {
      this.message = message;
   }

   // prints the message
   public void printMessage() {
      System.out.println(message);
      return message;
   }

   // add "Hi!" to the message
   public String salutationMessage() {
      message = "Hi!" + message;
      System.out.println(message);
      return message;
   }
}

  1. 在 C:&amp;gt;TestNG_WORKSPACE&gt;TestNGWithAnt&gt;src 文件夹中创建 TestMessageUtil 类。

import org.testng.Assert;
import org.testng.annotations.Test;


public class TestMessageUtil {
   String message = "Manisha";
   MessageUtil messageUtil = new MessageUtil(message);

   @Test
   public void testPrintMessage() {
      System.out.println("Inside testPrintMessage()");
      Assert.assertEquals(message,messageUtil.printMessage());
   }

   @Test
   public void testSalutationMessage() {
      System.out.println("Inside testSalutationMessage()");
      message = "Hi!" + "Manisha";
      Assert.assertEquals(message,messageUtil.salutationMessage());
   }
}

  1. 将 testng-6.8.jar 复制到 C:&amp;gt;TestNG_WORKSPACE&gt;TestNGWithAnt&gt;lib 文件夹中。

Create ANT build.xml

首先，我们需要按如下方式定义 TestNG Ant 任务 −

<taskdef name = "testng" classname = "org.testng.TestNGAntTask">
   <classpath>
      <pathelement location = "lib/testng-6.8.jar"/>
   </classpath>
</taskdef>

接下来，我们将使用 Ant 中的 <testng> 任务来执行我们的 TestNG 测试用例。

build.xml 文件如下 −

<project name = "TestNGTest" default = "test" basedir = ".">

   <!-- Define <testng> task -->

   <taskdef name = "testng" classname = "org.testng.TestNGAntTask">
      <classpath>
         <pathelement location = "lib/testng-6.8.jar"/>
      </classpath>
   </taskdef>

   <property name = "testdir" location = "test" />
   <property name = "srcdir" location = "src" />
   <property name = "libdir" location = "lib" />
   <property name = "full-compile" value="true" />

   <path id = "classpath.base"/>
   <path id = "classpath.test">

   <fileset dir = "${libdir}">
      <include name = "**/*.jar" />
   </fileset>

   <pathelement location = "${testdir}" />
   <pathelement location = "${srcdir}" />

   <path refid = "classpath.base" />
   </path>

   <target name = "clean" >
      <delete verbose="${full-compile}">
         <fileset dir = "${testdir}" includes="**/*.class" />
      </delete>
   </target>

   <target name = "compile" depends="clean">
      <javac srcdir = "${srcdir}" destdir = "${testdir}" verbose="${full-compile}">
         <classpath refid = "classpath.test"/>
      </javac>
   </target>

   <target name = "test" depends="compile">
      <testng outputdir = "${testdir}" classpathref="classpath.test">
         <xmlfileset dir = "${srcdir}" includes="testng.xml"/>
      </testng>
   </target>

</project>

运行以下 Ant 命令。

C:\TestNG_WORKSPACE\TestNGWithAnt>ant

验证输出。

test:
   [testng] [TestNG] Running:
   [testng]   C:\TestNG_WORKSPACE\TestNGWithAnt\src\testng.xml
   [testng]
   [testng] Inside testPrintMessage()
   [testng] Manisha
   [testng] Inside testSalutationMessage()
   [testng] Hi!Manisha
   [testng]
   [testng] ===============================================
   [testng] Plug ANT test Suite
   [testng] Total tests run: 2, Failures: 0, Skips: 0
   [testng] ===============================================
   [testng]

BUILD SUCCESSFUL
Total time: 1 second

TestNG - Plug With Eclipse

要使用 Eclipse 设置 TestNG，请按照以下步骤操作 -

Step 1: Download TestNG Archive

从 http://www.testng.org 下载最新版本的 TestNG jar 文件

OS

Archive name

Windows

testng-6.8.jar

Linux

testng-6.8.jar

Mac

testng-6.8.jar

我们假定您已经将上述 JAR 文件复制到 C:\>TestNG 文件夹中。

Step 2: Set Eclipse environment

  1. 打开 Eclipse → 右键单击项目，转到属性 → 构建路径 → 配置构建路径，然后使用“添加外部 JAR”按钮将 testng-6.8.jar 添加到库中。

eclipse properties

  1. 我们假定您的 Eclipse 具有内置 TestNG 插件；如果没有，请使用更新站点获取最新版本。在您的 Eclipse IDE 中，选择帮助 / 软件更新 / 查找并安装。搜索要安装的新功能。新的远程站点。确保勾选 URL 旁边的复选框，然后单击“下一步”。Eclipse 随后将引导您完成此过程。

现在，你的 Eclipse 已经准备好开发 TestNG 测试用例。

Step 3: Verify TestNG Installation in Eclipse

  1. 在 Eclipse 中创建项目 TestNGProject（位置任意）。

  2. 在项目中创建要测试的类 MessageUtil。

/*
* This class prints the given message on console.
*/

public class MessageUtil {

   private String message;

   //Constructor
   //@param message to be printed
   public MessageUtil(String message) {
      this.message = message;
   }

   // prints the message
   public String printMessage() {
      System.out.println(message);
      return message;
   }
}

  1. 在项目中创建测试类 TestNGExample。

import org.testng.Assert;
import org.testng.annotations.Test;

public class TestNGExample {
   String message = "Hello World";
   MessageUtil messageUtil = new MessageUtil(message);

   @Test
   public void testPrintMessage() {
      Assert.assertEquals(message,messageUtil.printMessage());
   }
}

项目结构应如下所示：

proj struct

最后，通过右键单击程序并以 TestNG 运行来验证程序输出。

验证结果。

test run