探索JUnit的核心

于 2024-12-22 14:37:41 发布
阅读量772 收藏 11
点赞数 18
分类专栏： 高效单元测试 文章标签： 测试工具 单元测试 junit java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_74849460/article/details/144646383
版权

第2章 探索JUnit的核心

1、了解Junit框架的核心相关类；

2、理解测试运行器；

3、掌握参数化测试（重点）4、掌握测试套件（重点、难点）

1、Junit的核心类

（1）测试用例：包含一个或更多用@Test进行注释的测试方法的类。一个TestCase把具有的公共行为的测试归入一组。

测试元素描述
断言Assert用于定义测试条件，如果条件满足则不执行任何操作，否则抛出异常。
测试方法Test被@Test注解标记的方法，每个这样的方法代表一个测试用例。JUnit通过创建测试类的实例并调用这些方法来运行测试。
测试类 Test class包含一个或多个@Test方法的类，用于组织和包含相关的测试用例。
测试套件 suite允许将多个测试类组合在一起运行，以便于管理和执行一组相关的测试。
测试运行器 Runner负责执行测试的类。JUnit 4的运行器可以运行JUnit 3和JUnit 4的测试用例。
assertXXX 方法用途
assertArrayEquals(“message”, A, B)断言数组A和B相等。
assertEquals(“message”, A, B)断言对象A和B相等。该方法实际上在第一个对象上对第二个对象调用equals()方法。
assertSame(“message”, A, B)断言对象A和B具有相同的值。与前一个断言方法不同，它检查A和B是否为同一个对象（使用==运算符）。
assertTrue(“message”, A)断言条件A为真。
assertNotNull(“message”, A)断言对象A不为null。

补充：

1、assertThat断言：

  1. JUnit4.4引入了Hamcrest框架，Hamcest提供了一套匹配符Matcher

  2. 使用全新的断言语法：assertThat，结合Hamcest提供的匹配符，只用这一个方法，就可以实现所有的测试；

  3. assertThat语法如下：

    assertThat(T actual, Matcher<T> matcher);

    assertThat(String reason, T actual, Matcher<T> matcher);

2、测试运行器Runner

JUnit4可以向后兼容JUnit3版本，JUnit的最新版本中提供了不同的运行器。

运行器目的
org.junit.internal.runners.JUnit38ClassRunner这个运行器包含在当前的JUnit版本中，仅仅是为了向后兼容。它将测试用例作为JUnit 3.8的测试用例来启动
org.junit.runners.JUnit4这个运行器将测试用例作为JUnit 4的测试用例来启动
org.junit.runners.Parameterized这个测试运行器可以使用不同参数来运行相同的测试集
org.junit.runners.SuiteSuite是一个包含不同测试的容器，同时Suite也是一个运行器，可以运行一个测试类中所有以@Test 注释的方法

3、@RunWith

注解名称描述
@RunWith当一个类被@RunWith注解标记，或者继承了一个被@RunWith注解标记的类时，JUnit将调用注解中引用的类来运行该类中的测试，而不是使用JUnit内置的运行器。
使用场景JUnit测试用例是通过Runner（运行器）执行的。使用@RunWith注解可以为一个测试类指定一个特定的Runner。
功能允许开发者自定义测试类的执行方式，通过指定不同的Runner来实现不同的测试行为，例如参数化测试、套件测试等。

eg：

使用Junit3来写

 @RunWith(value=org.junit.internal.runners.JUnit38ClassRunner.class) 
 public class TestWithJUnit38 extends junit.framework.TestCase { 
     […] 
 }

使用Junit4来写

 @RunWith(value=org.junit.runners.JUnit4.class)
 public class TestWithJUnit4 {
   private   Calculator cal;
     @Before
      public void setUp(){
     cal=new Calculator();
     }
     @Test
     public void add(){
     double result=cal.add(50, 10);
     assertEquals(60,result,0);
     }
 }
 ​

参数化测试：当要运行某个方法不同的参数多次测试时，参数化运行器提供了很大的方便。

eg：

对Calculator类中add方向分别用三组不同的数据进行测试：{1,1}，{-20,-30}，{10,0}

 @RunWith(value=Parameterized.class)
 public class ParameterizedTest {
     private int expected;
     private int valueone;
     private int valuetwo;
     @Parameters
     public static List<Object[]>  data(){
         return Arrays.asList(new Object[][]{
                 {2,1,1},
                 {-50,-20,-30},
                 {10,10,0}
         });
     }
         public ParameterizedTest(int expected,int  valueone,int valuetwo){
         this.expected=expected;
         this.valueone=valueone;
         this.valuetwo=valuetwo;
     }
     @Test
     public void testAdd(){
        Calculator cal=new Calculator();
       assertEquals(expected,cal.add(valueone, valuetwo),0);
     }
 }
 

  • Parameterized.class指定参数化运行器

  • @Parameters指定参数化测试所用的测试数据

  • ParameterizedTest编写构造方法，指定参数的调用顺序

  • assertEquals(expected,cal.add(valueone, valuetwo),0);编写测试方法，调用参数

2、测试套件

测试套件： 一组测试，一个测试套件是把多个相关测试归入一组的便捷方式。（简单来说，就是要组合多个Test case一起运行）

JUnit 用Suite或TestSuite可以运行一个或多个 test case ,test runner负责启动TestSuite，而要运行哪些test case则由TestSuite决定。

eg：

使用Junit3写的测试套件用例

 public class SuiteWithJUnit38 {
     public static Test suite(){
         TestSuite suite=new TestSuite();
         suite.addTestSuite(TestWithJUnit38.class);
         suite.addTestSuite(TestWithJUnit38_2.class);
         //junit3套件不能加入junit4测试用例
         //suite.addTestSuite(TestWithJUnit4.class); 
         suite.addTest(SuiteWithJunit38_2. suite()); 
         return suite;   
     }
 }
 ​

使用Junit4写的套件

注意：多个单元测试类整合测试 只需要把相关的class放入到SuiteClasses{}中即可

 @RunWith(Suite.class)
 @SuiteClasses(value={SuiteWithJUnit38.class,
         TestWithJUnit4.class}
                     )
 public class SuiteWithJUnit4 {
     ...
 }

3、实验

简单的实验操作，方便更容易理解本节学习内容

  • 掌握hamcrest与assertthat的使用

  • 掌握测试套件的编写

  • 掌握参数化测试；

在实验前先进行环境准备，需要导入hamcrest，类路径导入

img

首先，创建T.java类

 import java.util.List;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Map;
 public class T {
     public int add(int a, int b) {
         return a + b;
     }
     public double div(double a, double b) {
         return a / b;
     }
     public String getName(String name) {
         return name;
     }
     public List<String> getList(String item) {
         List<String> l = new ArrayList<String>();
         l.add(item);
         return l;
     }
     public Map<String, String> getMap(String key, String value) {
         Map<String, String> m = new HashMap<String, String>();
         m.put(key, value);
         return m;
     }
 }

接着创建测试类TTest.java

 package lab2;
 import static org.hamcrest.Matchers.*;
 import static org.junit.Assert.*;
 ​
 import java.util.List;
 import java.util.Map;
 import org.junit.Test;
 ​
 public class TTest {
     @Test
     public void testAdd() {
         // 一般匹配符
         int s = new T().add(1, 1);
         assertEquals(2, s);
 ​
         // allOf：所有条件必须都成立，测试才通过
         assertThat(s, allOf(greaterThan(1), lessThan(3)));
         // anyOf：只要有一个条件成立，测试就通过
         assertThat(s, anyOf(greaterThan(1), lessThan(1)));
         // anything：无论什么条件，测试都通过
         assertThat(s, anything());
         // is：变量的值等于指定值时，测试通过
         assertThat(s, is(2));
         // not：和is相反，变量的值不等于指定值时，测试通过
         assertThat(s, not(1));
         }
         @Test
         public void testDiv() {
         // 数值匹配符
         double d = new T().div(10, 3);
         // closeTo：浮点型变量的值在3.0±0.5范围内，测试通过
         assertThat(d, closeTo(3.0, 0.5));
         // greaterThan：变量的值大于指定值时，测试通过
         assertThat(d, greaterThan(3.0));
         // lessThan：变量的值小于指定值时，测试通过
         assertThat(d, lessThan(3.5));
         // greaterThanOrEuqalTo：变量的值大于等于指定值时，测试通过
         assertThat(d, greaterThanOrEqualTo(3.3));
         // lessThanOrEqualTo：变量的值小于等于指定值时，测试通过
         assertThat(d, lessThanOrEqualTo(3.4));
         }
         @Test
         public void testGetName() {
         // 字符串匹配符
         String n = new T().getName("Magci");
         // containsString：字符串变量中包含指定字符串时，测试通过
         assertThat(n, containsString("ci"));
         // startsWith：字符串变量以指定字符串开头时，测试通过
         assertThat(n, startsWith("Ma"));
         // endsWith：字符串变量以指定字符串结尾时，测试通过
         assertThat(n, endsWith("i"));
         // euqalTo：字符串变量等于指定字符串时，测试通过
         assertThat(n, equalTo("Magci"));
         // equalToIgnoringCase：字符串变量在忽略大小写的情况下等于指定字符串时，测试通过
         assertThat(n, equalToIgnoringCase("magci"));
         // equalToIgnoringWhiteSpace：字符串变量在忽略头尾任意空格的情况下等于指定字符串时，测试通过
         assertThat(n, equalToIgnoringWhiteSpace(" Magci  "));
         }
         @Test
         public void testGetList() {
         // 集合匹配符
         List<String> l = new T().getList("Magci");
         // hasItem：Iterable变量中含有指定元素时，测试通过
         assertThat(l, hasItem("Magci"));
         }
         @Test
         public void testGetMap() {
         Map<String, String> m = new T().getMap("mgc", "Magci");
         // hasEntry：Map变量中含有指定键值对时，测试通过
         assertThat(m, hasEntry("mgc", "Magci"));
         // hasKey：Map变量中含有指定键时，测试通过
         assertThat(m, hasKey("mgc"));
         // hasValue：Map变量中含有指定值时，测试通过
         assertThat(m, hasValue("Magci"));
     }
 }

运行结果：

img

使用Junit3写测试套件

（1）编写TTestWithJunit3_1.java文件

 package lab2;
 ​
 import junit.framework.Assert;
 import junit.framework.TestCase;
 import static org.hamcrest.Matchers.*;
 import static org.junit.Assert.*;
 ​
 import java.util.List;
 import java.util.Map;
 import org.junit.Test;
 ​
 ​
 public class TTestWithJunit3_1 extends TestCase {
 ​
     private T t;
     
     protected void setUp() throws Exception {
         super.setUp();
         t = new T();
     }
 ​
     protected void tearDown() throws Exception {
         super.tearDown();
     }
 ​
     public void testAdd() {
         Assert.assertEquals(3,t.add(1, 2),0);
     }
     
     public void testDiv() {
         fail("Not yet implemented");
     }
 }

（2）编写TTestWithJunit3_2.java文件

 package lab2;
 ​
 import junit.framework.TestCase;
 ​
 public class TTestWithJunit3_2 extends TestCase {
 ​
     private T t;
 ​
     protected void setUp() throws Exception {
         super.setUp();
         t = new T();
     }
 ​
     protected void tearDown() throws Exception {
         super.tearDown();
     }
 ​
     public void testGetName() {
         String result = t.getName("Magci");
         assertEquals("Magci", result);
     }
     
     public void testGetMap() {
         fail("fail");
         
     }
 }

运行结果：

img

img

（3）编写AllTestWithJunit3.java文件

 package lab2;
 ​
 import junit.framework.TestCase;
 import junit.framework.TestSuite;
 ​
 public class AllTestWithJunit3 extends TestCase {
 ​
     public static TestSuite suite() {
         TestSuite suite = new TestSuite("T Tests");
         suite.addTestSuite(TTestWithJunit3_1.class);
         suite.addTestSuite(TTestWithJunit3_2.class);
         return suite;
     }
 }

运行结果：

img

使用Junit4写测试套件

（1）编写AllTestWithJunit4.java文件

 package lab2;
 ​
 import org.junit.runner.RunWith;
 import org.junit.runners.Suite;
 ​
 @RunWith(Suite.class)
 @Suite.SuiteClasses({
     TTestWithJunit4_1.class,  
     TTestWithJunit4_2.class            
 })
 public class AllTestWithJunit4 {
 }

（2）编写TTestWithJunit4_1.java文件

 package lab2;
 ​
 import static org.junit.Assert.assertEquals;
 ​
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
 ​
 public class TTestWithJunit4_1 {
 ​
     private T t;
 ​
     @Before
     public void setUp() throws Exception {
         t = new T();
     }
 ​
     @After
     public void tearDown() throws Exception {
     }
 ​
     @Test
     public void testAdd() {
         int result = t.add(2, 2);
         assertEquals(4, result);
     }
 ​
     @Test
     public void testGetName() {
         String result = t.getName("Magci");
         assertEquals("Magci", result);
     }
 }

（3）编写TTestWithJunit4_2.java文件

 package lab2;
 ​
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
 import org.junit.runners.Parameterized.Parameters;
 ​
 import java.util.Arrays;
 import java.util.Collection;
 ​
 import static org.junit.Assert.assertEquals;
 ​
 ​
 @RunWith(Parameterized.class)
 public class TTestWithJunit4_2 {
 ​
     private final double expected;
     private final int numerator;
     private final int denominator;
 ​
     // 构造函数，用于接收测试参数
     public TTestWithJunit4_2(double expected, int numerator, int denominator) {
         this.expected = expected;
         this.numerator = numerator;
         this.denominator = denominator;
     }
 ​
     
     @Parameters
     public static Collection<Object[]> data() {
         return Arrays.asList(new Object[][]{
             {1.0, 1, 1},
             {0.0, 0, 2},
             {0.0, 2, 0},  
             {-2147483647.0, 2147483647, -1}
         });
     }
 ​
     @Test
     public void testDiv() {
         T t = new T();
         assertEquals(expected, t.div(numerator, denominator), 0.0001);
     }
 }

运行结果：

img

img

参数化测试

（1）编写AllTestWithJunit4_2.java文件

 package lab2;
 ​
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
 import org.junit.runners.Parameterized.Parameters;
 ​
 import java.util.Arrays;
 import java.util.Collection;
 ​
 import static org.junit.Assert.assertEquals;
 ​
 ​
 @RunWith(Parameterized.class)
 public class TTestWithJunit4_2 {
 ​
     private final double expected;
     private final int numerator;
     private final int denominator;
 ​
     // 构造函数，用于接收测试参数
     public TTestWithJunit4_2(double expected, int numerator, int denominator) {
         this.expected = expected;
         this.numerator = numerator;
         this.denominator = denominator;
     }
 ​
     
     @Parameters
     public static Collection<Object[]> data() {
         return Arrays.asList(new Object[][]{
             {1.0, 1, 1},
             {0.0, 0, 2},
             {0.0, 2, 0},  
             {-2147483647.0, 2147483647, -1}
         });
     }
 ​
     @Test
     public void testDiv() {
         T t = new T();
         assertEquals(expected, t.div(numerator, denominator), 0.0001);
     }
 }

运行结果：

img

至此，我们的就认识到Junit的核心到这里！！

创作不易，点点小赞，关注一下博主吧！！😭😍

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值