“深入了解JUnit单元测试框架的自动化测试“

已于 2023-12-25 20:45:20 修改
阅读量863 收藏 20
点赞数 22
分类专栏： 技术分享 干货分享 软件测试 文章标签： junit 单元测试 log4j
于 2023-12-25 19:47:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shihuaizxc/article/details/135207557
版权

🌈本节课我们来学习单元测试框架 Junit，这里的单元测试指的是对最小的软件设计单元（模块）进行验证，在UI自动化测试里面，我们的单元测试主要针对UI界面的功能进行自动化测试。

一、什么是 JUnit

JUnit是一个Java单元测试框架。它由Kent Beck和Erich Gamma建立，逐渐成为源于Kent Beck的sUnit的xUnit家族中最为成功的一个JUnit有它自己的JUnit扩展生态圈。多数Java的开发环境都已经集成了JUnit作为单元测试的工具。

注意：Junit 测试也是程序员测试，即所谓的白盒测试，它需要程序员知道被测试的代码如何完成功能，以及完成什么样的功能

它包括以下特性：

  1. 用于测试期望结果的断言（Assertion）
  2. 用于共享共同测试数据的测试工具
  3. 用于方便的组织和运行测试的测试套件
  4. 图形和文本的测试运行器

使用 Junit 能让我们快速的完成单元测试。

🌈通常我们写完代码想要测试这段代码的正确性，那么必须新建一个类，然后创建一个 main() 方法，然后编写测试代码。如果需要测试的代码很多呢？那么要么就会建很多main() 方法来测试，要么将其全部写在一个 main() 方法里面。这也会大大的增加测试的复杂度，降低程序员的测试积极性。而 Junit 能很好的解决这个问题，简化单元测试，写一点测一点，在编写以后的代码中如果发现问题可以较快的追踪到问题的原因，减小回归错误的纠错难度。

现在我也找了很多测试的朋友，做了一个分享技术的交流群，共享了很多我们收集的技术文档和视频教程。
如果你不想再体验自学时找不到资源，没人解答问题，坚持几天便放弃的感受
可以加入我们一起交流。而且还有很多在自动化，性能，安全，测试开发等等方面有一定建树的技术大牛
分享他们的经验，还会分享很多直播讲座和技术沙龙
可以免费学习！划重点！开源的！！！
qq群号：1150305204【暗号：csdn333】

二、JUnit5 相关技术

通常我们使用 JUnit5 版本

1.注解

注解（也可以称为 元数据）为在代码中添加信息提供了一种形式化的方法，使得在代码中任一时刻可以非常方便的使用这些数据；注解类型定义了一种新的特殊接口类型，在接口关键期 interface 之前加@符号，即用@interface即可区分注解与普通接口声明。目前大部分框架都是通过使用注解简化代码提高编码效率

1.1 @Test

JUnit提供了非常强大的注解功能，通过 @Test 注解修饰到方法上，该方法就变为了一个测试方法，执行当前类时，会自动的执行该类下所有带 @Test 注解的用例

使用这些JUnit提供的注解时，需要在pom.xml文件中进行配置（记得配置完要进行刷新）：maven中央仓库

 

 

<!-- https://mvnrepository.com/artifact/org.junit.jupiter/junit-jupiter-api -->
<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter-api</artifactId>
    <version>5.9.2</version>
    <scope>test</scope>
</dependency>
 

 

ef0833abb6c64b72aadfbc0c794dd18d.png​
 

 

    <dependencies>
        <!-- https://mvnrepository.com/artifact/org.junit.jupiter/junit-jupiter-api -->
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-api</artifactId>
            <version>5.9.2</version>
        </dependency>
    </dependencies>
 

 

 
 
在 main 文件中，我们需要导入 Test 包：
 
 
d7c8d5499ebc45d181b1e9d2ef6b6c6e.png​
 

 

我们写一个测试用例：
 

 

import org.junit.jupiter.api.Test;
public class JUnitDemo1 {
    @Test
    void Test01() {
        System.out.println("这是 JunitDemo1 里的 Test01");
    }
    @Test
    void Test02() {
        System.out.println("这是 JunitDemo1 里的 Test02");
    }
}
 

 

❗❗需要注意的是写的代码几个运行按钮：
 

7d48153af12b4db7b97df2fa097952f0.png​
 

 
 
 其中“对号”表示测试通过；“ ！”表示测试错误
 

 

1.2 @Disabled
 

Disabled 表示 忽略
 

 

import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.Test;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
public class JUnitDemo1 {
    @Test
    void Test01() {
        System.out.println("这是 JunitDemo1 里的 Test01");
    }
    @Test
    void Test02() {
        System.out.println("这是 JunitDemo1 里的 Test02");
    }
    @Disabled
    void Test03() {
        WebDriver webDriver = new ChromeDriver();
        webDriver.get("https://www.baidu.com");
        webDriver.findElement(By.cssSelector("#kw")).sendKeys("521");
        webDriver.findElement(By.cssSelector("#su")).click();
    }
}
 

 

6ca094feadbc4f7a9d397ed9803489aa.png​
 

 
 
此时我们看到这个代码就不执行 Test03 
 

 

1.3 @BeforeAll、@AfterAll
 

@BeforeAll：当前的方法需要在当前类下所有用例执行之前执行一次，且被该注解修饰的方法必须为静态方法
 

@AfterAll：当前的方法需要在当前类下所有用例执行之后执行一次，且被该注解修饰的方法必须为静态方法
 

 
 
例如在 UI 自动化中：通常情况下，创建文件、打开网页放在BeforeAll 里边；关闭浏览器放在AfterAll 里边
 

 

 

import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.Test;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
 
 
public class JUnitDemo1 {
    @Test
    void Test01() {
        System.out.println("这是 JunitDemo1 里的 Test01");
    }
    @Test
    void Test02() {
        System.out.println("这是 JunitDemo1 里的 Test02");
    }
    @Disabled
    void Test03() {
        WebDriver webDriver = new ChromeDriver();
        webDriver.get("https://www.baidu.com");
        webDriver.findElement(By.cssSelector("#kw")).sendKeys("521");
        webDriver.findElement(By.cssSelector("#su")).click();
    }
    @BeforeAll
    static void SetUp() {
        System.out.println("这是我们 BeforeAll 里边的语句");
    }
    @AfterAll
    static void TearDown() {
        System.out.println("这是我们 AfterAll 里边的语句");
    }
}
 

 

9bc9b342959949089e80c5d0c8ec9f71.png​
 

1.4 @BeforeEach、@AfterEach
 

@BeforeEach：当前的方法需要在每个用例执行之前都执行一次
 

@AfterEach：当前的方法需要在每个用例执行之后都执行一次
 

 

import org.junit.jupiter.api.*;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
public class JUnitDemo1 {
    @Test
    void Test01() {
        System.out.println("这是 JunitDemo1 里的 Test01");
    }
    @Test
    void Test02() {
        System.out.println("这是 JunitDemo1 里的 Test02");
    }
    @Disabled
    void Test03() {
        WebDriver webDriver = new ChromeDriver();
        webDriver.get("https://www.baidu.com");
        webDriver.findElement(By.cssSelector("#kw")).sendKeys("521");
        webDriver.findElement(By.cssSelector("#su")).click();
    }
    @BeforeAll
    static void SetUp() {
        System.out.println("这是我们 BeforeAll 里边的语句");
    }
    @AfterAll
    static void TearDown() {
        System.out.println("这是我们 AfterAll 里边的语句");
    }
    @BeforeEach
    void BeforeEachTest() {
        System.out.println("这是 BeforeEach 里边的语句");
    }
    @AfterEach
    void AfterEachTest() {
        System.out.println("这是 AfterEach 里边的语句");
    }
}
 

 

a2aa0e3310cd4b1bb61742dc3eeacefd.png​
 

2.参数化
 

参数化就是尽可能的通过一个用例，多组参数来模拟用户的行为；在使用参数化注解之前需要先用 @parameterizedTest 声明该方法为参数化方法，然后再通过注解提供数据来源
 

 
 
使用 @parameterizedTest 需要在 pom.xml 文件中进行配置（记得配置完要进行刷新）：
 
 
 
 
  1.  
    <!-- https://mvnrepository.com/artifact/org.junit.jupiter/junit-jupiter-params -->
     
  2.  
    <dependency>
     
  3.  
    <groupId>org.junit.jupiter</groupId>
     
  4.  
    <artifactId>junit-jupiter-params</artifactId>
     
  5.  
    <version>5.9.2</version>
     
  6.  
    </dependency>
     
 

 

 9db4323674f54d418699917762d5fef7.png​
 

2.1 单参数
 

单参数：@ValueSource(数据类型方法={参数1，参数2…})
 

 

import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.ValueSource;
 
public class JUnitDemo2 {
    //单参数:@ValueSource(数据类型方法={参数1，参数2…})
    @ParameterizedTest
    @ValueSource(ints = {1, 2, 3})
    void Test01(int num) {
        System.out.println(num);
    }
    @ParameterizedTest
    @ValueSource(strings = {"1", "2", "3"})
    void Test02(String number) {
        System.out.println(number);
    }
 
}
 

 

ab00f1f766f8489d8f5bb018d7588796.png
 

2.2 CSV 获取参数
 

 
 
假设上述参数有很多，在注解处手动编写数据源就有些不方便，我们这时就可以借助第三方csv文件来读取数据源
 

 

CSV 获取参数：@CsvFileSource(resources = "____.csv")
 

这个时候我们需要在 main 文件下 resources 中创建一个 test.csv 文件（.csv 和 参数必须相同）：
 

 

张三1，李四1，王五1
张三2，李四2，王五2
 

 

代码编写： 
 

 

import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.CsvFileSource;
//参数化
 
public class JUnitDemo2 {
    @ParameterizedTest
    @CsvFileSource(resources = "test.csv")
    void Test03(String name) {
        System.out.println(name);
    }
 
}
 

 

16918d94255147598901738ea8d083c2.png
 

 
 
 此时我们就把所有的内容都打印出来了；
 

 

2.3 方法获取参数
 

@CsvFileSource、@ValueSource 只能传递同种类型的参数，那么我们想要传多种参数，那么可以用方法获取参数
 

方法获取参数：@MethodSource("Generator")
 

 

import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;
import java.util.stream.Stream;
 
public class JUnitDemo2 {
    public static Stream<Arguments> Generator() {
        return Stream.of(Arguments.arguments(1, "张三"),
                Arguments.arguments(2, "李四"),
                Arguments.arguments(3, "王五")
        );
    }
 
    @ParameterizedTest
    @MethodSource("Generator")
    void Test04(int num, String name) {
        System.out.println(num + ":" + name);
    }
 
}
 

 

5af800df39744feebfc606790d5a5344.png
 

2.4 多参数
 

多参数：@CsvSource({“数据组合1”，“数据组合2”…})，每个双引号是一组参数（测试用例）
 

 

import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.*;
import java.util.stream.Stream;
public class JUnitDemo2 {
    //多参数：@CsvSource({“数据组合1”，“数据组合2”…})
    @ParameterizedTest
    @CsvSource({"1, 张三", "2, 李四", "3, 王五"})
    void manyTest(int num, String name) {
        System.out.println("num:" + num + ", name:" + name);
    }
 
}
 

 

199bae03a96c4f68a40f6b448640a938.png
 

3.测试用例的执行顺序
 

我们看以下代码：
 

553e12281dad43cfa275c59f51c082f8.png
 

 
 
此时我们看到打印的依次是 A、B、C 
 

 

7a9d04804c4d406c8a40fd0b0d85e4a5.png
 

 
 
此时我们看到打印的还是 A、B、C 
 

 

所以 测试用例的执行顺序并不会按照我们编写代码的顺序来执行
 

3.1 顺序执行：@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
 

 
 
如果在实际测试中，我们需要完成连贯的多个步骤的测试，是需要规定测试用例执行的顺序的，可以通过 @order 注解来实现排序
 
 
  • 先使用注解说明当前类下所有的用例需要使用 @order 注解来进行排序（注意：该注解必须要用在类上）
  • 然后通过 @order 来指定用例的具体顺序
 

 

顺序执行：@TestMethodOrder(MethodOrderer.OrderAnnotation.class)，然后再每次执行的时候添加 @order(执行顺序)
 

 

import org.junit.jupiter.api.MethodOrderer;
import org.junit.jupiter.api.Order;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestMethodOrder;
@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
public class JUnitDemo1 {
    @Order(2)
    @Test
    void test03() {
        System.out.println("C");
    }
    @Order(3)
    @Test
    void test01() {
        System.out.println("A");
    }
    @Order(1)
    @Test
    void test02() {
        System.out.println("B");
    }
}
 

 

 
 
这个时候我们通过 @Order 来设置执行顺序，按照这个思路，我们得到的结果为 B -> C -> A
 

 

01fe1501459f4dc492546c9b70de0e3a.png
 

3.2 随机执行：@TestMethodOrder(MethodOrderer.class)
 

随机执行：@TestMethodOrder(MethodOrderer.class)，也就是我们看到的一开始的执行顺序
 

 

import org.junit.jupiter.api.MethodOrderer;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestMethodOrder;
@TestMethodOrder(MethodOrderer.class)
public class JUnitDemo2 {
    @Test
    void test03() {
        System.out.println("C");
    }
    @Test
    void test01() {
        System.out.println("A");
    }
    @Test
    void test02() {
        System.out.println("B");
    }
}
 

 

58edd49f1092460ba0c321adff00713f.png
 

 
 
 因此，如果不写 @TestMethodOrder(MethodOrderer.OrderAnnotation.class) 则是随即执行
 

 

4.断言
 

检查测试方法的期望结果值和真实返回值，通过 Assertions 类实现
 

 
 
  • 断言匹配/不匹配：assertEquals()、assertNotEquals()
  • 断言结果为真/为假：assertTrue()、assertFalse()
  • 断言结果为空/非空：assertNull()、assertNotNull()
 

 

 

public class JUnitDemo3 {
    @Test
    void test01() {
        Assertions.assertTrue(1 == 1);
    }
    @Test
    void test02() {
        Assertions.assertTrue(2 == 1);
    }
}
 

 

a8ed87bcf9b6416f893c215471e354f6.png
 

 
 
 在这里我们可以看到 预期和结果 是否相同
 

 

5.测试套件
 

当我们一个类中有多个测试用例时，我们不可能挨个去运行，那样将会很耗费时间，这时我们就需要 测试套件 来指定类或者指定包名来运行类下或者包下的所有测试用例。
 

 
 
如果要使用测试套件，首先我们需要先创建一个类，通过 @Suite 注解标识该类为测试套件类（而不是测试类）
 

 

使用测试套件，需要引入依赖：
 

还需要引入依赖（使用 suite 需要引入 引擎engine 依赖）：
 

 

<!-- https://mvnrepository.com/artifact/org.junit.jupiter/junit-jupiter-engine -->
<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter-engine</artifactId>
    <version>5.9.1</version>
</dependency>
 

 

5.1 通过 class 运行测试用例
 

使用 @SelectClasses({指定类, 指定类, 指定类})
 

JUnitDemo1：
 

 

@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
public class JUnitDemo1 {
    @Order(2)
    @Test
    void test03() {
        System.out.println("C");
    }
    @Order(3)
    @Test
    void test01() {
        System.out.println("A");
    }
    @Order(1)
    @Test
    void test02() {
        System.out.println("B");
    }
}
 

 

JUnitDemo4：
 

 

public class JUnitDemo4 {
    public static Stream<Arguments> Generator() {
        return Stream.of(Arguments.arguments(1, "张三"),
                Arguments.arguments(2, "李四"),
                Arguments.arguments(3, "王五")
        );
    }
 
    @ParameterizedTest
    @MethodSource("Generator")
    void Test04(int num, String name) {
        System.out.println(num + ":" + name);
    }
}
 

 

RunSuite：
 

 

@Suite
@SelectClasses({JUnitDemo4.class, JUnitDemo1.class})
public class RunSuite {
 
}
 

 

 
 
此时就是先执行 JUnitDemo4，再执行 JUnitDemo1
 

 

4836567c7c08440480a06f094bd1fdf3.png
 

5.2 通过包运行测试用例
 

@SelectPackages(value = {"包1", "包2","..."})
 

JUnit1 包下 Test1：
 

 

public class Test1 {
    @Test
    void test1() {
        System.out.println("JUnit1 package Test1 test1");
    }
}
 

 

JUnit2 包下 Test2：
 

 

public class Test2 {
    @Test
    void test2() {
        System.out.println("JUnit2 package Test2 test2");
    }
}
 

 

RunSuite2：
 

 

@Suite
@SelectPackages(value = {"JUnit1", "JUnit2"})
public class RunSuite2 {
}
 

 

 
 
此时先执行 JUnit1 包下 Test1 ，再执行 JUnit2 包下 Test2
 

 

34267cd772e2488c8598a6127b9f4437.png

                

        

        

        

    




    

      

        

            

              
                
                  测试小贝
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                    22
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    20
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      

            

                专栏目录
          










                



	

		

			

				
					
接口自动化测试框架Karate入门

				
			

			

				

					01-27
				

			

		

		

			
				
【接口自动化测试框架Karate入门】是一篇引导读者了解如何使用Karate进行接口自动化测试的文章。Karate是一个基于Cucumber-JVM的开源测试框架，它专门设计用于Web-API的自动化测试，简化了接口测试的复杂性，使得...

			
		

	



                

              
                



	

		

			

				
					
自动化测试集成指南 -- 本地单元测试

				
			

			

				

					cmyperson的博客
				

				

					07-11
					
					1964
					
				

			

		

		

			
				
构建本地单元测试

简介：

单元测试(Unit Test) 是针对 程序的最小单元 来进行正确性检验的测试工作。程序单元是应用的最小可测试部件。一个单元可能是单个程序、类、对象、方法等。

如何区分单元测试和集成测试，一般情况下，单元测试应该不依赖数据库，网络，I/O和其他模块，否则就是集成测试

单元测试特性

单元性（快速）
	测试力度足够小，能够精确定位问题
	
单一职责：一个测试case只负责一条路径，测试代码中不允许有复杂的逻辑条件
	独立性（无依赖）
	避免单元测试之间的依赖关系，一个测试..

			
		

	



                


  
              

                


	

		

			

				
					
Junit单元测试框架详解

				
			

			

				

					斯文~
				

				

					06-28
					
					583
					
				

			

		

		

			
				
JUnit单元测试就是针对最小的功能单元编写测试代码，Java程序最小的功能单元是方法，因此，单元测试就是针对Java方法的测试，进而检查方法的正确性。手动测试的缺点
只有一个main方法，如果一个方法的测试失败了，其他方法测试会受到影响。无法得到测试的结果报告，需要程序员自己去观察测试是否成功。无法实现自动化测试。Junit单元测试框架
JUnit是使用Java语言实现的单元测试框架，它是开源的，Java开发者都应当学习并使用JUnit编写单元测试；此外，几乎所有的IDE工具都集成了JUnit，这样我们就

			
		

	





	

		

			

				
					
全网最详细的Python自动化测试（unittest框架)

					
最新发布

				
			

			

				

					apex_eixl的博客
				

				

					05-09
					
					848
					
				

			

		

		

			
				
框架是由大佬开发或者专业的研发团队研发的技术骨架，框架是一个半成品，框架是对常用的功能，基础的代码进行封装的一个工具，这个工具对外提供了一些API，其他的开发者只需要调用框架的接口即可，可以省去很多代码的编写，从而提高工作效率。

			
		

	



		

			
		



	

		

			

				
					
【软件测试】单元测试工具---Junit详解

					
热门推荐

				
			

			

				

					m0_57248752的博客
				

				

					07-26
					
					1万+
					
				

			

		

		

			
				
虽然我们已经学习了selenium测试框架，但是有的时候测试用例很多，我们需要一个测试工具来管理这些测试用例，Junit就是一个很好的管理工具，简单来说Junit是一个针对Java单元测试的框架。（test suite）有时也称为验证套件（validation suite），是许多测试用例的集合，测试用例可用来测试一程式是否正确工作，测试套件包括许多测试用例，一般也会有针对测试用例及其测试目的的详细说明，在进行测试时的系统组态资讯以及测试前需进行的步骤。有人觉得junit的测试顺序是从上到下的，是这样吗？

			
		

	





	

		

			

				
					
软件测试之单元测试自动化入门基础

				
			

			

				

					qq_57747969的博客
				

				

					09-29
					
					1641
					
				

			

		

		

			
				
软件测试之单元测试自动化入门基础

			
		

	





	

		

			

				
					
几款好用的自动化单元测试框架和工具

				
			

			

				

					m0_50579386的博客
				

				

					03-30
					
					4089
					
				

			

		

		

			
				
用自动化单元测试的方式，研发人员（通常建议单元测试由开发人员完成最为高效，但是开发人员通常项目任务紧，时间和精力不够）在用例设计、执行和数据管理上不需要再花费巨量的时间，就可能有足够的精力来真正进行和完成单元测试内容。

			
		

	





	

		

			

				
					
敏捷自动化测试-Java-黑盒单元测试

				
			

			

				

					09-18
				

			

		

		

			
				
本文将深入探讨"敏捷自动化测试-Java-黑盒单元测试"这一主题，涵盖相关的重要知识点。  首先，我们要理解什么是敏捷自动化测试。敏捷开发是一种强调快速响应变化、迭代开发和团队协作的软件开发方法论。自动化测试在...

			
		

	





	

		

			

				
					
测试+JUnit+单元测试+学习 

				
			

			

				

					02-26
				

			

		

		

			
				
JUnit是Java编程语言中广泛使用的单元测试框架，对于开发者来说，掌握JUnit的使用是提高工作效率和保证代码质量的关键步骤。本资源将带你深入学习JUnit及其在单元测试中的应用。  单元测试是对软件中的最小可测试...

			
		

	





	

		

			

				
					
免费的Junit的单元测试jar包

				
			

			

				

					09-02
				

			

		

		

			
				
Junit是Java编程语言中最常用的单元测试框架，它为开发者提供了丰富的功能来编写、运行和管理测试用例。在这个场景中，我们讨论的是一个免费的Junit单元测试jar包，该包可用于进行Java程序的单元测试。  首先，让...

			
		

	





	

		

			

				
					
深入浅出Android 自动化测试1

				
			

			

				

					08-04
				

			

		

		

			
				
本文将深入探讨Android自动化测试的不同方面，包括测试工具、分类、实践以及代码覆盖率。  首先，我们来看看常见的Android自动化测试工具。Monkey、EasyMonkey、MonkeyRunner主要用于模拟用户操作，进行压力测试；...

			
		

	





	

		

			

				
					
基于 Spring Boot 框架的人事管理系统的设计与实现 附完整代码+论文+ppt

				
			

			

				

					机器学习深度学习业余选手
				

				

					02-08
					
					4155
					
				

			

		

		

			
				
基于 Spring Boot 框架的人事管理系统的设计与实现 附完整代码+论文+ppt

			
		

	





	

		

			

				
					
JUnit 测试框架

				
			

			

				

					sjp151的博客
				

				

					12-13
					
					1784
					
				

			

		

		

			
				
文章讲解了 JUnit 框架的注解，断言，用例执行顺序，测试套件，还有参数化。

			
		

	





	

		

			

				
					
自动化测试-单元测试

				
			

			

				

					白天像蚂蚁一样工作，晚上像蝴蝶一样生活
				

				

					01-12
					
					1227
					
				

			

		

		

			
				
1. 单元测试的概念

单元测试（unit testing），是指对软件中的最小可测试单元进行检查和验证。对于单元测试中单元的含义，一般来说，要根据实际情况去判定其具体含义，如C语言中单元指一个函数，Java里单元指一个类，图形化的软件中可以指一个窗口或一个菜单等。总的来说，单元就是人为规定的最小的被测功能模块。单元测试是在软件开发过程中要进行的最低级别的测试活动，软件的独立单元将在与程序的其他部分相隔离的情况下进行测试。





2. 单元测试的工具类型

静态分析工具
	代码规范审核工具
	内存和资.

			
		

	





	

		

			

				
					
单元测试工具-Junit

				
			

			

				

					trong_ 的烂笔头
				

				

					11-10
					
					877
					
				

			

		

		

			
				
介绍Junit5的常用操作，常用注解，参数化，控制用例执行顺序，断言，测试套件等。

			
		

	





	

		

			

				
					
在Python中进行自动化单元测试的教程

				
			

			

				

					软件测试技术交流分享
				

				

					03-04
					
					914
					
				

			

		

		

			
				
大型软件系统的开发是一个很复杂的过程，其中因为人的因素而所产生的错误非常多，因此软件在开发过程必须要有相应的质量保证活动，而软件测试则是保证质量的关键措施。正像软件熵（software entropy）所描述的那样：一个程序从设计很好的状态开始，随着新的功能不断地加入，程序逐渐地失去了原有的结构，最终变成了一团乱麻（其实最初的"很好的状态"得加个问号）。测试的目的说起来其实很简单也极具吸引力，那就是写出高质量的软件并解决软件熵这一问题。

			
		

	





	

		

			

				
					
JUnit 单元自动化

				
			

			

				

					LEE180501的博客
				

				

					11-19
					
					1477
					
				

			

		

		

			
				
Junit 是 Java 中用于单元测试的框架。使用 Junit 能让我们快速高效的完成单元测试

			
		

	





	

		

			

				
					
自动化测试Junit

				
			

			

				

					weixin_44431128的博客
				

				

					06-05
					
					996
					
				

			

		

		

			
				
Junit5
注解
@Test
@Disabled
@BeforeAll、@AfterAll、@BeforeEach、@AfterEach
参数化
单参数
多参数
CSV获取参数
方法获取参数
测试用例执行顺序
断言 assert
断言相等
断言不相等
断言为空
断言不为空
测试套件
自动化测试项目
1. 熟悉项目
2. 针对核心流程设计手工测试用例
3. 将手工测试用例转换成自动化测试用例
4. 部署

			
		

	





	

		

			

				
					
Perl单元测试自动化实践与Test::Class框架详解

				
			

			

				

					
				

			

		

		

			
				
本文将深入探讨Perl中的单元测试自动化，重点关注Test::Class和Test::Unit这两个主要的单元测试框架。  首先，Perl单元测试框架的使用是为了应对快速变化的需求，确保代码在开发的不同阶段都经过充分的检验。不同于...

			
		

	



              



  
“相关推荐”对你有帮助么？

  

      
    
          
  • 
              
    
                  
                  
              
    
              
    非常没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    一般
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    有帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    非常有帮助
    
          
    • 
      

      

      

          
          提交
      

      

  




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值