TestNG - 快速指南

TestNG - Overview

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

与任何其他测试框架相比，JUnit促使开发人员了解测试的有用性，尤其是单元测试的有用性。利用相当简单，实用和严格的架构，JUnit能够“感染”大量开发人员。请查看我们的JUnit教程，以便对其功能有一个很好的理解。 JUnit同时也有一些缺点，如下所示 -

最初设计仅用于单元测试，现在用于各种测试。
不能做依赖性测试。
配置控制不佳（setUp/tearDown）。
侵入（迫使你扩展类并以某种方式命名你的方法）。
静态编程模型（强制您不必要地重新编译）。
在复杂项目中管理不同的测试套件可能非常棘手。

什么是TestNG？

根据其文件定义TestNG如下 -

TestNG is a testing framework inspired from JUnit and NUnit, but introducing some new functionalities that make it more powerful and easier to use.

TestNG是一个开源的自动化测试框架; NG表示N ext G eneration。 TestNG类似于JUnit（尤其是JUnit 4），但它不是JUnit扩展。它的灵感来自JUnit。它的设计优于JUnit，尤其是在测试集成类时。 TestNG的创建者是Cedric Beust 。

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

TestNG功能

支持注释。
TestNG使用更多Java和OO功能。
支持测试集成类（例如，默认情况下，不需要为每个测试方法创建新的测试类实例）。
将编译时测试代码与运行时配置/数据信息分开。
灵活的运行时配置
介绍'测试组'。编译完测试后，可以让TestNG运行所有“前端”测试，或“快速”，“慢速”，“数据库”测试等。
支持相关测试方法，并行测试，负载测试和部分故障。
灵活的插件API。
支持多线程测试。

TestNG - Environment

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

系统需求 (System Requirement)

JDK	1.5或以上。
Memory	没有最低要求。
磁盘空间	没有最低要求。
操作系统	没有最低要求。

步骤1 - 验证计算机中的Java安装

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

OS	任务	命令
Windows	打开命令控制台	c:\> java -version
Linux	打开命令终端	$ java -version
Mac	开放式终端	机器:~joseph $ java -version

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

OS	output
Windows	java版“1.7.0_25” Java（TM）SE运行时环境（版本1.7.0_25-b15） Java HotSpot（TM）64位服务器VM（内置23.25-b01，混合模式）
Linux	java版“1.7.0_25” Java（TM）SE运行时环境（版本1.7.0_25-b15） Java HotSpot（TM）64位服务器VM（内置23.25-b01，混合模式）
Mac	java版“1.7.0_25” Java（TM）SE运行时环境（版本1.7.0_25-b15） Java HotSpot（TM）64位服务器VM（内置23.25-b01，混合模式）

output

Windows

java版“1.7.0_25”

Java（TM）SE运行时环境（版本1.7.0_25-b15）

Java HotSpot（TM）64位服务器VM（内置23.25-b01，混合模式）

Linux

java版“1.7.0_25”

Java（TM）SE运行时环境（版本1.7.0_25-b15）

Java HotSpot（TM）64位服务器VM（内置23.25-b01，混合模式）

Mac

java版“1.7.0_25”

Java（TM）SE运行时环境（版本1.7.0_25-b15）

Java HotSpot（TM）64位服务器VM（内置23.25-b01，混合模式）

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

第2步:设置JAVA环境

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

OS	output
Windows	将环境变量JAVA_HOME设置为C:\Program Files\Java\jdk1.7.0_25。
Linux	导出JAVA_HOME =/usr/local/java-current。
Mac	导出JAVA_HOME =/Library/Java/Home。

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

OS	output
Windows	在系统变量Path的末尾附加字符串C:\Program Files\Java\jdk1.7.0_25\bin。
Linux	导出PATH = $ PATH:$ JAVA_HOME/bin/
Mac	不需要

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

第3步:下载TestNG Archive

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

OS	存档名称
Windows	testng-6.8.jar
Linux	testng-6.8.jar
Mac	testng-6.8.jar

第4步:设置TestNG环境

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

OS	描述
Windows	将环境变量TESTNG_HOME设置为C:\TESTNG。
Linux	导出TESTNG_HOME =/usr/local/TESTNG
Mac	导出TESTNG_HOME =/Library/TESTNG

第5步:设置CLASSPATH变量

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

OS	描述
Windows	将环境变量CLASSPATH设置为％CLASSPATH％;％TESTNG_HOME％\ testng-6.8.jar。
Linux	导出CLASSPATH = $ CLASSPATH:$ TESTNG_HOME/testng-6.8.jar。
Mac	导出CLASSPATH = $ CLASSPATH:$ TESTNG_HOME/testng-6.8.jar。

第6步:测试TestNG设置

在C:\》TestNG_WORKSPACE.创建名为TestNGSimpleTest的java类文件C:\》TestNG_WORKSPACE.

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可以通过几种不同的方式调用 -

使用testng.xml文件。
With ANT.
从命令行。

让我们使用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>

第7步:验证结果

使用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中编写测试基本上涉及以下步骤 -

编写测试的业务逻辑并在代码中插入TestNG注释。
在testng.xml文件或build.xml中添加有关测试的信息（例如，类名，要运行的组等）。
运行TestNG。

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

在C:\》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类用于 -

获取/设置员工姓名的值。
获取/设置员工月薪的值。
获取/设置员工年龄的值。

在C:\》TestNG_WORKSPACE创建一个包含业务逻辑的C:\》TestNG_WORKSPACE 。

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类用于计算 -

员工的年薪。
员工的评估金额。

现在，让我们在C:\“TestNG_WORKSPACE中创建一个名为TestEmployeeDetails.java的TestNG类。 TestNG类是一个包含至少一个TestNG注释的Java类。该类包含要测试的测试用例。可以通过@BeforeXXX和@AfterXXX注释来配置TestNG测试（我们将在TestNG - 执行过程一章中看到这一点），它允许在某个点之前和之后执行一些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类的方法。它做了以下 -

测试员工的年薪。
测试员工的评估金额。

在运行测试之前，必须使用特殊的XML文件（通常名为testng.xml）配置TestNG。该文件的语法非常简单，其内容如下所示。在C:\》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>

上述文件的详情如下 -

套件由一个XML文件表示。它可以包含一个或多个测试，并由标记定义。
Tag 表示一个测试，可以包含一个或多个TestNG类。
标记表示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，您将看到类似于下图中的页面 -

TestNG - Basic Annotations

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

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

以下是TestNG支持的注释列表 -

Sr.No.	注释和说明
1	@BeforeSuite 带注释的方法将在此套件中的所有测试运行之前运行一次。
2	@AfterSuite 在此套件中的所有测试运行后，带注释的方法将仅运行一次。
3	@BeforeClass 在调用当前类中的第一个测试方法之前，带注释的方法只运行一次。
4	@AfterClass 在当前类中的所有测试方法运行后，带注释的方法将仅运行一次。
5	@BeforeTest 在运行属于标记内的类的任何测试方法之前，将运行带注释的方法。
6	@AfterTest 在运行了属于标记内的类的所有测试方法之后，将运行带注释的方法。
7	@BeforeGroups 此配置方法之前将运行的组列表。保证在调用属于任何这些组的第一个测试方法之前不久运行此方法。
8	@AfterGroups 此配置方法将在其后运行的组列表。保证在调用属于任何这些组的最后一个测试方法后不久运行此方法。
9	@BeforeMethod 带注释的方法将在每个测试方法之前运行。
10	@AfterMethod 带注释的方法将在每个测试方法之后运行。
11	@DataProvider 将方法标记为为测试方法提供数据。带注释的方法必须返回Object [] []，其中每个Object []都可以分配测试方法的参数列表。想要从此DataProvider接收数据的@Test方法需要使用dataProvider名称等于此批注的名称。
12	@Factory 将方法标记为工厂，返回将由TestNG用作Test类的对象。该方法必须返回Object []。
13	@Listeners 在测试类上定义侦听器。
14	@Parameters 描述如何将参数传递给@Test方法。
15	@Test 将类或方法标记为测试的一部分。

使用注释的好处

以下是使用注释的一些好处 -

TestNG通过查找注释来识别它感兴趣的方法。因此，方法名称不限于任何模式或格式。
我们可以将其他参数传递给注释。
注释是强类型的，因此编译器会立即标记任何错误。
测试类不再需要扩展任何东西（例如TestCase，对于JUnit 3）。

TestNG - Excecution Procedure

本章介绍了TestNG中方法的执行过程。它解释了所谓方法的顺序。以下是TestNG测试API方法的执行过程和示例。

在C:\》TestNG_WORKSPACE创建一个java类文件名C:\》TestNG_WORKSPACE来测试注释。

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:\》TestNG_WORKSPACE创建文件C:\》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 = "TestngAnnotation"/>
      </classes>
   </test>
</suite>

使用javac编译测试用例类。

C:\TestNG_WORKSPACE>javac TestngAnnotation.java

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

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
===============================================

根据以上输出，执行程序如下 -

首先，beforeSuite（）方法只执行一次。
最后，afterSuite（）方法只执行一次。
甚至方法beforeTest（），beforeClass（），afterClass（）和afterTest（）方法也只执行一次。
beforeMethod（）方法为每个测试用例执行但在执行测试用例之前。
afterMethod（）方法为每个测试用例执行但在执行测试用例之后。
在beforeMethod（）和afterMethod（）之间，每个测试用例都会执行。

TestNG - Executing Tests

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

在现有的testng.xml上。
在合成的testng.xml上，完全由Java创建。
通过直接设置测试类。

您还可以定义要包含或排除的组，分配参数等。命令行参数是 -

-d outputdir:指定输出目录。
-testclass class_name:指定一个或多个类名。
-testjar jar_name:指定包含测试的jar。
-sourcedir src1; src2 :; 分隔的源目录列表（仅在使用javadoc注释时使用）。
-target
-groups
-testrunfactory
-listener

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

创建一个类 (Create a Class)

在C:\》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)

创建一个java测试类，比如SampleTest.java 。
将测试方法testPrintMessage（）添加到测试类。
向方法testPrintMessage（）添加注释@Test。
使用TestNG的assertEquals API实现测试条件并检查条件。

在C:\》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:\》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，它将运行标记中定义的测试用例。

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文件表示，因为套件是执行的特征。它还允许灵活配置要运行的tests 。套件可以包含一个或多个测试，并由“suite”标签定义。

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

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

Sr.No.	属性和描述
1	name 这个套房的名称。这是一个mandatory属性。
2	verbose 此次运行的级别或详细程度。
3	parallel TestNG是否应运行不同的线程来运行此套件。
4	thread-count 如果启用了并行模式，则使用的线程数（以其他方式忽略）。
5	annotations 您在测试中使用的注释类型。
6	time-out 将在此测试中找到的所有测试方法上使用的默认超时。

在本章中，我们将向您展示一个示例，它具有两个测试类Test1和Test2，可以使用Test Suite一起运行。

创建一个类 (Create a Class)

在C:\》JUNIT_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;
   }
}

创建测试用例类

在C:\》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:\》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:\》TestNG_WORKSPACE ，其中包含”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，它将运行在提供的Test Case类中定义的测试用例。

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，如下所示 -

TestNG - Ignore a Test

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

如果使用@Test(enabled = false)注释测试方法，则会绕过未准备好测试的测试用例。

现在，让我们看看@Test（enabled = false）。

创建一个类 (Create a Class)

在C:\》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)

创建一个java测试类，比如IgnoreTest.java 。
将测试方法testPrintMessage（）和testSalutationMessage（）添加到测试类中。
将注释@Test（enabled = false）添加到方法testPrintMessage（）。

在C:\》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:\》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（），提供Test Case类中定义的测试用例。

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.xml文件中指定组。它可以在或标签下找到。标记中指定的组适用于下面的所有标记。

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

创建一个类 (Create a Class)

在C:\》 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 "iowiki" to the message
   public String salutationMessage() {
      message = "iowiki" + 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)

创建一个java测试类，比如GroupTestExample.java。
将测试方法testPrintMessage（）和testSalutationMessage（）添加到测试类中。
将测试方法分为两类 -
- Check-in tests (checkintest) - 应在提交新代码之前运行这些测试。它们通常应该很快并确保没有基本功能被破坏。
- Functional tests (functest) - 这些测试应该涵盖您软件的所有功能，并且每天至少运行一次，尽管理想情况下您希望连续运行它们。

在C:\》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 = "iowiki" + ".com";
      Assert.assertEquals(message, messageUtil.salutationMessage());
   }
   @Test(groups = { "functest" })
   public void testingExitMessage() {
      System.out.println("Inside testExitMessage()");
      message = "www." + "iowiki"+".com";
      Assert.assertEquals(message, messageUtil.exitMessage());
   }  
}

Create testng.xml

在C:\》 TestNG_WORKSPACE创建testng.xml，以执行测试用例。在这里，我们将只执行那些属于functest组的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
===============================================

小组

组还可以包括其他组。这些组称为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()
iowiki.com
Inside testExitMessage()
www.iowiki.com
===============================================
Suite1
Total tests run: 3, Failures: 0, Skips: 0
===============================================

排除组

您可以使用标记忽略组，如下所示 -

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

在C:\》 TestNG_WORKSPACE创建一个要测试的java类，比如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)

创建一个java测试类，比如ExpectedExceptionTest.java 。
将预期的异常ArithmeticException添加到testPrintMessage（）测试用例。

在C:\》 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());
   }
}

创建测试运行器

在C:\》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

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

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允许您指定依赖项 -

在@Test注释中使用属性dependsOnMethods ，或。
在@Test注释中使用属性dependsOnGroups 。

示例使用dependsOnMethods

创建一个类

在C:\》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;
   }
}

创建测试用例类

创建一个java测试类，比如DependencyTestUsingAnnotation.java。
将测试方法testPrintMessage（）和testSalutationMessage（）以及initEnvironmentTest（）添加到测试类中。
将属性dependsOnMethods = {"initEnvironmentTest"}到testSalutationMessage()方法的@Test注释中。

在C:\》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:\》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

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

创建一个类

在C:\》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;
   }
}

创建测试用例类

创建一个java测试类，比如DependencyTestUsingAnnotation.java。
将测试方法testPrintMessage（）testSalutationMessage（）和initEnvironmentTest（）添加到测试类，并将它们添加到组“init”。
将属性dependsOnMethods = {"init.*"}到testSalutationMessage()方法的@Test注释中。

在C:\》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:\》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()方法后运行initEnvironmentTest()方法。

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

在使用组时，我们不再受到重构问题的影响。只要我们不修改dependsOnGroups或groups属性，我们的测试将继续运行并设置适当的依赖项。
每当需要在依赖图中添加新方法时，我们需要做的就是将它放在正确的组中，并确保它依赖于正确的组。我们不需要修改任何其他方法。

TestNG - Parameterized Test

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

TestNG允许您以两种不同的方式将参数直接传递给您的测试方法 -

用testng.xml
使用数据提供商

使用testng.xml传递参数

使用此技术，您可以在testng.xml文件中定义简单参数，然后在源文件中引用这些参数。让我们举个例子来演示如何使用这种技术传递参数。

创建测试用例类

创建一个java测试类，比如，ParameterizedTest1.java。
将测试方法parameterTest（）添加到测试类。此方法将字符串作为输入参数。
将注释@Parameters("myName")添加到此方法。该参数将从testng.xml传递一个值，我们将在下一步中看到。

在C:\》TestNG_WORKSPACE创建名为ParameterizedTest1.java的java类文件。

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:\》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>

我们也可以定义参数水平。假设我们已经在“套件”和“测试”级别定义了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中指定的值转换为您的参数类型。以下是支持的类型 -

String
int/Integer
boolean/Boolean
byte/Byte
char/Character
double/Double
float/Float
long/Long
short/Short

使用Dataproviders传递参数

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

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

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

例子1 (Example 1)

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

Create Java class

创建一个名为PrimeNumberChecker.java的java类。该类检查数字是否为素数。在C:\》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

创建一个java测试类，比如ParamTestWithDataProvider1.java。
定义方法primeNumbers（），它使用注释定义为数据提供者。此方法返回一个对象数组。
将测试方法testPrimeNumberChecker（）添加到测试类。此方法将Integer和Boolean作为输入参数。此方法验证传递的参数是否为素数。
将注释@Test(dataProvider = "test1")添加到此方法。属性dataProvider映射到“test1”。

在C:\》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

创建一个testng.xml C:\》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 = "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
===============================================

例子2 (Example 2)

这里，@ DataProvider将Object作为参数传递。

Create Java class

在C:\》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

创建一个java测试类，比如ParamTestWithDataProvider2.java。
定义primeNumbers（）方法，该方法使用注释定义为数据提供者。此方法返回一个对象数组。
将测试方法testMethod（）添加到测试类中。此方法将对象bean作为参数。
将注释@Test(dataProvider = "test1")添加到此方法。属性dataProvider映射到“test1”。

在C:\》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:\》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类，将测试运行器从JUnit更改为Ant中的TestNG，然后以“混合”模式运行TestNG。这样，您可以在同一个项目中进行所有测试，即使是在同一个包中，也可以开始使用TestNG。此方法还允许您以递增方式将现有JUnit测试转换为TestNG。

让我们举一个例子来展示TestNG的这种惊人的能力。

创建JUnit测试用例类

在C:\》TestNG_WORKSPACE创建一个java类，它是一个JUnit测试类， C:\》TestNG_WORKSPACE 。

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:\》TestNG_WORKSPACE ，其中包含”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测试用例，请在上面的xml中定义属性junit="true" 。 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生成报告有两种方法 -

Listeners - 为了实现监听器类，该类必须实现org.testng.ITestListener接口。当测试开始，结束，失败，跳过或通过时，TestNG会在运行时通知这些类。
Reporters - 为了实现报告类，该类必须实现org.testng.IReporter接口。整个套件运行结束时会调用这些类。包含整个测试运行信息的对象在被调用时传递给该类。

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

Sr.No.	案例和案例
1	自定义日志记录此示例说明了如何编写自己的记录器。
2	自定义报道这个例子说明了如何编写自己的记者。
3	HTML和XML报告此示例说明了TestNG生成的默认HTML和XML报告。
4	JUnit报告此示例说明如何从TestNG报告生成JUnit报告。

TestNG - Plug With ANT

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

第1步:下载Apache Ant

下载最新版本的Apache Ant

OS	存档名称
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

第2步:设置Ant环境

将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	导出ANT_HOME =/usr/local/apache-ant-1.8.4
Mac	导出ANT_HOME =/Library/apache-ant-1.8.4

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

OS	描述
Windows	在系统变量Path的末尾附加字符串％ANT_HOME\bin。
Linux	导出PATH = $ PATH:$ ANT_HOME/bin/
Mac	不需要。

第3步:下载TestNG Archive

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

OS	存档名称
Windows	testng-6.8.jar
Linux	testng-6.8.jar
Mac	testng-6.8.jar

第4步:创建项目结构

在C:\》TestNG_WORKSPACE创建一个文件夹C:\》TestNG_WORKSPACE 。
在C:\》TestNG_WORKSPACE》TestNGWithAnt创建一个文件夹src 。
在C:\》TestNG_WORKSPACE》TestNGWithAnt创建文件夹test 。
在C:\》TestNG_WORKSPACE》TestNGWithAnt创建一个文件夹lib 。
在C:\》TestNG_WORKSPACE》TestNGWithAnt》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;
   }   
}

在C:\》TestNG_WORKSPACE》TestNGWithAnt》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());
   }
}

在C:\》TestNG_WORKSPACE》TestNGWithAnt》lib文件夹中复制testng-6.8.jar。

创建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，请按照以下步骤操作 -

第1步:下载TestNG Archive

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

OS	存档名称
Windows	testng-6.8.jar
Linux	testng-6.8.jar
Mac	testng-6.8.jar

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

第2步:设置Eclipse环境

打开eclipse→右键单击项目并转到属性→构建路径→配置构建路径，然后使用Add External Jar按钮在库中Add External Jar testng-6.8.jar。

我们假设您的Eclipse内置了TestNG插件; 如果没有，请使用更新站点获取最新版本。
- 在Eclipse IDE中，选择“ Help/Software updates/Find and Install 。
- Search for new features to install.
- New remote site.
- 对于Eclipse 3.4及更高版本，请输入http://beust.com/eclipse 。
- 对于Eclipse 3.3及更低版本，请输入http://beust.com/eclipse1 。
- 确保选中URL旁边的复选框，然后单击“ Next 。
- Eclipse将引导您完成整个过程。

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

第3步:验证Eclipse中的TestNG安装

在Eclipse中的任何位置创建一个项目TestNGProject。
创建一个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;
   }   
}

在项目中创建一个测试类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());
   }
}

项目结构应如下 -

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

验证结果。

<上一篇.TestNG - 使用Eclipse插件( Plug with Eclipse)

TestNG - 有用的资源.下一篇>

Sr.No.	案例和案例
1	自定义日志记录此示例说明了如何编写自己的记录器。
2	自定义报道这个例子说明了如何编写自己的记者。
3	HTML和XML报告此示例说明了TestNG生成的默认HTML和XML报告。
4	JUnit报告此示例说明如何从TestNG报告生成JUnit报告。

TestNG - 教程

TestNG - 概述

TestNG - 环境

TestNG - 写测试( Writing Tests)

TestNG - 基本注释( Basic Annotations)

TestNG - 执行程序( Execution Procedure)

TestNG - 执行测试( Executing Tests)

TestNG - 套件测试( Suite Test)

TestNG - 忽略测试( Ignore a Test)

TestNG - 小组测试( Group Test)

TestNG - 异常测试( Exception Test)

TestNG - 依赖性测试( Dependency Test)

TestNG - 参数化测试( Parameterized Test)

TestNG - 运行JUnit测试( Run JUnit Tests)

TestNG - 测试结果( Test Results)

TestNG - 测试结果( Test Results)

TestNG - 使用Eclipse插件( Plug with Eclipse)