TestNG简单的学习类和方法级别@Test的区别

Posted 2023-05-16

参考技术A 使用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的对象。
创建一个类
创建一个Java类进行测试为 MessageUtil.java 在 C:\ > 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;



创建测试例类
创建一个Java测试类 SampleTest.java
您的测试类添加一个的测试方法testPrintMessage（）
添加注释@Test 到方法 testPrintMessage()
实现测试条件和使用的assertEquals API TestNG的检查条件
创建一个Java类文件名 SampleTest.java在 C:\ > TestNG_WORKSPACE
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());



创建 testng.xml
接下来，让我们创建testng.xml文件在 C:\ > TestNG_WORKSPACE 执行测试用例，此文件捕获整个测试XML。这个文件可以很容易地描述所有的测试套件和它们的参数在一个文件中，你可以检查你的代码库或e-mail给同事。这也使得它容易提取测试或分裂的几个运行时配置的子集（例如，TestNG的database.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中BeforeClass和BeforeTest的区别

【中文标题】TestNG中BeforeClass和BeforeTest的区别

【英文标题】：Difference between BeforeClass and BeforeTest in TestNG

【发布时间】：2015-08-15 17:40:23

【问题描述】：

我们从 TestNG 官方文档中了解到：

@BeforeClass:被注解的方法会在当前类的第一个测试方法被调用之前运行。

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

上述两个 TestNG 注释在功能上看起来相似。谁能解释一下独特的区别？

【问题讨论】：

每个班级一次与每个测试用例一次，我认为你可以在一个班级中有多个测试用例？

这两个注解用于在执行所有测试用例之前启动。这就是相似之处。除此之外还有什么独特的吗？

你有1个Testclass，有3个Testmethods：@BeforeClass会被执行一次，@BeforeTest会被执行3次。这就是区别。 @BeforeClass可用于搭建测试环境，@BeforeTest可用于清理数据或设置数据等...

@Dude 如果是这样，'@BeforeMethod' 有什么作用？实际上'@BeforeClass'和'@BeforeTest'都将执行一次:)'@BeforeMethod'将执行3次。是的，数据清理是主要的。

好吧我错了，但答案说得很清楚，很完美

【参考方案1】：

这是 TestNG 层次结构： 测试套件 -> 测试 -> 类 -> 方法

@BeforeTest 在 test 标签内所有类的所有方法执行之前执行一次。

另一方面；

@BeforeClass 在它定义的类中的所有方法执行之前执行一次。

我已将脚本上传到我的 GitHub 个人资料中。这是相同的链接。喜欢的请点个赞。

请看： https://github.com/provivek2124/TestAnnotate.git1

【参考方案2】：

以上答案中缺少的是@BeforeClass 和@BeforeTest 注释之间的用法差异。

很明显，带有@BeforeClass 注释的方法（最常见的是setup 方法）只会在类中编写的所有测试用例之前执行一次。并且带有'@BeforeTest'注释的方法将在每个测试用例之前执行，无论它们的计数/序列/下划线逻辑如何。

因此，@BeforeClass 用于当我们的方法有很长的调用且执行时间很长并且这些调用的输出不会被任何测试用例改变时。例如，在 setup 方法中获取 API 响应，所有测试都将使用该响应。 而@BeforeTest@ 用于我们需要做一些清理工作，并且每个测试都需要一些新的资源来开始。例如，一个新创建的订单等。

【参考方案3】：

@BeforeClass: The annotated method will be run before the first test method in the current class is invoked. 
@BeforeMethod: The annotated method will be run before each test method.

The annotations above will also be honored (inherited) when placed on a superclass of a TestNG class. This is useful for example to centralize test setup for multiple test classes in a common superclass.

In that case, TestNG guarantees that the "@Before" methods are executed in inheritance order (highest superclass first, then going down the inheritance chain), and the "@After" methods in reverse order (going up the inheritance chain).

了解更多TestNG注解：https://testng.org/doc/documentation-main.html#annotations

【参考方案4】：

在解释区别之前，首先这是一些测试术语

Test suite – 由一个或多个测试标签组成。

Test tag - 由一个或多个测试类组成。

Test class – 由一种或多种方法组成。

例如

<suite name="suit1">
  <test name="TestTag1">
    <classes>
      <class name="TestClass1"/>
    </classes>
  </test>
  <test name="TestTag2">
    <classes>
      <class name="TestClass2"/>
      <class name="TestClass3"/>
    </classes>
  </test>
</suite>

@BeforeTest : 在任何测试标签之前只会被调用一次，无论该标签内有多少个测试类或有多少用@Test注解的方法，每个测试标签只会被调用一次，在前面的 XML 示例中，@BeforeTest 将被调用两次，一次在TestTag1 之前，第二次在TestTag2 之前，因此它可以用于在一个测试标签内初始化不同测试类之间的公共对象。

@BeforeClass : 在任何一个测试class之前只会被调用一次，不管这个测试类中有多少个被@Test注解的方法，每一个只会被调用一次测试类，在前面的XML例子中@BeforeClass会被调用3次，一次在TestClass1之前，第二次在TestClass2之前，第三次在TestClass3之前，所以它可以用来初始化两者之间的公共对象一个测试类中的不同测试方法。

@BeforeSuite 会为suit1 套装调用一次

调用顺序如下

@BeforeSuite
    @BeforeTest
        @BeforeClass
            @BeforeMethod
                @Test

想了解更多@BeforeMethod，请参考答案https://***.com/a/52331616/1973933

【参考方案5】：

SeleniumAbstractTest.class

public abstract class SeleniumAbstractTest 

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

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

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

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

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

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

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

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

MyTestClass1.class

public class MyTestClass1 extends SeleniumAbstractTest 

  @Test
  public void myTestMethod1() 
    System.out.println("myTestMethod1");
  

  @Test
  public void myTestMethod2() 
    System.out.println("myTestMethod2");
  

MyTestClass2.class

public class MyTestClass2 extends SeleniumAbstractTest 

  @Test
  public void myTestMethod3() 
    System.out.println("myTestMethod3");
  

  @Test
  public void myTestMethod4() 
    System.out.println("myTestMethod4");
  

如果您有以下测试套件...

<suite name="Suite">
  <test name="Test1" >
    <classes>
       <class name="MyTestClass2" />
    </classes>
  </test>

  <test name="Test2">
    <classes>
      <class name="MyTestClass1"/>
      <class name="MyTestClass2"/>
    </classes>
  </test>
</suite>

...那么输出[为便于阅读缩进]将是

BeforeSuite
'   BeforeTest
'   '   BeforeClass
'   '   '   BeforeMethod
'   '   '   '   myTestMethod3
'   '   '   AfterMethod
'   '   '   BeforeMethod
'   '   '   '   myTestMethod4
'   '   '   AfterMethod
'   '   AfterClass
'   AfterTest
'   BeforeTest
'   '   BeforeClass
'   '   '   BeforeMethod
'   '   '   '   myTestMethod1
'   '   '   AfterMethod
'   '   '   BeforeMethod
'   '   '   '   myTestMethod2
'   '   '   AfterMethod
'   '   AfterClass
'   '   BeforeClass
'   '   '   BeforeMethod
'   '   '   '   myTestMethod3
'   '   '   AfterMethod
'   '   '   BeforeMethod
'   '   '   '   myTestMethod4
'   '   '   AfterMethod
'   '   AfterClass
'   AfterTest
AfterSuite

希望对你有帮助:)

【讨论】：

这个答案的底部正是我要找的，太棒了！

【参考方案6】：

@BeforeMethod - 在每个测试方法之前执行，例如使用@Test注解的方法

@BeforeTest - 仅在 testng.xml 文件中给出的标记之前执行。

简而言之，@BeforeMethod 适用于 Java 类中定义的测试。 @BeforeTest 适用于 testng.xml 中定义的测试，即 XML 文件。

【参考方案7】：

我的意见：

@BeforeClass:被注解的方法会在当前类中的第一个测试方法被调用之前运行

@BeforeTest:注解的方法将在当前套件中的任何测试方法运行之前运行

【参考方案8】：

如果你从另一个类扩展，结果如下：

parentTest - BeforeTest- parent     
testClass1 - BeforeTest- test1    
parentTest - BeforeClass- parent    
testClass1 - BeforeClass- test1    
parentTest - BeforeMethod- parent    
testClass1 - BeforeMethod- test1    
testClass1 - myTestMethod1    
testClass1 - AfterMethod- test1    
parentTest - AfterMethod- parent    
parentTest - BeforeMethod- parent    
testClass1 - BeforeMethod- test1    
testClass1 - myTestMethod2    
testClass1 - AfterMethod- test1    
parentTest - AfterMethod- parent
testClass1 - AfterClass- test1    
parentTest - AfterClass- parent
testClass1 - AfterTest- test1
parentTest – AfterTest- parent