在MyEclipse中使用Junit 的方法 回归测试

于 2019-02-25 15:18:35 发布
阅读量728 收藏 1
点赞数
分类专栏： java

一、回归测试的目的

回归测试是指修改了旧代码后，重新进行测试以确认修改没有引入新的错误或导致其他代码产生错误。自动回归测试将大幅降低系统测试、维护升级等阶段的成本。回归测试作为软件生命周期的一个组成部分，在整个软件测试过程中占有很大的工作量比重，软件开发的各个阶段都会进行多次回归测试。在渐进和快速迭代开发中，新版本的连续发布使回归测试进行的更加频繁，而在极端编程方法中，更是要求每天都进行若干次回归测试。因此，通过选择正确的回归测试策略来改进回归测试的效率和有效性是非常有意义的。
　　1.回归测试是指重复以前的全部或部分的相同测试。
　　2.新加入测试的模组，可能对其他模组产生副作用，故须进行某些程度的回归测试。
　　3.回归测试的重心，以关键性模组为核心。

 

二、mycilipse添加junit

myeclipse自带junit jar包。

在工程上邮件，build path--config build path--add library--选择junit4

 

三、在MyEclipse中使用Junit 的方法
2016年10月25日 08:57:50 qinjianhuang 阅读数：8101
 版权声明：本文为博主原创文章，未经博主允许不得转载。    https://blog.csdn.net/sinat_35512245/article/details/52918120
在MyEclipse中使用Junit 的方法，这一部分先记 Test Case 的创建方法。

Test Case ：是指对一个用例进行测试，比如说测试一个接口，对于接口来说，一组输入值就是一个Test Case 。MyEclipse中创建Junit 的步骤如下：

1、选择一个存放测试类的package，右键–>new–>Other–>Java–>JUnit–>JUnit Test Case–>填写完测试类的名字， 然后，点“finish”，这样就创建了一个 Junit Case。

 

四、Junit 介绍:

Junit是一套框架（用于JAVA语言），由 Erich Gamma 和 Kent Beck 编写的一个回归测试框架（regression testing framework），即用于白盒测试。

 

本文介绍的内容:

1 Junit Myeclipse测试类的生成

2 JUnit 4 常用的几个annotation 介绍与使用 (@Before  @After @Test @Ignore @BeforeClass @AfterClass)

3 常用的断言介绍

4 特殊的处理 (限时测试，异常测试)

5 参数化配置 (@Parameters)

 

准备测试代码

测试的方法（正确、错误方法、死循环、抛异常）

LogicService

复制代码

package com.logic;

public class LogicService {
    
    public int add(int x ,int y){ //加法
        return x+y;
    }
    
    public int sub(int x ,int y){ //减法
        return x-y;
    }
    
    public int div(int x ,int y){ //除法 
        return x/y;
    }
    
    public int div2(int x ,int y){ //除法  做了异常判断
        try {
            int z = x/y;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return x/y;
    }
    
    public void loop(int x ,int y){ //死循环
        for(;;)
            x=y;
    }    
    
    public void unCompleted(int x ,int y){ //未完成的模块
        //还在开发中
    }
    
}

复制代码

 

一  Myeclipse测试类的生成

1 对需要测试的类点右键 NEW 一个Junit Test Case

 

 

2 点击NEXT

 注意 1 选择NEW Junit 4 test

        2 source folder 是默认会填写上之前右键NEW的那个类，如果不是的话，请自行进行修改

        3 package 默认会填写当前的包名 个人建议重新开个测试包-即在包后面加上.test 表示是单元测试用例专用包与源代码分离

        4 name 默认会在之前右键NEW的那个类的基础的后面加上Test 如果不是的话，建议自行进行修改，便于标示

        5 初始化的方法，我一般会勾上个setUp，这个请随意。

        

3 继续点击NEXT

1 这里可以选择需要测试的方法，我一般都是全选的然后在生成的测试类中再做处理

2 点击finish完成

 

4 生成的单元测试类

复制代码

package com.logic.test;

import static org.junit.Assert.*;

import org.junit.Before;
import org.junit.Test;

public class LogicServiceTest {

    @Before
    public void setUp() throws Exception {
    }

    @Test
    public void testAdd() {
        fail("Not yet implemented");
    }

    @Test
    public void testSub() {
        fail("Not yet implemented");
    }

    @Test
    public void testDiv() {
        fail("Not yet implemented");
    }

    @Test
    public void testDiv2() {
        fail("Not yet implemented");
    }

    @Test
    public void testLoop() {
        fail("Not yet implemented");
    }

    @Test
    public void testUnCompleted() {
        fail("Not yet implemented");
    }

}

复制代码

 

二 JUnit 4 常用的几个annotation 介绍与使用 (@Before  @After @Test @Ignore @BeforeClass @AfterClass)

1 常用的annotation介绍

 @Before：初始化方法，在任何一个测试执行之前必须执行的代码; 

 @After：释放资源，在任何测试执行之后需要进行的收尾工作。在每个测试方法执行之后执行一次，该annotation只能修饰public void 方法;

 @Test：测试方法，表明这是一个测试方法。在Junit中将会自动被执行。该annotation只你呢个修饰public void 方法。

 @Ignore：忽略的测试方法，标注的含义就是“某些方法尚未完成，暂不参与此次测试”;

 @BeforeClass：针对所有测试，只执行一次，且必须为public static void;一般用于初始化必要的消耗较大的资源，例如数据库连接等

 @AfterClass：针对所有测试，将会在所有测试方法执行结束后执行一次，且必须为public static void; 

 

2 常用的annotation测试

 修改单元测试类LogicServiceTest

复制代码

package com.logic.test;

import static org.junit.Assert.*;

import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Ignore;
import org.junit.Test;

public class LogicServiceTest {

    @Before
    public void setUp() throws Exception {
        System.out.println("@Before");//测试@Before
    }

    @After
    public void end() throws Exception {
        System.out.println("@After");//测试@@After
    }

    @BeforeClass
    public static void init() throws Exception {
        System.out.println("@BeforeClass");//测试@BeforeClass
    }

    @AfterClass
    public static void disstroy() throws Exception {
        System.out.println("@AfterClass");//测试@AfterClass
    }

    @Test
    public void testAdd() {
        System.out.println("@Test testAdd");//测试@Test
    }

    @Test
    public void testSub() {
        System.out.println("@Test testSub");//测试@Test
    }

    @Ignore
    public void testDiv() {
        System.out.println("@Ignore ");//测试@Ignore
    }

    @Ignore
    public void testDiv2() {
        System.out.println("@Ignore ");//测试@Ignore
    }

    @Ignore
    public void testLoop() {
        System.out.println("@Ignore ");//测试@Ignore
    }

    
    public void testUnCompleted() {
        System.out.println("@Ignore ");//测试未标注
    }

}

复制代码

 

执行结果

执行结果分析

1 @BeforeClass和@AfterClass只执行一次，在所有方法开始前/后

2 @Before和@After在每个@Test标注的方法前后各执行一次

3 @Test 标注的方法都会执行一次（表示要测试的方法）

4 @Ignore方法不会被执行，没有annotation的方法也不会被执行

5 总结  @BeforeClass –> （@Before –> @Test –> @After） –> @AfterClass

 

理解了以上注解后就可以尝试着在日常的项目中使用Junit进行单元测试了。

 

3 常用的断言介绍

assertEquals(String msg, Object expectRes, Object Res) --------  用于值判断

判断expectRes.equals(Res) ，表示值等于的判断，失败则抛MSG

assertSame(String msg, Object expectRes, Object Res)  --------  用于地址判断

判断expectRes==Res，表示地址等于的判断，失败则抛MSG

assertTrue(String msg,Boolean result) ----------------------------用于Boolean判断

判断result是true还是false，失败则抛MSG

assertNull(String msg,Object result)-------------------------------用于NULL判断

判断result是否为NULL，失败则抛MSG

fail(String msg);---------------------------------------------------直接中止方法运行

直接中止方法运行，抛出MSG

 

测试代码

复制代码

package com.logic.test;

import static org.junit.Assert.*;

import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Ignore;
import org.junit.Test;

import com.logic.LogicService;

public class LogicServiceTest {
    LogicService logserv ;

    @Before
    public void setUp() throws Exception {
        logserv = new LogicService();
    }

    @Test
    public void testAdd() {
        String a = "aa";
        String t = "a";
        String b = "a"+t;
        assertEquals("assertEquals", a, b) ; //A与B的关系是值相等，地址不相等，这个用例会成功
    }

    @Test
    public void testSub() {
        String a = "aa";
        String t = "a";
        String b = "a"+t;
        assertSame("assertSame", a, b) ; //A与B的关系是值相等，地址不相等,这个用例会失败
    }

    @Test
    public void testDiv() {
        assertTrue("assertTrue",true);//用例成功
        assertTrue("第二个为false失败",false);//用例失败
    }

    @Test
    public void testDiv2() {
        assertNull("assertNull",null);//用例成功
        assertNull("第二个为notNull失败","a");//用例失败
    }

    @Ignore
    public void testLoop() {
    }

    @Ignore
    public void testUnCompleted() {
    }

}

复制代码

 

执行结果分析

这里我不再截图了

1 成功

2 失败，返回MSG为assertSame

3 第一个成功，第二个失败，返回MSG为第二个为false失败

4 第一个成功，第二个失败，返回MSG为第二个为notNull失败

断言是用来判断被测方法执行的结果与预期结果是否匹配

 

4 特殊的处理 (限时测试，异常测试)

1 Junit提供限时处理的机制。

@Test(timeout=1000) 单位毫秒

当方法用时超过1000毫秒时，此方法会自动中止并执行失败

复制代码

package com.logic.test;

import static org.junit.Assert.*;

import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Ignore;
import org.junit.Test;

import com.logic.LogicService;

public class LogicServiceTest {
    LogicService logserv ;

    @Before
    public void setUp() throws Exception {
        logserv = new LogicService();
    }

    @Ignore
    public void testAdd() {
    }

    @Ignore
    public void testSub() {
    }

    @Ignore
    public void testDiv() {
    }

    @Test(timeout=1000) 
    public void testDiv2() {
        System.out.print("我不会超过1000毫秒的");
    }

    @Test(timeout=1000) 
    public void testLoop() {
        logserv.loop(1, 1);//此方法使用的是死循环实现，所以一定会超过限时，超过限时后此方法会自动中止
    }

    @Ignore
    public void testUnCompleted() {
    }

}

复制代码

执行结果

loop方法超时报错，div2方法不超时成功

 

2 Junit提供异常处理的机制。

@Test(expected=Exception.class) 其中Exception.class可以写的更加具体

测试

复制代码

    @Test(expected=Exception.class)
    public void testDiv() {
        System.out.print(logserv.div(3, 0));
    }

    @Test(expected=Exception.class)
    public void testDiv2() {
        System.out.print(logserv.div(3, 0));
    }

复制代码

执行结果

两个都通过

 

测试

复制代码

    @Test(expected=Exception.class)
    public void testDiv() {
        System.out.print(logserv.div(3, 0));
    }

    @Test
    public void testDiv2() {
        System.out.print(logserv.div(3, 0));
    }

复制代码

执行结果

第一个通过 第二个不通过 异常为除数不能为zero

 

5 参数化配置 (@Parameters)   重要

进行单元测试的时候，通常一个方法需要好几个case进行测试，Junit提供参数化便于我们对方法进行多种参数的组合测试

如果不使用参数化进行测试的话，那么我们的测试类会做的很臃肿

例如

复制代码

    @Test
    public void testAdd() {
        assertEquals("1+1 失败",2,logserv.add(1, 1) );
    }
    @Test
    public void testAdd1() {
        assertEquals("1+2 失败",3,logserv.add(1, 2) );
    }
    @Test
    public void testAdd2() {
        assertEquals("1+3 失败",3,logserv.add(1, 3) );
    }
    @Test
    public void testAdd3() {
        assertEquals("1+4 失败",3,logserv.add(1, 4) );
    }

复制代码

这样的测试类显然看起来不是很理想，代码过于重复

 

参数化的实现过程（重要）

1 在测试类上增加

@RunWith(Parameterized.class)并引入

import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;

2 写上构造类的函数及定义入参

例如

复制代码

@RunWith(Parameterized.class)
public class LogicServiceTest {
    LogicService logserv ;
    int parm1 ;//定义入参
    int parm2 ;//定义入参
    int res;//定义入参
    
   public LogicServiceTest(int parm1,int parm2,int res){//定义构造函数
       this.parm1=parm1;
       this.parm2=parm2;
       this.res=res;
   }

复制代码

3 定义一个返回结果为collection类型的方法并写上@Parameters 

注意 Arrays.asList()里面NEW的Object的要与定义的参数一一对应

例如

复制代码

public class LogicServiceTest {
    LogicService logserv ;
    int parm1 ;//定义入参
    int parm2 ;//定义入参
    int res;//定义入参
    
   public LogicServiceTest(int parm1,int parm2,int res){//定义构造函数
       this.parm1=parm1;
       this.parm2=parm2;
       this.res=res;
   }
   
   @Parameters   
   public static Collection<Object[]> initParm(){
       return  Arrays.asList(new Object[][]{
          {1,1,2},{1,2,3},{1,3,4},{1,3,5}//{}里的参数一定要和构造函数一一对应
   });
   }

复制代码

4 编写测试方法，调用参数

    @Test
    public void testAdd() {
        assertEquals(res,logserv.add(parm1, parm2));
    }

5 测试类代码全景（准备执行）

复制代码

package com.logic.test;

import static org.junit.Assert.*;

import java.util.Arrays;
import java.util.Collection;

import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameters;

import com.logic.LogicService;

@RunWith(Parameterized.class)
public class LogicServiceTest {
    LogicService logserv;
    int parm1;// 定义入参
    int parm2;// 定义入参
    int res;// 定义入参

    public LogicServiceTest(int parm1, int parm2, int res) {// 定义构造函数
        this.parm1 = parm1;
        this.parm2 = parm2;
        this.res = res;
    }

    @Parameters
    public static Collection<Object[]> initParm() {
        return Arrays.asList(new Object[][] { { 1, 1, 2 }, { 1, 2, 3 },
                { 1, 3, 4 }, { 1, 3, 5 } // {}里的参数一定要和构造函数一一对应
                });
    }

    @Before
    public void setUp() throws Exception {
        logserv = new LogicService();
    }

    @Test
    public void testAdd() {
        assertEquals(res, logserv.add(parm1, parm2));
    }

    @Ignore
    public void testSub() {
    }
}

复制代码

6 执行结果

总结:使用了参数化后测试类的代码简化了不少，而且执行起来效果很不错

 

收尾

通过本文可以了解到:

1 Junit Myeclipse测试类的生成

2 JUnit 4 常用的几个annotation 介绍与使用 (@Before  @After @Test @Ignore @BeforeClass @AfterClass)

3 常用的断言介绍

4 特殊的处理 (限时测试，异常测试)

5 参数化配置 (@Parameters)

https://www.cnblogs.com/sunfan1988/p/3475450.html

夜路人
关注
专栏目录
MyEclipse中的junit测试
PsMuJIngHua的专栏
09-12 1282
1.在MyEclipse中自带了junit包 创建一个包，下面可以写测试类，右击新建的包，new---------JUnit Test Case，显示“New JUnit Test Case ”,在“Class Under test”中，选择要测试的类，   选择“finish”按钮，会显示如下窗体，因为MyEclipse中自带了Junit包，选择“OK”即可   查看项目
JUnit in java 真正的测试用例实战.doc
06-17
在配置JUnit环境时，通常是在Eclipse或MyEclipse这样的IDE中进行。首先，需要在项目的构建路径中添加JUnit的JAR库。然后，可以利用IDE的快捷方式创建JUnit测试用例。例如，在Eclipse中，右键选择待测试的类，新建...
在Myeclipse里使用Junit
weixin_33755554的博客
05-20 143
有关理财的帖子是转载的，这可是原创哦，希望对大家有帮助。^_^ 第一步：写一个简单的方法，作为测试的方法。 第二步 将JUnit加入到工程里面。 第三步，创建测试的class。 第四步。选中要测试的方法。 如果你的工程已经自动加载了Junit用的jar包，可跳过 5 6 这两步。 第五步 向工程中添加Junit jar包 第六步。选择Junit jar包第七...
Myeclipse中进行JUnit单元测试
weixin_34174132的博客
08-05 447
最近学习了在myeclipse中进行单元测试，写点东西总结总结。 JUnit单元测试： 测试对象为一个类中的方法。 juint不是javase中的部分，所以必须导入jar包，但是myeclipse自带了juint的jar包。 单元测试的方法命名规则为： public void 方法名（）{ } 首先，如下图所示，建立相应的project、pac...
Junit测试（转载）
The Dawn.
12-01 367
新建一个项目叫JUnit_Test，我们编写一个Calculator类，这是一个能够简单实现加减乘除、平方、开方的计算器类，然后对这些功能进行单元测试。这个类并不是很完美，我们故意保留了一些Bug用于演示，这些Bug在注释中都有说明。该类代码如下： [code="java"] package andycpp; public class Calculator { private stati...
在MyEclipse中使用Junit 的方法
phubing
12-07 960
在MyEclipse中使用Junit 的方法，这一部分先记 Test Case 的创建方法。 Test Case ：是指对一个用例进行测试，比如说测试一个接口，对于接口来说，一组输入值就是一个Test Case 。MyEclipse中创建Junit 的步骤如下： 1、选择一个存放测试类的package，右键–&gt;new–&gt;Other–&gt;Java–&gt;JUnit–&gt;JU...
Myeclipse中JUnit单元测试详解及其重要性
在单元测试中，目标是对代码中的最小可测试单元（如函数、方法或类）进行测试，这些单元在与其余代码隔离开的情况下运行。在面向对象编程语言如C++中，重点在于测试类的行为。对于Ada这样的语言，开发者可以选择在...
使用JUnit进行Java单元测试实战指南
这篇实验报告详细介绍了如何在Eclipse中使用JUnit进行单元测试，包括理解测试的基本概念、JUnit的使用方法以及其带来的好处。通过这样的实践，学生能够深入理解单元测试的重要性，并掌握实际操作技能。
JUnit框架详解：单元测试的关键方法与实践
5. **JUnit的优势：**JUnit的使用提高了开发效率，因为通过自动化测试，可以在代码修改后迅速发现潜在的错误，减少了回归测试的时间。同时，单元测试还有助于促进良好的编程习惯，即"红绿原则"（先写出失败的测试，...
JUnit单元测试实践与优势
对于测试团队而言，由于减少了回归测试中的bug，工作效率也会显著提升。而对于项目经理，完善的单元测试提供了项目进度和质量的有力保障。最后，对于后期的维护人员，充足的测试用例能让他们更快地理解和修改现有...
教会你如何使用junit，以及myeclipse+junit 使用
07-05
教会你如何使用junit，以及myeclipse+junit 使用
MyEclipse 添加junit包
zunguitiancheng的专栏
02-25 1599
http://blog.csdn.net/nemo2011/article/details/6615624 myEclipse自带了junit的包，具体如下 window - preferences- Java -Junit 即可。 或者选中某个工程 - Properties - Java bulid path - add library - junit
MyEclipse中Junit的简单配置
Java-Jinguo
10-22 682
MyEclipse中Junit的简单配置 2007-11-26 15:07 Eclipse IDE中集成了JUnit组件，无须另行下载和安装，但是，要使用Eclipse中提供的运行Junit单元测试用例和测试套件的图形用户界面，还要在Eclipse中进行一些设置。其中主要是就是类路径变量的设置。下面先看一下路径变量的具体设置步骤： （1）      在主菜单栏上选择【窗口-&gt;首选项...
在Eclipse中使用JUnit4进行单元测试（高级篇）
热门推荐
华丽的痘痘
10-10 7万+
通过前2篇文章，您一定对JUnit有了一个基本的了解，下面我们来探讨一下JUnit4中一些高级特性。一、     高级Fixture上一篇文章中我们介绍了两个Fixture标注，分别是@Before和@After，我们来看看他们是否适合完成如下功能：有一个类是负责对大文件（超过500兆）进行读写，他的每一个
在MyEclipse 2014 中使用JUnit-(二)
天高地阔的专栏
01-14 1018
当一个项目中存在较多case需要测试时，我们可以利用JUnit提供的Suite来测试。 步骤如下： 1.首先我们编写两个被测试的java文件，如下： package com.jc.demo1; public class Demo1 { public int add(int a,int b){ return a+b; } public int minus(int a,int b
JAVA之Myeclipse中Junit、静态导入、枚举和单例设计模式
rainmeterlinux的专栏
12-15 1322
这篇博客主要有以下知识点：Myeclipse中Junit的使用、静态导入、枚举、单例设计模式(饿汉式和懒汉式) 知识点一：Myeclipse中Junit的使用(有四个类Person.class、PersonTest.class、PersonTest1.class、PersonTest2.class)
myeclipse junit 单元测试学习
roach
12-11 730
 http://blog.csdn.net/shellycai2008/article/details/3379842 对静态方法测试连接 http://hi.baidu.com/ljmybfq/item/ab5e1c3f080ba40dcfb9fe3a junit 3.8 myeclipse结合使用实例
Junit在MyEclipse上怎么用？
weixin_34064653的博客
07-03 125
　　在项目中加入junit-x.x.jar包 　　在MyEclipse在package上右键 可以找到 JunitTestCase 　　这就是负责单元测试的类 　　只要在合适的包中 一般在对应待测试类的test包中 新建Junit Test Case 　　然后可以选择 对哪个类 的哪个方法进行测试 　　MyEclipse就会自动生成测试类框架 　　...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值