测试框架TestNG

最新推荐文章于 2022-10-10 12:12:01 发布
最新推荐文章于 2022-10-10 12:12:01 发布
阅读量195 收藏
点赞数 1
分类专栏： 接口自动化测试实战 文章标签： TestNG 单元测试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34829447/article/details/83245935
版权

一.TestNG介绍

1.适合测试人员使用的原因
  • 比Junit涵盖功能更全面的测试框架
  • Junit更适合隔离性比较强的单元测试
  • TestNG更适合复杂的集成测试
2.TestNG的使用

  • maven引入

    <dependencies>
	<dependency>
    	<groupId>org.testing</groupId>
        <artifactId>testing</artifactId>
        <version>release</version>
    </dependency>
</dependencies>
3.TestNG基本注解与执行顺序实战

  • 创建maven的工程文件

  • 使用最基本的@Test注解，用来把方法标记为测试的一部分

    package com.course.testng;
import org.testng.annotations.Test;
public class BasicAnnotation {
    //最基本的注解，用来把方法标记为测试的一部分
    @Test
    public void testCase1() {
        System.out.println("这是测试用例1");
    }
}

  • 注解实战@BeforeMethod和@AfterMethod

    package com.course.testng;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
public class BasicAnnotation {
    //最基本的注解，用来把方法标记为测试的一部分
    @Test
    public void testCase1() {
        System.out.println("这是测试用例1");
    }
    //BeforeMethod是在测试方法之前运行的
    @BeforeMethod
    public void beforeMethod(){
        System.out.println("BeforeMethod是在测试方法之前运行的");
    }
    //AfterMethod是在测试方法之后运行的
    @AfterMethod
    public void afterMethod(){
        System.out.println("AfterMethod是在测试方法之后运行的");
    }
}
//运行结果
//BeforeMethod是在测试方法之前运行的
//这是测试用例1
//AfterMethod是在测试方法之后运行的
    • 当在类中添加case方法时，运行类则可以发现每个Test方法的前后都有BeforeMethod和AfterMethod方法
    package com.course.testng;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
public class BasicAnnotation {
    //最基本的注解，用来把方法标记为测试的一部分
    @Test
    public void testCase1() {
        System.out.println("这是测试用例1");
    }
    @Test
    public void testCase2() {
        System.out.println("这是测试用例2");
    }
    //BeforeMethod是在测试方法之前运行的
    @BeforeMethod
    public void beforeMethod(){
        System.out.println("BeforeMethod是在测试方法之前运行的");
    }
    //AfterMethod是在测试方法之后运行的
    @AfterMethod
    public void afterMethod(){
        System.out.println("AfterMethod是在测试方法之后运行的");
    }
}
//运行类结果
//BeforeMethod是在测试方法之前运行的
//这是测试用例1
//AfterMethod是在测试方法之后运行的
//BeforeMethod是在测试方法之前运行的
//这是测试用例2
//AfterMethod是在测试方法之后运行的

  • 注解实战@BeforeClass和@AfterClass，在类运行之前和之后执行的方法

    package com.course.testng;
import org.testng.annotations.*;
public class BasicAnnotation {
    //最基本的注解，用来把方法标记为测试的一部分
    @Test
    public void testCase1() {
        System.out.println("这是测试用例1");
    }
    @Test
    public void testCase2() {
        System.out.println("这是测试用例2");
    }
    //BeforeMethod是在测试方法之前运行的
    @BeforeMethod
    public void beforeMethod(){
        System.out.println("BeforeMethod是在测试方法之前运行的");
    }
    //AfterMethod是在测试方法之后运行的
    @AfterMethod
    public void afterMethod(){
        System.out.println("AfterMethod是在测试方法之后运行的");
    }
    //BeforeClass是在类运行之前运行的方法
    @BeforeClass
    public void beforeClass(){
        System.out.println("BeforeClass是在类运行之前运行的方法");
    }
    //AfterClass是在类运行之后运行的方法
    @AfterClass
    public void afterClass(){
        System.out.println("AfterClass是在类运行之后运行的方法");
    }
}
//运行结果
//BeforeClass是在类运行之前运行的方法
//BeforeMethod是在测试方法之前运行的
//这是测试用例1
//AfterMethod是在测试方法之后运行的
//BeforeMethod是在测试方法之前运行的
//这是测试用例2
//AfterMethod是在测试方法之后运行的
//AfterClass是在类运行之后运行的方法

  • 注解实战BeforeSuite和AfterSuite测试套件，在类执行之前的前面运行和在类执行之后的后面执行

    package com.course.testng;
import org.testng.annotations.*;
public class BasicAnnotation {
    //最基本的注解，用来把方法标记为测试的一部分
    @Test
    public void testCase1() {
        System.out.println("这是测试用例1");
    }
    @Test
    public void testCase2() {
        System.out.println("这是测试用例2");
    }
    //BeforeMethod是在测试方法之前运行的
    @BeforeMethod
    public void beforeMethod(){
        System.out.println("BeforeMethod是在测试方法之前运行的");
    }
    //AfterMethod是在测试方法之后运行的
    @AfterMethod
    public void afterMethod(){
        System.out.println("AfterMethod是在测试方法之后运行的");
    }
    //BeforeClass是在类运行之前运行的方法
    @BeforeClass
    public void beforeClass(){
        System.out.println("BeforeClass是在类运行之前运行的方法");
    }
    //AfterClass是在类运行之后运行的方法
    @AfterClass
    public void afterClass(){
        System.out.println("AfterClass是在类运行之后运行的方法");
    }
    //beforeSuite在beforeClass之前执行
    @BeforeSuite
    public void beforeSuite(){
        System.out.println("beforeSuite测试套件");
    }
    //afterSuite在afterClass之后执行
    @AfterSuite
    public void afterSuite(){
        System.out.println("afterSuite测试套件");
    }
}
//运行结果
//beforeSuite测试套件
//BeforeClass是在类运行之前运行的方法
//BeforeMethod是在测试方法之前运行的
//这是测试用例1
//AfterMethod是在测试方法之后运行的
//BeforeMethod是在测试方法之前运行的
//这是测试用例2
//AfterMethod是在测试方法之后运行的
//AfterClass是在类运行之后运行的方法
//afterSuite测试套件
4.TestNG套件测试

  • 编写SuiteConfig.java文件（文件名可以自定义，主要用于配置套件的相关方法编写）

    package com.course.testng.suite;

import org.testng.annotations.AfterSuite;
import org.testng.annotations.AfterTest;
import org.testng.annotations.BeforeSuite;
import org.testng.annotations.BeforeTest;

public class SuiteConfig {
    @BeforeSuite
    public void beforeSuite(){
        System.out.println("before suite运行啦");
    }
    @AfterSuite
    public void afterSuite(){
        System.out.println("after suite运行啦");
    }

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

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

  • 编写LoginTest.java文件和PayTest.java文件（文件名可以自定义，主要编写固定的测试用例）

    //PayTest.java
package com.course.testng.suite;
import org.testng.annotations.Test;
public class PayTest {
    @Test
    public void paySuccess(){
        System.out.println("支付宝支付成功");
    }
}
//LoginTest.java
package com.course.testng.suite;
import org.testng.annotations.Test;
public class LoginTest {
    @Test
    public void loginTaoBao(){
        System.out.println("淘宝登录成功");
    }
}

  • 编写suite.xml文件（文件名可以自定义，主要用于将配置套件文件与用例文件整合）

    <?xml version="1.0" encoding="UTF-8" ?><!-- 标准xml文件头 -->
<suite name="test">
    <test name="login">
        <classes>
            <class name="com.course.testng.suite.SuiteConfig"/>
            <class name="com.course.testng.suite.LoginTest"/>
        </classes>
    </test>
    <test name="pay">
        <classes>
            <class name="com.course.testng.suite.SuiteConfig"/>
            <class name="com.course.testng.suite.PayTest"/>
        </classes>
    </test>
</suite>

  • 执行suite.xml文件

    before suite运行啦
beforeTest
淘宝登录成功
afterTest
beforeTest
支付宝支付成功
afterTest
after suite运行啦
5.TestNG忽略测试

  • 创建文件IgnoreTest.java文件

  • 忽略测试：指的是当前不执行某个测试用例，将@Test的enabled属性设置为false即可（默认enabled属性值为true）

    package com.course.testng;
import org.testng.annotations.Test;
public class IgnoreTest {
    @Test
    public void ignore1(){
        System.out.println("ignore1 执行！");
    }
    @Test(enabled = false)
    public void ignore2(){
        System.out.println("ignore2 执行！");
    }
    @Test(enabled = true)
    public void ignore3(){
        System.out.println("ignore3 执行！");
    }
}
//执行结果
//ignore1 执行！
//ignore3 执行！

二.TestNG组测试

1.组测试中的方法分组测试

  • 创建GroupsOnMethod.java文件

  • 方法分组测试：利用@BeforeGroups和@AfterGroups筛选在对应groups的前后执行的内容

  • 实例代码

    package com.course.testng.groups;
import org.testng.annotations.AfterGroups;
import org.testng.annotations.BeforeGroups;
import org.testng.annotations.Test;
public class GroupsOnMethod {
    @Test(groups = "server")
    public void test1(){
        System.out.println("这是服务端组的测试方法11111");
    }
    @Test(groups = "server")
    public void test2(){
        System.out.println("这是服务端组的测试方法22222");
    }
    @Test(groups = "client")
    public void test3(){
        System.out.println("这是客户端组的测试方法33333");
    }
    @Test(groups = "client")
    public void test4(){
        System.out.println("这是客户端组的测试方法44444");
    }
    @BeforeGroups("server")
    public void beforeGroupsOnServer(){
        System.out.println("这是服务端组运行之前运行的方法");
    }
    @AfterGroups("server")
    public void afterGroupsOnServer(){
        System.out.println("这是服务端组运行之后运行的方法");
    }
    @BeforeGroups("client")
    public void beforeGroupsOnClient(){
        System.out.println("这是客户端组运行之前运行的方法");
    }
    @AfterGroups("client")
    public void afterGroupsOnClient(){
        System.out.println("这是客户端组运行之后运行的方法");
    }
}
//运行结果
//这是服务端组运行之前运行的方法
//这是服务端组的测试方法11111
//这是服务端组的测试方法22222
//这是服务端组运行之后运行的方法
//这是客户端组运行之前运行的方法
//这是客户端组的测试方法33333
//这是客户端组的测试方法44444
//这是客户端组运行之后运行的方法
2.组测试中的类分组测试

  • 创建GroupsOnClass1.java文件

    package com.course.testng.groups;
import org.testng.annotations.Test;
@Test(groups = "stu")//给类命名groups
public class GroupsOnClass1 {
    public void stu1(){
        System.out.println("GroupsOnClass1中的stu1运行");
    }
    public void stu2(){
        System.out.println("GroupsOnClass1中的stu2运行");
    }
}

  • 创建GroupsOnClass2.java文件

    package com.course.testng.groups;
import org.testng.annotations.Test;
@Test(groups = "stu")//给类命名groups
public class GroupsOnClass2 {
    public void stu1(){
        System.out.println("GroupsOnClass2中的stu1运行");
    }
    public void stu2(){
        System.out.println("GroupsOnClass2中的stu2运行");
    }
}

  • 创建GroupsOnClass3.java文件

    package com.course.testng.groups;
import org.testng.annotations.Test;
@Test(groups = "teacher")//给类命名groups
public class GroupsOnClass3 {
    public void teacher1(){
        System.out.println("GroupsOnClass3中的teacher1运行");
    }
    public void teacher2(){
        System.out.println("GroupsOnClass3中的teacher2运行");
    }
}

  • 创建groupsOnClass.xml文件

    <?xml version="1.0" encoding="UTF-8" ?>
<suite name="suitename">
    <test name="runAll"><!-- 运行所有的组 -->
        <classes>
            <class name="com.course.testng.groups.GroupsOnClass1"/>
            <class name="com.course.testng.groups.GroupsOnClass2"/>
            <class name="com.course.testng.groups.GroupsOnClass3"/>
        </classes>
    </test>
    <test name="onlyRunStu">
        <groups>
            <run>
                <include name="stu"/><!-- 只运行groups为stu的类组的方法 -->
            </run>
        </groups>
        <classes>
            <class name="com.course.testng.groups.GroupsOnClass1"/>
            <class name="com.course.testng.groups.GroupsOnClass2"/>
            <class name="com.course.testng.groups.GroupsOnClass3"/>
        </classes>
    </test>
</suite>

    • 利用阻塞式配置groups->run->include，设置执行哪组的类

    • 执行xml结果(前六条因为没有指定设置则执行所有的组，后四条因为利用阻塞式配置只运行groups为stu的组中的类的方法)

      GroupsOnClass1中的stu1运行
GroupsOnClass1中的stu2运行
GroupsOnClass2中的stu1运行
GroupsOnClass2中的stu2运行
GroupsOnClass3中的teacher1运行
GroupsOnClass3中的teacher2运行
GroupsOnClass1中的stu1运行
GroupsOnClass1中的stu2运行
GroupsOnClass2中的stu1运行
GroupsOnClass2中的stu2运行

三.TestNG异常测试

1.什么时候使用异常测试

  • 在我们期望结果为某一个异常的时候（系统抛出的异常或显式抛出的异常）

  • 比如：我们传入了某些不合法的参数，程序抛出异常

  • 也就是我的预期结果就是这个异常

2.异常测试举例

  • 失败的异常测试(下述代码因为没有异常，所以异常测试失败)

    //这是一个测试结果会失败的异常测试
@Test(expectedExceptions = RuntimeException.class)
public void runTimeExceptionFailed(){
    System.out.println("这是一个失败的异常测试");
}

  • 成功的异常测试(下述代码因为有异常，所以异常测试成功)

    //这是一个成功的异常测试
@Test(expectedExceptions = RuntimeException.class)
public void runTimeExceptionSuccess(){
    System.out.println("这是我的异常测试");
    throw new RuntimeException();
}

四.TestNG依赖测试

  • 依赖测试：本测试方法依赖于其他的方法，使用@Test中的dependsOnMethods = {"其他方法名"}属性进行控制

  • 实例代码

    package com.course.testng;
import org.testng.annotations.Test;
public class DependTest {
    @Test
    public void test1(){
        System.out.println("test1 run");
    }
    @Test(dependsOnMethods = {"test1"})//将test1作为test2的前置条件
    public void test2(){
        System.out.println("test2 run");
    }
    @Test
    public void test3(){
        System.out.println("test3 run");
        throw new RuntimeException();
    }
    @Test(dependsOnMethods = {"test3"})//将test3作为test4的前置条件,test3失败则test4被忽略
    public void test4(){
        System.out.println("test4 run");
    }
}
//运行test2的结果为(因为依赖的test1没有异常)
//test1 run
//test2 run
//运行test4的结果为(因为依赖的test3抛出异常)
//java.lang.RuntimeException
//	...
//Test ignored.

五.TestNG参数化测试

1.xml文件参数化测试

  • xml文件参数化测试：给对应方法中传递参数进行测试，在类中使用@Parameters注解定义要传的参数名称，在xml的配置文件中使用<parameter>标签的name和value设置传递的具体参数值

  • 实例代码

    • ParamterTest.java文件

      package com.course.testng.paramter;
import org.testng.annotations.Parameters;
import org.testng.annotations.Test;
public class ParamterTest {
    @Test
    @Parameters({"name","age"})
    public void paramterTest1(String name, int age){
        System.out.println("name="+name+" age="+age);
    }
}

    • parameter.xml文件

      <?xml version="1.0" encoding="UTF-8" ?>
<suite name="parameter">
    <test name="param">
        <classes>
            <parameter name="name" value="zhangsan"/>
            <parameter name="age" value="10"/>
            <class name="com.course.testng.paramter.ParamterTest"></class>
        </classes>
    </test>
</suite>

    • 执行xml的运行结果

      name=zhangsan age=10
2.DataProvider参数化测试

  • 将需要执行的测试方法@Test的dataProvider属性值与@DataProvider定义的方法的name属性值设置相同，@DataProvider方法主要用于提供参数对象。实例代码如下

    package com.course.testng.paramter;

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

import java.lang.reflect.Method;

public class DataProviderTest {
    @Test(dataProvider = "data")
    public void testDataProvider(String name, int age){
        System.out.println("name="+name+" age="+age);
        //运行结果
        //name=张三 age=10
        //name=李四 age=20
        //name=王五 age=30
    }
    @DataProvider(name="data")//name与需要使用的方法Test注解的dataProvider属性值相同
    public Object[][] providerData(){
        Object [][] o= new Object[][]{//相当于给参数传递三次参数，分别执行三次测试方法
                {"张三",10},
                {"李四",20},
                {"王五",30}
        };
        return o;
    }
}

  • 当一个@DataProvider方法修饰多个测试方法时，通过@DataProvider修饰方法的Method参数判断给对应测试方法的方法名设置对应传递给测试方法的参数内容

    package com.course.testng.paramter;
import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;
import java.lang.reflect.Method;
public class DataProviderTest {
    @Test(dataProvider = "methodData")
    public void test1(String name, int age){
        System.out.println("test1方法:name="+name+" age="+age);
        //运行结果
        //test1方法:name=张三 age=15
        //test1方法:name=李四 age=25
    }
    @Test(dataProvider = "methodData")
    public void test2(String name, int age){
        System.out.println("test2方法:name="+name+" age="+age);
        //运行结果
        //test2方法:name=王五 age=50
        //test2方法:name=赵六 age=60
    }
    @DataProvider(name = "methodData")
    public Object[][] methodData(Method method){//method表示测试的方法名
        Object[][] result=null;
        if(method.getName().equals("test1")){
            result = new Object[][]{
                    {"张三",15},
                    {"李四",25}
            };
        }else if(method.getName().equals("test2")){
            result = new Object[][]{
                    {"王五",50},
                    {"赵六",60}
            };
        }
        return result;
    }
}

六.TestNG多线程测试

1.java注解实现多线程测试

  • 使用@Test的invocationCount设置方法的执行次数

  • 使用@Test的threadPoolSize设置线程池内的线程个数

  • 实例代码

    package com.course.testng.multiThread;
import org.testng.annotations.Test;
public class MultiThreadOnAnnotation {
    @Test(invocationCount = 10, threadPoolSize = 3)
    public void test(){
        System.out.println(1);
        System.out.printf("Thread ID:%s %n",Thread.currentThread());
    }
}
//运行结果——通过Thread.currentThread()得到当前所处的线程信息
//1
//1
//Thread ID:Thread[TestNG-methods-1,5,main]
//1
//Thread ID:Thread[TestNG-methods-2,5,main]
//Thread ID:Thread[TestNG-methods-3,5,main]
//1
//Thread ID:Thread[TestNG-methods-3,5,main]
//1
//Thread ID:Thread[TestNG-methods-2,5,main]
//1
//Thread ID:Thread[TestNG-methods-1,5,main]
//1
//Thread ID:Thread[TestNG-methods-1,5,main]
//1
//Thread ID:Thread[TestNG-methods-3,5,main]
//1
//Thread ID:Thread[TestNG-methods-2,5,main]
//1
//Thread ID:Thread[TestNG-methods-1,5,main]
2.xml文件实现多线程测试

  • 使用xml中suite的parallel属性决定多线程级别，thread-count属性决定最大并发线程数

  • parallel属性值

    • tests级别：不同的test tag下的用例可以在不同的线程下执行，相同的test tag下的用例只能在同一个线程中取执行
    • classs级别：相同的class tag下的用例在同一个线程下执行，不同的class tag下的用例可以在不同的线程下执行
    • methods级别：所有用例都可以在不同的线程下去执行

  • xml文件配置这种方式不能指定线程池，只有方法上才可以指定线程池

  • 实例代码

    • MultiThreadOnXml.java文件代码

      package com.course.testng.multiThread;
import org.testng.annotations.Test;
public class MultiThreadOnXml {
    @Test(invocationCount = 3)
    public void test1(){
        System.out.printf("Thread ID:%s %n",Thread.currentThread().getId());//打印线程ID
    }
}

    • multiThread.xml文件代码

      <?xml version="1.0" encoding="UTF-8" ?>
<suite name="thread" parallel="methods" thread-count="2"><!-- parallel表示多线程级别是方法级别的，thread-count表示的是线程数是2 -->
     <!--
        tests级别：不同的test tag下的用例可以在不同的线程下执行，相同的test tag下的用例只能在同一个线程中取执行
        classs级别：相同的class tag下的用例在同一个线程下执行，不同的class tag下的用例可以在不同的线程下执行
        methods级别：所有用例都可以在不同的线程下去执行
        thread-count：代表了最大并发线程数
        xml文件配置这种方式不能指定线程池，只有方法上才可以指定线程池
     -->
     <test name="demo1">
        <classes>
            <class name="com.course.testng.multiThread.MultiThreadOnXml"/>
        </classes>
    </test>
    <test name="demo2">
        <classes>
            <class name="com.course.testng.multiThread.MultiThreadOnXml"/>
        </classes>
    </test>
</suite>

七.TestNG超时测试

  • 通过设置@Test的timeout属性值进行超时测试，timeout属性值单位为毫秒值

  • 实例代码

    package com.course.testng;
import org.testng.annotations.Test;
public class TimeOutTest {
    @Test(timeOut = 3000)//单位为毫秒值
    public void testSuccess() throws InterruptedException {//测试通过
        Thread.sleep(2000);
    }
    @Test(timeOut = 2000)//单位为毫秒值
    public void testFailed() throws InterruptedException {//测试失败
        Thread.sleep(3000);
    }
}
汪喆_Jack
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
创建并运行TestNG单元测试
悟已往之不谏，知来者之可追
02-24 302
maven 依赖 TestNG： <dependency> <groupId>org.testng</groupId> <artifactId>testng</artifactId> <version>7.0.0</version> <scope>test</scope> </dependency> Mockito: <dependency>
java: 无法访问org.testng.annotations.Test 错误的类文件
m0_66298628的博客
11-26 6794
一、问题重述： java: 无法访问org.testng.annotations.Test 错误的类文件: /C:/Users/盼盼/.m2/repository/org/testng/testng/7.6.1/testng-7.6.1.jar!/org/testng/annotations/Test.class 类文件具有错误的版本 55.0, 应为 52.0
java: 无法访问org.testng.annotations.Test
xiaoma's Blog
10-10 5194
java: 无法访问org.testng.annotations.Test
找不到 org.testng.annotations.Test
桃花朵朵~
12-24 8842
注解@Test找不到 org.testng.annotations.Test 非常明确依赖包已经导入，看到相关解释https://segmentfault.com/q/1010000009108958 将<scope>test</scope>去掉，就可以看见了。 本来到这里就结束了，我又再次查看了刚刚那篇文章。 这个回答太棒了，我再次把sco...
testng介绍与使用方式
asd43211234的博客
04-24 1661
目录 一、概述 二、@Test注解常用参数 三、测试中常用的断言（assert） 四、TestNG常用注解及使用 五、配置文件xml常用标签 六、参数传递 七、测试报告 一、概述 1、TestNG是一个开源自动化测试框架，其灵感来自JUnit和NUnit，TestNG还涵盖了整个核心的JUnit4功能，但引入了一些新的功能，使其功能更强大，使用更方便。 优势：支持依赖测试...
测试框架testng包
07-31
开源自动化测试框架testng包，用于appium+java+android测试
单元测试框架 TestNG1
08-08
单元测试框架 TestNG1 在 Java 开发领域，单元测试是必不可少的一部分，而 TestNG 是一个相对 JUnit 而言的新生力量。TestNG 的创造者 Cedric Beust 是 Java 编程领域的知名人物，是 EJB 3 专家组的成员，也是其他...
单元测试 框架 testng6.8
11-15
单元测试 框架 testng6.8
TestNG测试框架(Author: Coast)
11-14
TestNG是一个开源的自动化测试框架，它受JUnit框架启发而实现的，TestNG可以让开发者和测试者能够通过简单的注解、分组、指定顺序、参数化就可以编写更加灵活、更加强大的测试用例。...接口自动化测试框架TestNG
Test测试报错：org.Junit.Test不能@test测试的解决方法
suhuiteng的博客
12-22 3473
Test测试报错：org.Junit.Test不能@test测试的解决方法。
TestNGException 解决办法
实践是最好的学习
11-24 894
笔记自用 写了一个Sring的demo， 然后测试运行的时候遇到了这个错误： TestNG by default disables loading DTD from unsecured Urls. If you need to explicitly load the DTD from a http url, please do so by using the JVM argument [-Dtestng.dtd.http=true] 异常解决参考了： https://zhuanlan.zhihu.com/
TestNG在自动化测试框架中应用详解
SailWu的自动化测试技术博客
04-20 3491
1、TestNG支持的注解和执行顺序 @beforeSuite （测试套件执行前执行一次，可以包括N个java包，N个java类） @beforeTest （介于测试套件suite和测试类之间的级别） @beforeClass （测试类中的所有方法执行之前执行一次） @beforeMethod （测试类中每个测试方法执行之前执行一次） @Test （测试类） @after
TestNG测试框架
zljain的博客
08-07 1万+
part 1、认识单元测试框架TestNG Java语言的单元测试框架 . JUnit4，要求JDK1.5及以上版本 . TestNG，同理 单元测试框架的作用 . 使测试代码和产品代码分离 . 简化测试代码的编写 . 灵活组织单元测试用例 . 方便与CI系统集成 TestNG的主要特点： 注解 1. TestNG使用Java和面向对象的功能 2. 支持综合类测试（单元测试...
单元测试(UnitTesting): TestNG + Jacoco + Gradle 配置篇
sunbelt的博客
07-23 1636
单元测试的工具主要常用的是JUnit和TestNG，从看到的文档对比来看TestNG要更加灵活，就从TestNG开始用起来。 TestNG 在build.gradle的配置 基于gradle的项目关于TestNG的配置: dependencies { compile('org.testng:testng:6.9.5') } 创建test Task test { ign...
5.Maven实战 --- 坐标和依赖
enlyhua的专栏
06-28 216
无
import org.junit.Test 和@Test报错---解决方案大全
热门推荐
cao_yanjie的博客
01-09 9万+
在最近用spring框架做项目的时候，发现不定时出现import org.junit.Test 和@Test报错，在包没有导入错误的前提下，该问题的解决方案如下：解决方案一：MyEclipse 在项目右击属性选择【build path】的【add Libararies】界面 ，选择JUnit导入，Eclipse也同样。解决方案二：原因是java文件所在的包为默认的匿名包。新建个com.XXX.XX...
【Android Gradle 插件】TestOptions 配置 ④ ( org.gradle.api.tasks.testing.Test 单元测试配置类 | Android 单元测试示例 )
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
05-23 959
一、org.gradle.api.tasks.testing.Test 单元测试配置类、 1、Test 单元测试配置回顾、 2、启动单元测试、 3、设置 JVM 系统属性 4、打开命令行标准输出、 二、单元测试示例、 单元测试类、 gradle 配置、 1、右键运行单元测试、 3、执行单元测试 Gradle 任务、 4、查看单元测试命令行输出、 5、查看单元测试报告
testing - 测试基本使用接口
weixin_33779515的博客
01-20 186
testing - 测试基本使用接口 当你写完一个函数，结构体，main之后，你下一步需要的就是测试了。testing包提供了很简单易用的测试包。 写一个基本的测试用例 测试文件的文件名需要以_test.go为结尾，测试用例需要以TestXxxx的样式存在。 比如我要测试utils包的sql.go中的函数： func GetOne(db *sql.DB, query string, args .....
测试框架testng\httpcilent
最新发布
06-07
好的，针对测试框架TestNG和httpclient，我可以为你提供一些基本信息和使用建议。 首先，TestNG是一个流行的测试框架，可以用于编写和执行测试用例。它支持各种测试类型，包括单元测试、集成测试和端到端测试。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值