public class BasicAnnotation1 {
@Test
public void testCase1(){
System.out.println("这是第一个测试用例");
}
@Test
public void testCase2(){
System.out.println("这是第二个测试用例");
}
@BeforeClass
public void beforeClass(){
System.out.println("beforeClass在类运行之前运行");
}
@AfterClass
public void afterClass(){
System.out.println("afterClass在类运行之后运行");
}
@BeforeMethod
public void beforeMethod(){
System.out.println("BeforeMethod在测试方法之前运行");
}
@AfterMethod
public void afterMethod(){
System.out.println("AfterMethod在测试方法之后运行");
}
@BeforeSuite
public void beforeSuite(){
System.out.println("BeforeSuite测试套件");
}
@AfterSuite
public void afterSutie(){
System.out.println("AfterSuite测试套件");
}
}
BeforeSuite测试套件
beforeClass这是在类运行之前运行的方法
BeforeMethod这是在测试方法之前运行的
Thread Id : 1
Test这是测试用例1
AfterMethod这是在测试方法之后运行的
BeforeMethod这是在测试方法之前运行的
Thread Id : 1
Test这是测试用例2
AfterMethod这是在测试方法之后运行的
afterClass这是在类运行之后运行的方法 场景在类正式运行之前是不是需要对象 静态方法 变量赋值
AfterSuite测试套件
忽略测试
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 执行");
}
}
enabled 等于true的时候不忽略 ,等于false的时候忽略测试
组测试中的方法分组测试
public class GroupsOnMethod {
@Test(groups = "server")
public void test1(){
System.out.println("这是服务端组的测试方法11111");
}
@Test(groups = "server")
public void test2(){
System.out.println("这是服务端组的测试方法2222");
}
@Test(groups = "client")
public void test3(){
System.out.println("这是客户端组的测试方法33333");
}
@Test(groups = "client")
public void test4(){
System.out.println("这是客户端组的测试方法4444");
}
@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
这是服务端组的测试方法2222
这是服务端组运行之后运行的方法!!!!!
这是客户端组的测试方法33333
这是客户端组的测试方法4444
组测试中的类分组测试,只运行一部分组
三个类,@Test放到类上不放在方法上
@Test(groups = "stu")
public class GroupsOnClass1 {
public void stu1(){
System.out.println("GroupsOnClass1中的stu1111运行");
}
public void stu2(){
System.out.println("GroupsOnClass1中的stu2222运行");
}
}
@Test(groups = "stu")
public class GroupsOnClass2 {
public void stu1(){
System.out.println("GroupsOnClass222中的stu1运行");
}
public void stu2(){
System.out.println("GroupsOnClass222中的stu2运行");
}
}
@Test(groups = "teacher")
public class GroupsOnClass3 {
public void teacher1(){
System.out.println("GroupsOnClass3中的teacher1运行");
}
public void teacher2(){
System.out.println("GroupsOnClass3中的teacher2运行");
}
}
<?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"/>
</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>
GroupsOnClass1中的stu1111运行
GroupsOnClass1中的stu2222运行
GroupsOnClass222中的stu1运行
GroupsOnClass222中的stu2运行
GroupsOnClass3中的teacher1运行
GroupsOnClass3中的teacher2运行
GroupsOnClass1中的stu1111运行
GroupsOnClass1中的stu2222运行
GroupsOnClass222中的stu1运行
GroupsOnClass222中的stu2运行
异常测试
public class ExpectedException {
/**
* 什么时候会用到异常测试??
* 在我们期望结果为某一个异常的时候
* 比如:我们传入了某些不合法的参数,程序抛出了异常
* 也就是说我的语气结果就是这个异常。
*/
// 这是一个测试结果会失败的异常测试
@Test(expectedExceptions = RuntimeException.class)
public void runTimeExceptionFailed(){
System.out.println("这是一个失败的异常测试");
}
// 这是一个成功的异常测试
@Test(expectedExceptions = RuntimeException.class)
public void runTimeExceptionSuccess(){
System.out.println("这是我的异常测试");
throw new RuntimeException();
}
}
依赖测试
public class DependTest {
@Test
public void test1(){
System.out.println("test1 run");
}
@Test(dependsOnMethods = {"test1"})
public void test2(){
System.out.println("test2 run");
}
}
参数化测试-xml
一般用于配置参数
public class ParamterTest {
@Test
@Parameters({"city","sex"})
public void paramTest1(String city,String sex){
System.out.println("city = " + city + "; age = " + sex);
}
}
<?xml version="1.0" encoding="UTF-8" ?>
<suite name="parameter">
<test name="param">
<classes>
<parameter name="city" value="北京"/>
<parameter name="sex" value="男"/>
<class name="com.course.testng.paramter.ParamterTest"/>
</classes>
</test>
</suite>
参数化测试-DataProvider
public class DataProviderTest {
@Test(dataProvider = "data")
public void testDataProvider(String name,int age){
System.out.println("name =" + name +"; age=" + age);
}
@DataProvider(name="data")
public Object[][] providerData(){
Object[][] o = new Object[][]{
{"小明",10},
{"小强",20},
{"小张",30}
};
return o;
}
@Test(dataProvider = "methodData")
public void test1(String name,int age){
System.out.println("test1方法 name="+name+";age="+age);
}
@Test(dataProvider = "methodData")
public void test2(String name,int age){
System.out.println("test2方法 name="+name+";age="+age);
}
@DataProvider(name="methodData")
public Object[][] methodDataTest(Method method){
Object[][] result=null;
if(method.getName().equals("test1")){
result = new Object[][]{
{"小明",10},
{"小强",20}
};
}else if(method.getName().equals("test2")){
result = new Object[][]{
{"小张",30},
{"小李",40}
};
}
return result;
}
}
DataProvider 还可以根据方法名判断,传入不同的入参
多线程测试-xml文件实现
tests级别:不同的test 标签下的用例可以在不同的线程下执行
相同的test 标签下的用例只能在同一个线程中去执行
classs级别:不同的class 标签 下的用例可以在不同的线程中执行
相同的class 标签下的用例在同一个线程中执行
methods级别:所有用例都可以在不同的线程下去执行
thread-count:代表了最大并发线程数
xml文件配置这种方式不能指定线程池,只有方法上才可以指定线程池
<?xml version="1.0" encoding="UTF-8" ?>
<suite name="thread" parallel="tests" thread-count="3">
<!--
tests级别:不同的test 标签下的用例可以在不同的线程下执行
相同的test tag下的用例只能在同一个线程中去执行
classs级别:不同的class tag 下的用例可以在不同的线程中执行
相同的class tag 下的用例在同一个线程中执行
methods级别:所有用例都可以在不同的线程下去执行
thread-count:代表了最大并发线程数
xml文件配置这种方式不能指定线程池,只有方法上才可以指定线程池
-->
<test name = "demo1">
<classes name="d">
<class name="com.course.testng.multiThread.MultiThreadOnXml"/>
<class name="com.course.testng.BasicAnnotation"/>
<class name="com.course.testng.multiThread.MultiThreadOnXml"/>
</classes>
<classes name="d1">
<class name="com.course.testng.multiThread.MultiThreadOnXml"/>
<class name="com.course.testng.BasicAnnotation"/>
<class name="com.course.testng.multiThread.MultiThreadOnXml"/>
</classes>
</test>
<test name = "demo2">
<classes name="d3">
<class name="com.course.testng.BasicAnnotation"/>
</classes>
</test>
</suite>
超时测试
public class TimeOutTest {
@Test(timeOut = 5000)//单位为毫秒值
public void testSuccess() throws InterruptedException {
Thread.sleep(4000);
}
@Test(timeOut = 4000)
public void testFailed() throws InterruptedException {
Thread.sleep(6000);
}
}