精华内容
下载资源
问答
  • Junit4

    千次阅读 2019-04-04 18:47:27
    junit4官方网站:https://junit.org/junit4/ junit5官方网站:https://junit.org/junit5/ W3Cschool:https://www.w3cschool.cn/junit/ 慕课:https://www.imooc.com/learn/356 依赖包:hamcrest-core.jar(设置...

    junit4官方网站: https://junit.org/junit4/

    junit5官方网站:https://junit.org/junit5/ 

    W3Cschool:https://www.w3cschool.cn/junit/ 

    慕课:https://www.imooc.com/learn/356

    依赖包:hamcrest-core.jar (设置规则的框架,可以有效的增强 junit 的测试能力)

    eclipse:https://blog.csdn.net/qq_40794973/article/details/83579049


    目录

    JUnit - 概述

    JUnit - 环境设置

    JUnit - API

    JUnit - 编写测试

    JUnit - 使用断言

    JUnit - 执行过程

    JUnit - 执行测试

    JUnit - 套件测试

    JUnit - 忽略测试

    JUnit - 时间测试

    JUnit - 异常测试

    JUnit - 参数化测试


    public class Calculate {
    	public int add(int a,int b) {
    		return a + b;
    	}
    	public int subtract(int a, int b) {
    		return a - b;
    	}
    	public int multiply(int a,int b) {
    		return a * b;
    	}
    	public int divide(int a ,int b) {
    		return a / b;
    	}
    }
    import static org.junit.Assert.assertEquals;
    import org.junit.Ignore;
    import org.junit.Test;
    public class AnotationTest {
    
        /*
         * @Test:将一个普通的方法修饰成为一个测试方法
         * 		@Test(expected=XX.class)
         * 		@Test(timeout=毫秒 )
         * @BeforeClass:它会在所有的方法运行前被执行,static修饰
         * @AfterClass:它会在所有的方法运行结束后被执行,static修饰
         * @Before:会在每一个测试方法被运行前执行一次
         * @After:会在每一个测试方法运行后被执行一次
         * @Ignore:所修饰的测试方法会被测试运行器忽略
         * @RunWith:可以更改测试运行器 org.junit.runner.Runner
         */
    
        /**
         * 下面这段代码预期会抛出一个算术异常,我们添加 expected=ArithmeticException.class
         * 将异常捕获了
         */
        @Test(expected=ArithmeticException.class)
        public void testDivide() {
            assertEquals(3, new Calculate().divide(6, 0));//除数为零
        }
    
        /**
         * timeout 通常用于对方法运行时间的限定
         */
        @Ignore("...") //"..." 中间可以加入一些说明信息,为什么没有执行  单独执行这个,这个方法是是会被执行的,执行所有会被忽略
        @Test(timeout=2000)
        public void testWhile() {
            while(true) {
                System.out.println("run forever...");
            }
        }
    
        @Test(timeout=3000)
        public void testReadFile(){
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    

    JUnit - 概述 (Junit4)

    所谓单元测试是测试应用程序的功能是否能够按需要正常运行,并且确保是在开发人员的水平上,单元测试生成图片。单元测试是一个对单一实体(类或方法)的测试。单元测试是每个软件公司提高产品质量、满足客户需求的重要环节。

    单元测试可以由两种方式完成

    人工测试自动测试
    手动执行测试用例并不借助任何工具的测试被称为人工测试。
    - 消耗时间并单调:由于测试用例是由人力资源执行,所以非常缓慢并乏味。
    - 人力资源上投资巨大:由于测试用例需要人工执行,所以在人工测试上需要更多的试验员。
    - 可信度较低:人工测试可信度较低是可能由于人工错误导致测试运行时不够精确。
    - 非程式化:编写复杂并可以获取隐藏的信息的测试的话,这样的程序无法编写。
    借助工具支持并且利用自动工具执行用例被称为自动测试。
    - 快速自动化运行测试用例时明显比人力资源快。 
    - 人力资源投资较少:测试用例由自动工具执行,所以在自动测试中需要较少的试验员。
    - 可信度更高:自动化测试每次运行时精确地执行相同的操作。
    - 程式化:试验员可以编写复杂的测试来显示隐藏信息。

    什么是 JUnit?

    JUnit 是一个 Java 编程语言的单元测试框架。JUnit 在测试驱动的开发方面有很重要的发展,是起源于 JUnit 的一个统称为 xUnit 的单元测试框架之一。

    JUnit 促进了“先测试后编码”的理念,强调建立测试数据的一段代码,可以先测试,然后再应用。这个方法就好比“测试一点,编码一点,测试一点,编码一点……”,增加了程序员的产量和程序的稳定性,可以减少程序员的压力和花费在排错上的时间。

    特点:

    • JUnit 是一个开放的资源框架,用于编写和运行测试。
    • 提供注释来识别测试方法。
    • 提供断言来测试预期结果。
    • 提供测试运行来运行测试。
    • JUnit 测试允许你编写代码更快,并能提高质量。
    • JUnit 优雅简洁。没那么复杂,花费时间较少。
    • JUnit 测试可以自动运行并且检查自身结果并提供即时反馈。所以也没有必要人工梳理测试结果的报告。
    • JUnit 测试可以被组织为测试套件,包含测试用例,甚至其他的测试套件。
    • JUnit 在一个条中显示进度。如果运行良好则是绿色;如果运行失败,则变成红色。

    什么是一个单元测试用例?

    单元测试用例是一部分代码,可以确保另一端代码(方法)按预期工作。为了迅速达到预期的结果,就需要测试框架。JUnit 是 java 编程语言理想的单元测试框架。

    一个正式的编写好的单元测试用例的特点是:已知输入和预期输出,即在测试执行前就已知。已知输入需要测试的先决条件,预期输出需要测试后置条件。

    每一项需求至少需要两个单元测试用例:一个正检验,一个负检验。如果一个需求有子需求,每一个子需求必须至少有正检验和负检验两个测试用例。


    JUnit - 环境设置

    gradle: 

    // https://mvnrepository.com/artifact/junit/junit
    compile group: 'junit', name: 'junit', version: '4.12'
    

    maven: 

    <!-- https://mvnrepository.com/artifact/junit/junit -->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
    

    注:Eclipse 自带了 junit 的。

    测试 JUnit 建立

    import org.junit.Test;
    import static org.junit.Assert.assertEquals;
    public class TestJunit {
        @Test
        public void testAdd() {
            String str= "Junit is working fine";
            assertEquals("Junit is working fine",str);
        }
    }
    import org.junit.runner.JUnitCore;
    import org.junit.runner.Result;
    import org.junit.runner.notification.Failure;
    public class TestRunner {
        public static void main(String[] args) {
            Result result = JUnitCore.runClasses(TestJunit.class);
            for (Failure failure : result.getFailures()) {
                System.out.println(failure.toString());
            }
            System.out.println(result.wasSuccessful());
        }
    }

     运行 TestRunner:

    true


    JUnit - API

    JUnit 中的重要的 API

    JUnit 中的最重要的程序包是 junit.framework 它包含了所有的核心类。一些重要的类列示如下:

    序号类的名称类的功能
    1Assertassert 方法的集合
    2TestCase一个定义了运行多重测试的固定装置
    3TestResultTestResult 集合了执行测试样例的所有结果
    4TestSuiteTestSuite 是测试的集合

     Assert 类

    下面介绍的是 org.junit.Assert 类:

    public class Assert extends java.lang.Object

    这个类提供了一系列的编写测试的有用的声明方法。只有失败的声明方法才会被记录。Assert 类的重要方法列式如下:

    序号方法和描述
    1void assertEquals(boolean expected, boolean actual) 
    检查两个变量或者等式是否平衡
    2void assertFalse(boolean condition) 
    检查条件是假的
    3void assertNotNull(Object object) 
    检查对象不是空的
    4void assertNull(Object object) 
    检查对象是空的
    5void assertTrue(boolean condition) 
    检查条件为真
    6void fail() 
    在没有报告的情况下使测试不通过
    import org.junit.Test;
    import static org.junit.Assert.*;
    public class TestJunit1 {
        @Test
        public void testAdd() {
            //test data
            int num= 5;
            String temp= null;
            String str= "Junit is working fine";
    
            //check for equality
            assertEquals("Junit is working fine", str);
    
            //check for false condition
            assertFalse(num > 6);
    
            //check for not null value
            assertNotNull(str);
        }
    }
    import org.junit.runner.JUnitCore;
    import org.junit.runner.Result;
    import org.junit.runner.notification.Failure;
    
    public class TestRunner1 {
        public static void main(String[] args) {
            Result result = JUnitCore.runClasses(TestJunit1.class);
            for (Failure failure : result.getFailures()) {
                System.out.println(failure.toString());
            }
            System.out.println(result.wasSuccessful());
        }
    }

     输出:

    true

     TestCase 类

    下面介绍的是 org.junit.TestCaset 类:

    public abstract class TestCase extends Assert implements Test

    测试样例定义了运行多重测试的固定格式。TestCase 类的一些重要方法列式如下:

    序号方法和描述
    1int countTestCases()
    为被run(TestResult result) 执行的测试案例计数
    2TestResult createResult()
    创建一个默认的 TestResult 对象
    3String getName()
    获取 TestCase 的名称
    4TestResult run()
    一个运行这个测试的方便的方法,收集由TestResult 对象产生的结果
    5void run(TestResult result)
    在 TestResult 中运行测试案例并收集结果
    6void setName(String name)
    设置 TestCase 的名称
    7void setUp()
    创建固定装置,例如,打开一个网络连接
    8void tearDown()
    拆除固定装置,例如,关闭一个网络连接
    9String toString()
    返回测试案例的一个字符串表示
    import junit.framework.TestCase;
    import org.junit.Before;
    import org.junit.Test;
    public class TestJunit2 extends TestCase  {
        protected double fValue1;
        protected double fValue2;
    
        @Before
        public void setUp() {
            fValue1= 2.0;
            fValue2= 3.0;
        }
    
        @Test
        public void testAdd() {
            //count the number of test cases
            System.out.println("No of Test Case = "+ this.countTestCases());
    
            //test getName
            String name= this.getName();
            System.out.println("Test Case Name = "+ name);
    
            //test setName
            this.setName("testNewAdd");
            String newName= this.getName();
            System.out.println("Updated Test Case Name = "+ newName);
        }
        //tearDown used to close the connection or clean up activities
        public void tearDown(  ) {
        }
    }
    import org.junit.runner.JUnitCore;
    import org.junit.runner.Result;
    import org.junit.runner.notification.Failure;
    
    public class TestRunner2 {
        public static void main(String[] args) {
            Result result = JUnitCore.runClasses(TestJunit2.class);
            for (Failure failure : result.getFailures()) {
                System.out.println(failure.toString());
            }
            System.out.println("------------------------");
            System.out.println(result.wasSuccessful());
        }
    }

     输出:

    No of Test Case = 1
    Test Case Name = testAdd
    Updated Test Case Name = testNewAdd
    ------------------------
    true

     TestResult 类

    下面定义的是 org.junit.TestResult 类:

    public class TestResult extends Object

    TestResult 类收集所有执行测试案例的结果。它是收集参数层面的一个实例。这个实验框架区分失败和错误。失败是可以预料的并且可以通过假设来检查。错误是不可预料的问题就像 ArrayIndexOutOfBoundsException。TestResult 类的一些重要方法列式如下:

    序号方法和描述
    1void addError(Test test, Throwable t)
    在错误列表中加入一个错误
    2void addFailure(Test test, AssertionFailedError t)
    在失败列表中加入一个失败
    3void endTest(Test test)
    显示测试被编译的这个结果
    4int errorCount()
    获取被检测出错误的数量
    5Enumeration errors()
    返回错误的详细信息
    6int failureCount()
    获取被检测出的失败的数量
    7void run(TestCase test) 运行 TestCase
    8int int runCount()
    获得运行测试的数量
    9void startTest(Test test)
    声明一个测试即将开始
    10void stop()
    标明测试必须停止
    import org.junit.Test;
    import junit.framework.AssertionFailedError;
    import junit.framework.TestResult;
    
    public class TestJunit3 extends TestResult {
        // add the error
        public synchronized void addError(Test test, Throwable t) {
            super.addError((junit.framework.Test) test, t);
        }
    
        // add the failure
        public synchronized void addFailure(Test test, AssertionFailedError t) {
            super.addFailure((junit.framework.Test) test, t);
        }
        @Test
        public void testAdd() {
            // add any test
        }
    
        // Marks that the test run should stop.
        public synchronized void stop() {
            //stop the test here
        }
    }
    
    import org.junit.runner.JUnitCore;
    import org.junit.runner.Result;
    import org.junit.runner.notification.Failure;
    
    public class TestRunner3 {
        public static void main(String[] args) {
            Result result = JUnitCore.runClasses(TestJunit3.class);
            for (Failure failure : result.getFailures()) {
                System.out.println(failure.toString());
            }
            System.out.println(result.wasSuccessful());
        }
    }

     输出:

    true

     TestSuite 类

    下面定义的是 org.junit.TestSuite 类:

    public class TestSuite extends Object implements Test

     TestSuite 类是测试的组成部分。它运行了很多的测试案例。TestSuite 类的一些重要方法列式如下:

    序号方法和描述
    1void addTest(Test test) 
    在套中加入测试。
    2void addTestSuite(Class<? extends TestCase> testClass)
    将已经给定的类中的测试加到套中。
    3int countTestCases()
    对这个测试即将运行的测试案例进行计数。
    4String getName()
    返回套的名称。
    5void run(TestResult result)
    在 TestResult 中运行测试并收集结果。
    6void setName(String name)
    设置套的名称。
    7Test testAt(int index)
    在给定的目录中返回测试。
    8int testCount()
    返回套中测试的数量。
    9static Test warning(String message)
    返回会失败的测试并且记录警告信息。
    import junit.framework.*;
    public class JunitTestSuite {
        public static void main(String[] a) {
            // add the test's in the suite
            TestSuite suite = new TestSuite(TestJunit1.class, TestJunit2.class, TestJunit3.class );
            TestResult result = new TestResult();
            suite.run(result);
            System.out.println("Number of test cases = " + result.runCount());
        }
    }

     输出:

    No of Test Case = 1
    Test Case Name = testAdd
    Updated Test Case Name = testNewAdd
    Number of test cases = 3


    JUnit - 编写测试

    在这里你会会看到一个应用POJO类,业务逻辑类和在测试运行器中运行的测试类的JUnit测试的例子。

    public class EmployeeDetails {
    
       private String name;
       private double monthlySalary;
       private int age;
    
       /**
       * @return the name
       */
       public String getName() {
          return name;
       }
       /**
       * @param name the name to set
       */
       public void setName(String name) {
          this.name = name;
       }
       /**
       * @return the monthlySalary
       */
       public double getMonthlySalary() {
          return monthlySalary;
       }
       /**
       * @param monthlySalary the monthlySalary to set
       */
       public void setMonthlySalary(double monthlySalary) {
          this.monthlySalary = monthlySalary;
       }
       /**
       * @return the age
       */
       public int getAge() {
          return age;
       }
       /**
       * @param age the age to set
       */
       public void setAge(int age) {
       this.age = age;
       }
    }

     EmployeeDetails类被用于

    • 取得或者设置雇员的姓名的值
    • 取得或者设置雇员的每月薪水的值
    • 取得或者设置雇员的年龄的值
    public class EmpBusinessLogic {
       // Calculate the yearly salary of employee
       public double calculateYearlySalary(EmployeeDetails employeeDetails){
          double yearlySalary=0;
          yearlySalary = employeeDetails.getMonthlySalary() * 12;
          return yearlySalary;
       }
    
       // Calculate the appraisal amount of employee
       public double calculateAppraisal(EmployeeDetails employeeDetails){
          double appraisal=0;
          if(employeeDetails.getMonthlySalary() < 10000){
             appraisal = 500;
          }else{
             appraisal = 1000;
          }
          return appraisal;
       }
    }

     EmpBusinessLogic类被用来计算

    • 雇员每年的薪水
    • 雇员的评估金额

     TestEmployeeDetails 被测试的测试案例类

    import org.junit.Test;
    import static org.junit.Assert.assertEquals;
    
    public class TestEmployeeDetails {
       EmpBusinessLogic empBusinessLogic =new EmpBusinessLogic();
       EmployeeDetails employee = new EmployeeDetails();
    
       //test to check appraisal
       @Test
       public void testCalculateAppriasal() {
          employee.setName("Rajeev");
          employee.setAge(25);
          employee.setMonthlySalary(8000);
          double appraisal= empBusinessLogic.calculateAppraisal(employee);
          assertEquals(500, appraisal, 0.0);
       }
    
       // test to check yearly salary
       @Test
       public void testCalculateYearlySalary() {
          employee.setName("Rajeev");
          employee.setAge(25);
          employee.setMonthlySalary(8000);
          double salary= empBusinessLogic.calculateYearlySalary(employee);
          assertEquals(96000, salary, 0.0);
       }
    }

     TestEmployeeDetails是用来测试EmpBusinessLogic类的方法的,它

    • 测试雇员的每年的薪水
    • 测试雇员的评估金额

     TestRunner 来执行测试案例类

    import org.junit.runner.JUnitCore;
    import org.junit.runner.Result;
    import org.junit.runner.notification.Failure;
    
    public class TestRunner {
       public static void main(String[] args) {
          Result result = JUnitCore.runClasses(TestEmployeeDetails.class);
          for (Failure failure : result.getFailures()) {
             System.out.println(failure.toString());
          }
          System.out.println(result.wasSuccessful());
       }
    } 

     


    JUnit - 使用断言

    断言

    所有的断言都包含在Assert类中

    public class Assert extends java.lang.Object

     这个类提供了很多有用的断言方法来编写测试用例。只有失败的断言才会被记录。断言类中的一些有用的方法列式如下:

    序号方法和描述
    1void assertEquals(boolean expected,boolean actual)
    检查两个变量或者等式是否平衡
    2void assertTrue(boolean expected,boolean actual)
    检查条件为真
    3void assertFalse(boolean condition)
    检查条件为假
    4void assertNotNull(Object object)
    检查对象不为空
    void assertNull(Object object)
    检查对象为空
    6void assertSame(boolean condition)
    assertSame()方法检查两个相关对象是否指向同一个对象
    7void assertNotSame(boolean condition)
    assertNotSame()方法检查两个相关对象是否不指向同一个对象
    8void assertArrayEquals(expectedArray,resultArray)
    assertArrayEquals()方法检查两个数组是否相等

     下面我们在例子中试验一下上面提到的各种方法。

    import org.junit.Test;
    import static org.junit.Assert.*;
    
    public class TestAssertions {
    
       @Test
       public void testAssertions() {
          //test data
          String str1 = new String ("abc");
          String str2 = new String ("abc");
          String str3 = null;
          String str4 = "abc";
          String str5 = "abc";
          int val1 = 5;
          int val2 = 6;
          String[] expectedArray = {"one", "two", "three"};
          String[] resultArray =  {"one", "two", "three"};
    
          //Check that two objects are equal
          assertEquals(str1, str2);
    
          //Check that a condition is true
          assertTrue (val1 < val2);
    
          //Check that a condition is false
          assertFalse(val1 > val2);
    
          //Check that an object isn't null
          assertNotNull(str1);
    
          //Check that an object is null
          assertNull(str3);
    
          //Check if two object references point to the same object
          assertSame(str4,str5);
    
          //Check if two object references not point to the same object
          assertNotSame(str1,str3);
    
          //Check whether two arrays are equal to each other.
          assertArrayEquals(expectedArray, resultArray);
       }
    }

     创建一个文件名为TestRunner.java的类来执行测试用例

    import org.junit.runner.JUnitCore;
    import org.junit.runner.Result;
    import org.junit.runner.notification.Failure;
    
    public class TestRunner2 {
       public static void main(String[] args) {
          Result result = JUnitCore.runClasses(TestAssertions.class);
          for (Failure failure : result.getFailures()) {
             System.out.println(failure.toString());
          }
          System.out.println(result.wasSuccessful());
       }
    } 

     


    JUnit - 执行过程

    注释

    注释就好像你可以在你的代码中添加并且在方法或者类中应用的元标签。JUnit 中的这些注释为我们提供了测试方法的相关信息,哪些方法将会在测试方法前后应用,哪些方法将会在所有方法前后应用,哪些方法将会在执行中被忽略。
    JUnit 中的注释的列表以及他们的含义:

    序号注释和描述
    1@Test
    这个注释说明依附在 JUnit 的 public void 方法可以作为一个测试案例。
    2@Before
    有些测试在运行前需要创造几个相似的对象。在 public void 方法加该注释是因为该方法需要在 test 方法前运行。
    3@After
    如果你将外部资源在 Before 方法中分配,那么你需要在测试运行后释放他们。在 public void 方法加该注释是因为该方法需要在 test 方法后运行。
    4@BeforeClass
    在 public void 方法加该注释是因为该方法需要在类中所有方法前运行。
    5@AfterClass
    它将会使方法在所有测试结束后执行。这个可以用来进行清理活动。
    6@Ignore
    这个注释是用来忽略有关不需要执行的测试的。

     

    import org.junit.After;
    import org.junit.AfterClass;
    import org.junit.Before;
    import org.junit.BeforeClass;
    import org.junit.Test;
    public class ExecutionProcedureJunit {
        //execute only once, in the starting
        @BeforeClass
        public static void beforeClass() {
            System.out.println("in before class");
        }
    
        //execute only once, in the end
        @AfterClass
        public static void afterClass() {
            System.out.println("in after class");
        }
    
        //execute for each test, before executing test
        @Before
        public void before() {
            System.out.println("in before");
        }
    
        //execute for each test, after executing test
        @After
        public void after() {
            System.out.println("in after");
        }
    
        //test case 1
        @Test
        public void testCase1() {
            System.out.println("in test case 1");
        }
    
        //test case 2
        @Test
        public void testCase2() {
            System.out.println("in test case 2");
        }
    }
    import org.junit.runner.JUnitCore;
    import org.junit.runner.Result;
    import org.junit.runner.notification.Failure;
    public class TestRunner {
        public static void main(String[] args) {
            Result result = JUnitCore.runClasses(ExecutionProcedureJunit.class);
            for (Failure failure : result.getFailures()) {
                System.out.println(failure.toString());
            }
            System.out.println(result.wasSuccessful());
        }
    }

    输出:

    in before class
    in before
    in test case 1
    in after
    in before
    in test case 2
    in after
    in after class
    true

    import org.junit.After;
    import org.junit.AfterClass;
    import org.junit.Before;
    import org.junit.BeforeClass;
    import org.junit.Test;
    public class JunitFlowTest {
        /*
         * 1.@BeforeClass修饰的方法会在所有方法被调用前被执行,而且该方法是静态的,所以当测试类被加载后接着就会运行它,而且在内存中它只会存在一份实例,它比较适合加载配置文件。
         * 2.@AfterClass所修饰的方法通常用来对资源的清理,如关闭数据库的连接
         * 3.@Before和@After会在每个测试方法的前后各执行一次。
         *
         */
        @BeforeClass
        public static void setUpBeforeClass() {
            System.out.println("this is BeforeClass...");
        }
    
        @AfterClass
        public static void tearDownAfterClass() {
            System.out.println("this is AfterClass...");
        }
    
        @Before
        public void setUp() {
            System.out.println("this is Before...");
        }
    
        @After
        public void tearDown() {
            System.out.println("this is After...");
        }
    
        @Test
        public void test1() {
            System.out.println("this is test1...");
        }
    
        @Test
        public void test2(){
            System.out.println("this is test2...");
        }
    
    }
    

    输出:

    this is BeforeClass...
    this is Before...
    this is test1...
    this is After...

    this is Before...
    this is test2...
    this is After...

    this is AfterClass...

    观察以上的输出,这是 JUnite 执行过程:

    • beforeClass() 方法首先执行,并且只执行一次。
    • afterClass() 方法最后执行,并且只执行一次。
    • before() 方法针对每一个测试用例执行,但是是在执行测试用例之前。
    • after() 方法针对每一个测试用例执行,但是是在执行测试用例之后。
    • 在 before() 方法和 after() 方法之间,执行每一个测试用例。

    JUnit - 执行测试

    测试用例JUnitCore类来执行的.JUnitCore是运行测试的外观类。它支持运行JUnit 4测试,JUnit 3.8.x测试,或者他们的混合。要从命令行运行测试,可以运行java org.junit。 runner.JUnitCore。对于只有一次的测试运行,可以使用静态方法runClasses(Class [])。

    下面是org.junit.runner.JUnitCore类的声明:

    public class JUnitCore extends java.lang.Object
    /*
    * This class prints the given message on console.
    */
    public class MessageUtil {
    
       private String message;
    
       //Constructor
       //@param message to be printed
       public MessageUtil(String message){
          this.message = message;
       }
    
       // prints the message
       public String printMessage(){
          System.out.println(message);
          return message;
       }   
    }  

     创建测试用例类

    • 创建一个java测试类叫做TestJunit.java。
    • 在类中加入一个测试方法testPrintMessage()。
    • 在方法testPrintMessage()中加入注释@Test。
    • 实现测试条件并且用Junit的assertEquals API检查测试条件。
    import org.junit.Test;
    import static org.junit.Assert.assertEquals;
    public class TestJunit {
    
       String message = "Hello World";  
       MessageUtil messageUtil = new MessageUtil(message);
    
       @Test
       public void testPrintMessage() {
          assertEquals(message,messageUtil.printMessage());
       }
    }

    创建TestRunner类

    创建一个java类文件命名为TestRunner.java来执行测试用例,导出JUnitCore类并且使用runClasses()方法,将测试类名称作为参数。

    import org.junit.runner.JUnitCore;
    import org.junit.runner.Result;
    import org.junit.runner.notification.Failure;
    
    public class TestRunner {
       public static void main(String[] args) {
          Result result = JUnitCore.runClasses(TestJunit.class);
          for (Failure failure : result.getFailures()) {
             System.out.println(failure.toString());
          }
          System.out.println(result.wasSuccessful());
       }
    }  

     


    JUnit - 套件测试(批量运行测试类的方法)

    测试套件

    测试套件意味着捆绑几个单元测试用例并且一起执行他们。在JUnit中,@ RunWith@Suite注释用来运行套件测试。这个教程将向您展示一个例子,其中含有两个测试样例TestJunit1&TestJunit2类,我们将使用测试套件一起运行他们。

    随着项目规模的增大,测试类也会越来越多,这个时候我们不可能一个一个的运行测试类,这个时候我们就可以把测试类集合到一个测试套件中,运行测试套件即可。测试有个特点套件,这个类是个空类。 

    /*
    * This class prints the given message on console.
    */
    public class MessageUtil {
    
       private String message;
    
       //Constructor
       //@param message to be printed
       public MessageUtil(String message){
          this.message = message; 
       }
    
       // prints the message
       public String printMessage(){
          System.out.println(message);
          return message;
       }   
    
       // add "Hi!" to the message
       public String salutationMessage(){
          message = "Hi!" + message;
          System.out.println(message);
          return message;
       }   
    }  
    import org.junit.Test;
    import org.junit.Ignore;
    import static org.junit.Assert.assertEquals;
    
    public class TestJunit1 {
    
       String message = "Robert";   
       MessageUtil messageUtil = new MessageUtil(message);
    
       @Test
       public void testPrintMessage() { 
          System.out.println("Inside testPrintMessage()");    
          assertEquals(message, messageUtil.printMessage());     
       }
    }
    import org.junit.Test;
    import org.junit.Ignore;
    import static org.junit.Assert.assertEquals;
    
    public class TestJunit2 {
    
       String message = "Robert";   
       MessageUtil messageUtil = new MessageUtil(message);
    
       @Test
       public void testSalutationMessage() {
          System.out.println("Inside testSalutationMessage()");
          message = "Hi!" + "Robert";
          assertEquals(message,messageUtil.salutationMessage());
       }
    }

     使用测试套件类

    • 创建一个java类。
    • 在类中附上@RunWith(Suite.class)注释。
    • 使用@ Suite.SuiteClasses注释给JUnit测试类加上引用。
    import org.junit.runner.RunWith;
    import org.junit.runners.Suite;
    @RunWith(Suite.class)
    @Suite.SuiteClasses({
       TestJunit1.class,
       TestJunit2.class
    })
    public class JunitTestSuite {   
    }  

    创建Test Runner类

    创建一个java类文件叫做TestRunner.java来执行测试用例。

    import org.junit.runner.JUnitCore;
    import org.junit.runner.Result;
    import org.junit.runner.notification.Failure;
    
    public class TestRunner {
       public static void main(String[] args) {
          Result result = JUnitCore.runClasses(JunitTestSuite.class);
          for (Failure failure : result.getFailures()) {
             System.out.println(failure.toString());
          }
          System.out.println(result.wasSuccessful());
       }
    }  

     输出:

    Inside testPrintMessage()
    Robert
    Inside testSalutationMessage()
    Hi Robert
    true

    案例二

    三个测试类: 

    import org.junit.Test;
    public class TaskTest1 {
    	@Test
    	public void test() {
    		System.out.println("this is TaskTest1...");
    	}
    }
    import org.junit.Test;
    public class TaskTest2 {
    	@Test
    	public void test() {
    		System.out.println("this is TaskTest2...");
    	}
    }
    import org.junit.Test;
    public class TaskTest3 {
    	@Test
    	public void test() {
    		System.out.println("this is TaskTest3...");
    	}
    }

     测试套件:

    import org.junit.runner.RunWith;
    import org.junit.runners.Suite;
    @RunWith(Suite.class)
    @Suite.SuiteClasses({TaskTest1.class,TaskTest2.class,TaskTest3.class})
    public class SuiteTest {
    	/*
    	 * 1.测试套件就是组织测试类一起运行的
    	 * 写一个作为测试套件的入口类,这个类里不包含其他的方法
    	 * 更改测试运行器Suite.class
    	 * 将要测试的类作为数组传入到Suite.SuiteClasses({})
    	 */
    }

    输出:

    this is TaskTest1...
    this is TaskTest2...
    this is TaskTest3... 


    JUnit - 忽略测试

    有时可能会发生我们的代码还没有准备好的情况,这时测试用例去测试这个方法或代码的时候会造成失败。@Ignore注释会在这种情况时帮助我们。

    • 一个含有@Ignore注释的测试方法将不会被执行。
    • 如果一个测试类有@Ignore注释,则它的测试方法将不会执行。

    现在我们用例子来学习@Ignore。

    创建一个类

    /*
    * This class prints the given message on console.
    */
    public class MessageUtil {
    
       private String message;
    
       //Constructor
       //@param message to be printed
       public MessageUtil(String message){
          this.message = message; 
       }
    
       // prints the message
       public String printMessage(){
          System.out.println(message);
          return message;
       }   
    
       // add "Hi!" to the message
       public String salutationMessage(){
          message = "Hi!" + message;
          System.out.println(message);
          return message;
       }   
    } 

     创建测试用例类

    • 创建java测试类命名为TestJunit.java。
    • 在类中加入测试方法testPrintMessage()和testSalutationMessage()。
    • 在方法testPrintMessage()中加入@Ignore注释。
    import org.junit.Test;
    import org.junit.Ignore;
    import static org.junit.Assert.assertEquals;
    
    public class TestJunit {
    
       String message = "Robert";   
       MessageUtil messageUtil = new MessageUtil(message);
    
       @Ignore
       @Test
       public void testPrintMessage() {
          System.out.println("Inside testPrintMessage()");
          message = "Robert";
          assertEquals(message,messageUtil.printMessage());
       }
    
       @Test
       public void testSalutationMessage() {
          System.out.println("Inside testSalutationMessage()");
          message = "Hi!" + "Robert";
          assertEquals(message,messageUtil.salutationMessage());
       }
    }

     创建Test Runner类

    创建一个java类文件叫做TestRunner.java来执行测试用例。

    import org.junit.runner.JUnitCore;
    import org.junit.runner.Result;
    import org.junit.runner.notification.Failure;
    
    public class TestRunner {
       public static void main(String[] args) {
          Result result = JUnitCore.runClasses(TestJunit.class);
          for (Failure failure : result.getFailures()) {
             System.out.println(failure.toString());
          }
          System.out.println(result.wasSuccessful());
       }
    }  

    现在运行Test Runner类,即不会运行在Test Case类中定义的testPrintMessage()测试用例。 

    验证输出.testPrintMessage()测试用例并没有被测试。

     输出:

    Inside testSalutationMessage()
    Hi!Robert
    true 

     现在更新TestJunit在类级别上使用@Ignore来忽略所有的测试用例

    import org.junit.Test;
    import org.junit.Ignore;
    import static org.junit.Assert.assertEquals;
    
    @Ignore
    public class TestJunit {
    
       String message = "Robert";   
       MessageUtil messageUtil = new MessageUtil(message);
    
       @Test
       public void testPrintMessage() {
          System.out.println("Inside testPrintMessage()");
          message = "Robert";
          assertEquals(message,messageUtil.printMessage());
       }
    
       @Test
       public void testSalutationMessage() {
          System.out.println("Inside testSalutationMessage()");
          message = "Hi!" + "Robert";
          assertEquals(message,messageUtil.salutationMessage());
       }
    }

    保持你的Test Runner不被改变,如下:

    import org.junit.runner.JUnitCore;
    import org.junit.runner.Result;
    import org.junit.runner.notification.Failure;
    
    public class TestRunner {
       public static void main(String[] args) {
          Result result = JUnitCore.runClasses(TestJunit.class);
          for (Failure failure : result.getFailures()) {
             System.out.println(failure.toString());
          }
          System.out.println(result.wasSuccessful());
       }
    }

     现在运行Test Runner即不会运行在Test Case类中定义的任何一个测试样例。

    验证输出。没有测试用例被测试。

    输出:

    true


    JUnit - 时间测试

     Junit的提供了一个暂停的方便选项。如果一个测试用例比起指定的毫秒数花费了更多的时间,那么Junit的将自动将它标记为失败。超时参数和@Test注释一起使用。现在让我们看看活动中的@test(超时)。

    创建一个类

    • 创建MessageUtil.java的java类来测试。
    • 在printMessage()方法内添加一个无限而循环。
    /*
    * This class prints the given message on console.
    */
    public class MessageUtil {
    
       private String message;
    
       //Constructor
       //@param message to be printed
       public MessageUtil(String message){
          this.message = message; 
       }
    
       // prints the message
       public void printMessage(){
          System.out.println(message);
          while(true);
       }   
    
       // add "Hi!" to the message
       public String salutationMessage(){
          message = "Hi!" + message;
          System.out.println(message);
          return message;
       }   
    } 

     创建测试用例类

    • 创建一个叫做TestJunit.java的java测试类。
    • 给testPrintMessage()测试用例添加1000的暂停时间。

    创建TestJunit类。

    import org.junit.Test;
    import org.junit.Ignore;
    import static org.junit.Assert.assertEquals;
    
    public class TestJunit {
    
       String message = "Robert";   
       MessageUtil messageUtil = new MessageUtil(message);
    
       @Test(timeout=1000)
       public void testPrintMessage() { 
          System.out.println("Inside testPrintMessage()");     
          messageUtil.printMessage();     
       }
    
       @Test
       public void testSalutationMessage() {
          System.out.println("Inside testSalutationMessage()");
          message = "Hi!" + "Robert";
          assertEquals(message,messageUtil.salutationMessage());
       }
    }

     创建Test Runner类

    创建一个文件名为TestRunne的java类来执行测试样例。

    import org.junit.runner.JUnitCore;
    import org.junit.runner.Result;
    import org.junit.runner.notification.Failure;
    
    public class TestRunner {
       public static void main(String[] args) {
          Result result = JUnitCore.runClasses(TestJunit.class);
          for (Failure failure : result.getFailures()) {
             System.out.println(failure.toString());
          }
          System.out.println(result.wasSuccessful());
       }
    } 

     现在运行Test Runner,它将运行由提供的测试用例类中所定义的测试用例。

    验证输出.testPrintMessage()测试用例将标记单元测试失败。

    输出:

    Inside testPrintMessage()
    Robert
    Inside testSalutationMessage()
    Hi!Robert
    testPrintMessage(TestJunit): test timed out after 1000 milliseconds
    false

     


    JUnit - 异常测试

    Junit用代码处理提供了一个追踪异常的选项。你可以测试代码是否它抛出了想要得到的异常。预期参数和@Test注释一起使用。现在让我们看看活动中的@Test(预期)

    创建一个类

    /*
    * This class prints the given message on console.
    */
    public class MessageUtil {
    
       private String message;
    
       //Constructor
       //@param message to be printed
       public MessageUtil(String message){
          this.message = message; 
       }
    
       // prints the message
       public void printMessage(){
          System.out.println(message);
          int a =0;
          int b = 1/a;
       }   
    
       // add "Hi!" to the message
       public String salutationMessage(){
          message = "Hi!" + message;
          System.out.println(message);
          return message;
       }   
    }  

     创建测试用例类

    • 创建一个叫做TestJunit.java的java测试类。
    • 给testPrintMessage()测试用例添加需要的异常ArithmeticException。

    创建一个文件名为TestJunit.java的java类

    import org.junit.Test;
    import org.junit.Ignore;
    import static org.junit.Assert.assertEquals;
    
    public class TestJunit {
    
       String message = "Robert";   
       MessageUtil messageUtil = new MessageUtil(message);
    
       @Test(expected = ArithmeticException.class)
       public void testPrintMessage() { 
          System.out.println("Inside testPrintMessage()");     
          messageUtil.printMessage();     
       }
    
       @Test
       public void testSalutationMessage() {
          System.out.println("Inside testSalutationMessage()");
          message = "Hi!" + "Robert";
          assertEquals(message,messageUtil.salutationMessage());
       }
    }

     创建TestRunner类

    创建一个文件名为TestJunit.java的java类来执行测试用例。

    import org.junit.runner.JUnitCore;
    import org.junit.runner.Result;
    import org.junit.runner.notification.Failure;
    
    public class TestRunner {
       public static void main(String[] args) {
          Result result = JUnitCore.runClasses(TestJunit.class);
          for (Failure failure : result.getFailures()) {
             System.out.println(failure.toString());
          }
          System.out.println(result.wasSuccessful());
       }
    }

     

    现在运行Test Runner,它将运行由提供的测试用例类中所定义的测试用例。

     

    验证输出.testPrintMessage()测试用例将通过。

    输出:

    Inside testPrintMessage()
    Robert
    Inside testSalutationMessage()
    Hi!Robert
    true

     


    JUnit - 参数化测试

    Junit 4引入了一个新的功能参数化测试。参数化测试允许开发人员使用不同的值反复运行同一个测试。你将遵循5个步骤来创建参数化测试

    • 用@RunWith(Parameterized.class)来注释测试类。
    • 创建一个由@Parameters注释的公共的静态方法,它返回一个对象的集合(数组)来作为测试数据集合。
    • 创建一个公共的构造函数,它接受和一行测试数据相等同的东西。
    • 为每一列测试数据创建一个实例变量。
    • 用实例变量作为测试数据的来源来创建你的测试用例。

    一旦每一行数据出现测试用例将被调用。让我们看看活动中的参数化测试。

    创建一个类

    创建一个叫做PrimeNumberChecker.java的java类来测试。

    public class PrimeNumberChecker {
       public Boolean validate(final Integer primeNumber) {
          for (int i = 2; i < (primeNumber / 2); i++) {
             if (primeNumber % i == 0) {
                return false;
             }
          }
          return true;
       }
    }

     创建参数化测试用例类

    创建一个叫做PrimeNumberCheckerTest.java的java类。

    import java.util.Arrays;
    import java.util.Collection;
    
    import org.junit.Test;
    import org.junit.Before;
    import org.junit.runners.Parameterized;
    import org.junit.runners.Parameterized.Parameters;
    import org.junit.runner.RunWith;
    import static org.junit.Assert.assertEquals;
    
    @RunWith(Parameterized.class)
    public class PrimeNumberCheckerTest {
       private Integer inputNumber;
       private Boolean expectedResult;
       private PrimeNumberChecker primeNumberChecker;
    
       @Before
       public void initialize() {
          primeNumberChecker = new PrimeNumberChecker();
       }
    
       // Each parameter should be placed as an argument here
       // Every time runner triggers, it will pass the arguments
       // from parameters we defined in primeNumbers() method
       public PrimeNumberCheckerTest(Integer inputNumber, 
          Boolean expectedResult) {
          this.inputNumber = inputNumber;
          this.expectedResult = expectedResult;
       }
    
       @Parameterized.Parameters
       public static Collection primeNumbers() {
          return Arrays.asList(new Object[][] {
             { 2, true },
             { 6, false },
             { 19, true },
             { 22, false },
             { 23, true }
          });
       }
    
       // This test will run 4 times since we have 5 parameters defined
       @Test
       public void testPrimeNumberChecker() {
          System.out.println("Parameterized Number is : " + inputNumber);
          assertEquals(expectedResult, 
          primeNumberChecker.validate(inputNumber));
       }
    }

     创建TestRunner类

    创建一个文件名为TestRunner.java的java类来执行测试用例

    import org.junit.runner.JUnitCore;
    import org.junit.runner.Result;
    import org.junit.runner.notification.Failure;
    
    public class TestRunner {
       public static void main(String[] args) {
          Result result = JUnitCore.runClasses(PrimeNumberCheckerTest.class);
          for (Failure failure : result.getFailures()) {
             System.out.println(failure.toString());
          }
          System.out.println(result.wasSuccessful());
       }
    }

    现在运行TestRunner,它将运行由提供的测试用例类中所定义的测试用例。 

    输出:

    Parameterized Number is : 2
    Parameterized Number is : 6
    Parameterized Number is : 19
    Parameterized Number is : 22
    Parameterized Number is : 23
    true

    案例二

    public class Calculate {
    	public int add(int a,int b) {
    		return a + b;
    	}
    	public int subtract(int a, int b) {
    		return a - b;
    	}
    	public int multiply(int a,int b) {
    		return a * b;
    	}
    	public int divide(int a ,int b) {
    		return a / b;
    	}
    }
    import static org.junit.Assert.*;
    import java.util.Arrays;
    import java.util.Collection;
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.junit.runners.Parameterized;
    import org.junit.runners.Parameterized.Parameters;
    
    @RunWith(Parameterized.class)
    public class ParameterTest {
    	/*
    	 * 1.更改默认的测试运行器为RunWith(Parameterized.class)
    	 * 2.声明变量来存放预期值 和结果值
    	 * 3.声明一个返回值 为Collection的公共静态方法,并使用@Parameters进行修饰
    	 * 4.为测试类声明一个带有参数的公共构造函数,并在其中为之声明变量赋值
    	 */
    	int expected =0;
    	int input1 = 0;
    	int input2 = 0;
    	
    	@Parameters
    	public static Collection<Object[]> t() {
    		return Arrays.asList(new Object[][]{
    				{3,1,2},
    				{4,2,2}
    		}) ;
    	}
    	
    	public ParameterTest(int expected,int input1,int input2) {
    		this.expected = expected;
    		this.input1 = input1;
    		this.input2 = input2;
    	}
    	
    	@Test
    	public void testAdd() {
    		assertEquals(expected, new Calculate().add(input1, input2));
    	}
    
    }
    

     

     


     总结:


    • 1.测试方法上必须使用@Test进行修饰
    • 2.测试方法必须使用public void 进行修饰,不能带任何的参数
    • 3.新建一个源代码目录来存放我们的测试代码
    • 4.测试类的包应该和被测试类保持一致
    • 5.测试单元中的每个方法必须可以独立测试,测试方法间不能有任何的依赖
    • 6.测试类使用Test作为类名的后缀(不是必须)
    • 7.测试方法使用test作为方法名的前缀(不是必须) 

    测试失败的两种情况:  

    • 1.Failure一般由单元测试使用的断言方法判断失败所引起的,这经表示 测试点发现了问题 ,就是说程序输出的结果和我们预期的不一样。
    • 2.error是由代码异常引起的,它可以产生于测试代码本身的错误,也可以是被测试代码中的一个隐藏的bug
    • 3.测试用例不是用来证明你是对的,而是用来证明你没有错。 
    import static org.junit.Assert.*;
    import org.junit.Test;
    public class ErrorAndFailureTest {
    	/*
    	 * 1.Failure一般由单元测试使用的断言方法判断失败所引起的,这经表示 测试点发现了问题
    	 * ,就是说程序输出的结果和我们预期的不一样。
    	 * 2.error是由代码异常引起的,它可以产生于测试代码本身的错误,也可以是被测试代码中的
    	 * 一个隐藏的bug
    	 * 3.测试用例不是用来证明你是对的,而是用来证明你没有错。
    	 */
    	@Test
    	public void testAdd() {
    		assertEquals(5, new Calculate().add(3,3));
    	}
    
    	@Test
    	public void testDivide() {
    		assertEquals(3, new Calculate().divide(6, 0));
    	}
    }
    

    • 1.@BeforeClass修饰的方法会在所有方法被调用前被执行,而且该方法是静态的,所以当测试类被加载后接着就会运行它,而且在内存中它只会存在一份实例,它比较适合加载配置文件。
    • 2.@AfterClass所修饰的方法通常用来对资源的清理,如关闭数据库的连接
    • 3.@Before和@After会在每个测试方法的前后各执行一次。
    展开全文
  • JUnit4
  • JUnit4

    千次阅读 2008-04-09 14:06:00
    JUnit 4是三年以来最具里程碑意义的一次发布。它的新特性主要是针对JAVA5中的标记(annotation)来简化测试,而不是利用子类、反射或命名机制。JUnit, 由Kent Beck?和 Erich Gamma开发,几乎是JAVA开发最重要的第三...
    JUnit 是JAVA语言事实上的标准测试库。JUnit 4是三年以来最具里程碑意义的一次发布。它的新特性主要是针对JAVA5中的标记(annotation)来简化测试,而不是利用子类、反射或命名机制。
    
    JUnit, 由Kent Beck?和 Erich Gamma开发,几乎是JAVA开发最重要的第三方工具。正如Martin Fowler 所说,“在软件开发领域,从来就没有如此少的代码起到了如此重要的作用“。由于JUnit,JAVA代码变得更健壮,更可靠,BUG也比以前更少。由于JUnit (由Smalltalk's的SUnit得来) 的出现,随后产生了许多xUnit的测试工具,如nUnit (.NET), pyUnit (Python), CppUnit (C++), dUnit (Delphi) 和其它不同平台及语言的测试相关的工具。
    虽然JUnit也只是一个工具,但其产生的思想和技术却较其架构更意义重大。单元测试,测试先行的编程方式,测试驱动的开发方式,并非必须由JUNIT实现,也不一定要用SWing实现GUI界面。JUNIT最近的一次更新是在三年前,但它比其它大多数有BUG的框架都要健壮,更重要的是,JAVA一直在改进。现在JAVA支持泛型,枚举,可变长度参数,以及标记语言(开创了开发可重用框架的新局面)。
    JUnit's的停滞不前使得那些想要变革的开发人员换其它测试工具.挑战者有Bill Venners的Artima SuiteRunner和Cedric Beust的TestNG.这些工具库虽然有值得推荐的功能,但没有任何一款的地位能与JUNIT相比,没有任何一款工具被其它业界产品如Ant, Maven, Eclipse广泛支持.因此Beck 和Gamma双开始利用JAVA5的新特性来开发新版的JUNIT,目的是利用JAVA5中的标记特性使得单元测试开发更容易。Beck说:“JUNIT4的主要目的是通过简化JUNIT的使用鼓励更多的开发人员写更多的测试”。虽然会与以前的版本兼容,但JUNIT4与从JUNIT1.0就开始的版本相比会有一个非常大的变化. 
       
    展开全文
  • IDEA中使用JUnit4(单元测试框架)超详细!

    万次阅读 多人点赞 2019-08-20 17:25:23
    IDEA中使用JUnit4教程 超详细!(单元测试框架) 自动化测试的必经之路--Selenium

    IDEA中使用JUnit4教程 超详细!(单元测试框架)

    导语:自动化测试的必经之路–Selenium

    作者变优秀的小白

    GithubYX-XiaoBai

    QQ交流群(new): 811792998

    爱好Americano More Ice !

    话不多说,实战为主!

    注:如中途遇到不懂的地方,直接评论留言看到会马上答疑!

    首先我们要认识什么是JUnit

    JUnit单元测试框架由Erich Gamma和Kent Beck编写的一个回归测试框架(Regresion Testing Framework),主要用于Java语言程序的单元测试,目前使用的主流版本是JUnit以上版本。
    此测试框架可用于执行WebDriver的自动化测试框架,话不多说,实战为主。

    1.安装IDEA,配置好IDEA的环境(关于IDEA的配置就不在此说明了,度娘多详细的教程都有)
    2.打开IDEA,先新建一个Java项目,点击 文件File-新建New-项目Project

    3.然后下一步,下一步,我这里项目名使用 Junit4Proj,点击完成
    在这里插入图片描述
    4.完成项目的创建后,点击 文件File-设置Settings-Plugins 在搜索栏搜索 JUnit,此时出现了几个Plugins,选择 JUnit,有两种方法安装插件(我都框起来了)。Install JetBrains plugin…Browser repositories两种方法,前者直接点击下载就好,如图
    在这里插入图片描述
    也可用后者方法,相对麻烦了一点(第三种方法更麻烦就不列举了),如图
    在这里插入图片描述
    在这里插入图片描述
    5.当你下载好Junit4 插件后,打开 文件File-设置Settings,如图注明修改配置
    在这里插入图片描述
    JUnit4 模块里找到此代码 将test去掉
    在这里插入图片描述
    6.以下是我编写的被测试类Calculator,以它为例。操作步骤为:IDEA新建一个java工程–自定义命名新建package–此package下新建Calculator类
    在这里插入图片描述
    代码如下

    public class Calculator {
        public int result=0;
        public int add(int operand1,int operand2){
            result=operand1+operand2;   //将两个传入参数进行相加操作
            return result;
        }
        public  int subtract(int operand1,int operand2){
            result=operand1-operand2;   //将两个传入参数进行相减操作
            return  result;
        }
        public int multipe(int operand1,int operand2){
            result=operand1*operand2;   //将两个传入参数进行相乘操作
            for(;;){                    //死循环
            }
        }
        public int divide(int operand1,int operand2){
            result=operand1/0;      //除0操作
            return result;
        }
        public int getResult(){
            return this.result;     //返回计算结果
        }
    
    }
    
    

    7.创建Junit4的测试代码,有两种方法(超级简单方便),第一种直接点击被测试类Calculator 使用 Ctrl+Shift+T
    在这里插入图片描述
    第二种方法 鼠标右键点击类名 使用 goto-Test(本人使用IDEA下错成汉化版表示难受)即可实现
    在这里插入图片描述
    8.创建测试,根据自身需要来勾选
    在这里插入图片描述
    我把测试类代码直接给出来,可根据需要自行修改

    import org.junit.*;
    
    import static org.junit.Assert.*;
    
    public class CalculatorTest {
    
        private static Calculator cal=new Calculator();
    
        @BeforeClass
        public static void setUpBeforeClass() throws Exception{
            System.out.println("@BeforeClass");
        }
        @AfterClass
        public static void tearDownAfterClass() throws Exception{
            System.out.println("@AfterClass");
        }
    
        @Before
        public void setUp() throws Exception {
            System.out.println("测试开始");
        }
    
        @After
        public void tearDown() throws Exception {
            System.out.println("测试结束");
        }
    
        @Test
        public void testAdd() {
            cal.add(2,2);
            assertEquals(4,cal.getResult());
            //fail("Not yet implemented");
        }
    
        @Test
        public void testSubtract() {
            cal.subtract(4,2);
            assertEquals(2,cal.getResult());
            //fail("Not yet implemented");
        }
    
        @Ignore
        public void testMultiply() {
            fail("Not yet implemented");
        }
    
        @Test(timeout = 2000)
        public void testDivide() {
            for(;;);
        }
    
        @Test(expected = ArithmeticException.class)
        public void testDivideByZero(){
            cal.divide(4,0);
        }
    
    
    }
    

    9.创建完成,有可能会报错,如图所描述的可能会报错
    在这里插入图片描述
    解决方法:找到项目的 pom.xml文件,使用maven直接导入项目
    在这里插入图片描述
    以下是本测试类需要用到的dependency,可自行复制

        <dependencies>
            <!-- https://mvnrepository.com/artifact/org.seleniumhq.selenium/selenium-java -->
            <dependency>
                <groupId>org.seleniumhq.selenium</groupId>
                <artifactId>selenium-java</artifactId>
                <version>3.14.0</version>
            </dependency>
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.12</version>
                <scope>test</scope>
            </dependency>
            <dependency>
                <groupId>org.jboss.shrinkwrap</groupId>
                <artifactId>shrinkwrap-api</artifactId>
                <version>1.2.6</version>
            </dependency>
            <dependency>
                <groupId>org.jboss.arquillian.junit</groupId>
                <artifactId>arquillian-junit-container</artifactId>
                <version>1.4.1.Final</version>
                <scope>test</scope>
            </dependency>
    
        </dependencies>
    

    10.所有工作已经做完,此时点击运行就可以啦!运行结果如下:
    在这里插入图片描述

    此时一个简单的Junit注解使用就算成功了!

    最后附上一些使用到的概念:
    一个测试类中只能声明此注解一次,此注解对应的方法只能被执行一次
    @BeforeClass 使用此注解的方法在测试类被调用之前执行
    @AfterClass 使用此注解的方法在测试类被调用结束退出之前执行
    一个类中有多少个@Test注解方法,以下对应注解方法就被调用多少次
    @Before 在每个@Test调用之前执行
    @After 在每个@Test调用之后执行
    @Test 使用此注解的方法为一个单元测试用例,一个测试类中可多次声明,每个注解为@Test只执行一次
    @Ignore 暂不执行的测试用例,会被JUnit4忽略执行

    总结: 大家如果有什么疑问或者建议的地方,可直接留言评论!本人会一一回复!!

    展开全文
  • junit4-example:看junit4源码
  • junit源码将JUnit3代码转换为JUnit4 脚本不是完美的,但是在处理最常见的问题上还有很长的路要走。 不处理呼叫 junit.framework.TestSuite.addTestSuite(clazz); 对于这些,您需要使用@RunWith(Suite.class) 。
  • Junit4.jar

    2018-03-24 21:37:32
    Junit4.jar, Junit4.jar, Junit4.jar, Junit4.jar, Junit4.jar, Junit4.jar
  • JUnit 4 vs JUnit 5

    千次阅读 2019-10-04 09:56:26
    JUnit 4 JUnit 5 定义方法测试 @Test @Test 区别: JUnit5中没有声明任何属性,JUnit Jupiter中的测试扩展是基于它们自己的专用注解来完成的。这样的方法会被继承,除非它们被覆盖。 JUnit 4中基于属性来设置...

    注解说明

    单元测试方法

    功能描述JUnit 4JUnit 5
    定义方法测试@Test@Test

    区别:
    JUnit5中没有声明任何属性,JUnit Jupiter中的测试扩展是基于它们自己的专用注解来完成的。这样的方法会被继承,除非它们被覆盖。
    JUnit 4中基于属性来设置,timeout和exception两个属性

    类前置方法

    功能描述JUnit 4JUnit 5
    在类所有方法执行之前调用@BeforeClass@BeforeAll

    说明:
    单元测试方法包括: @Test/@RepeatedTest
    /@ParameteredTest/@TestFactory修饰的方法

    类后置方法

    功能描述JUnit 4JUnit 5
    在类所有方法执行之后调用@AfterClass@AfterAll

    说明:
    单元测试方法包括: @Test/@RepeatedTest
    /@ParameteredTest/@TestFactory修饰的方法

    方法级的前置方法

    功能描述JUnit 4JUnit 5
    在每一个单元测试方法之前执行@Before@BeforeEach

    说明:
    单元测试方法包括:@Test、@RepeatedTest、@ParameterizedTest或者@TestFactory

    方法级的后置方法

    功能描述JUnit 4JUnit 5
    在每一个单元测试方法之后@After@AfterEach

    禁止执行

    功能描述JUnit 4JUnit 5
    禁止执行测试方法@Ignore@Disabled

    声明过滤测试

    功能描述JUnit 4JUnit 5
    过滤测试@Category@Tag

    参数化测试

    功能描述JUnit 4JUnit 5
    参数化测试@Parameters@ParameterizedTest

    运行测试类

    功能描述JUnit 4JUnit 5
    执行测试类@RunWith@ExtendWith

    监控TestCase和外部资源

    功能能描述JUnit 4JUnit 5
    监控/验证@Rule@ExtendWith

    静态变量

    功能描述JUnit 4JUnit 5
    静态变量@ClassRule@ExtendWith
    展开全文
  • Junit4教程

    2016-01-13 11:07:05
    Junit4教程讲述Junit4的使用,以及在eclipse中如何高效方便的进行对代码进行测试。
  • Junit 4 断言方法允许检查测试方法的期望结果值和真实返回值。Junit的org.junit.Assert类提供了各种断言方法来写junit测试。这些方法被用来检查方法的真实结果值和期望值。下列一些有用的断言方法列表:
  • Junit 4超时测试可以被用来测试can be used to test execution time of method. Junit 4 Timeout Test can be performed on any single method of class using @Timeout Annotationall methods of class using Time...
  • JUnit4基础文档

    2017-12-27 12:38:27
    JUnit4基础文档
  • jUnit4详细教程

    2017-11-27 10:24:35
    因 jdk5 中的新特性,JUnit4 也因此有了很大的改变。下面详细介绍 JUnit4 的使用方法,只是举个例子说明junit4 的使用
  • Junit4 jar包

    2018-08-22 14:42:38
    单元测试Junit4 用于java测试开发
  • JUnit 4 Demo

    2014-07-23 19:47:55
    JUnit 4 Demo
  • Junit 4 annotations provide the basic functionality to write junit test. Basic Junit 4 annotations explained in this post are @BeforeClass, @AfterClass, @Before, @After and @Test. @BeforeClass annota
  • Junit 4 Tutorials(Junit 4 教程)

    千次阅读 2014-07-08 16:53:54
    Junit 测试框架 测试框架是最流行的Java单元测试框架。Junit被用来开发Java类的单元测试。 Junit Eclipse 教程 介绍eclipse IDE 中junit的...Junit4 注解提供了书写单元测试的基本功能。本章将介绍@BeforeClass, @A
  • Junit4使用方法

    2016-11-16 12:07:30
    Junit4使用方法
  • junit3.8 和junit4 api

    2011-11-04 18:15:13
    junit3.8 和junit4 api
  • mock junit4

    2012-03-09 20:36:25
    mock junit4
  • JUnit 5和JUnit 4比较

    万次阅读 多人点赞 2019-01-21 15:11:34
    JUnit 5旨在调整java 8样式的编码,并且比JUnit 4更强大和灵活。在这篇文章中,JUnit 5 vs JUnit 4,我们将关注junit 4junit 5之间的一些主要差异。 1. JUnit 5 vs JUnit 4 - 注释 两个版本中的大多数注释都是...
  • 学习-junit4 JUnit 实践代码学习与 JUnit in Action 一书
  • Junit 测试框架简介   测试框架是最流行的Java单元... Junit 4 特性 简单的注解,提供书写Junit测试的基本特性断言方法(Assert Methods)比较测试的方法执行结果值和期望值@Ignore 注解,忽略测试方法或者测试类的
  • JUnit4 下载包

    2017-03-06 11:24:29
    JUnit4 下载包 包含 juint4.12 和 harmcrest1.3
  • junit4教程(《Junit4初探》)

    热门讨论 2009-05-13 14:31:45
    junit4教程(《Junit4初探》)
  • spring boot Junit4配置

    2018-05-29 10:12:41
    由于很多人不会配置Junit4和spring boot集成,所以文档主要讲解spring boot Junit4配置
  • Junit 4 参数化测试 允许通过变化范围的参数值来测试方法。参数擦测试可以通过以下简单的步骤实现: 对测试类添加注解 @RunWith(Parameterized.class) 将需要使用变化范围参数值测试的参数定义为私有变量 使用上...
  • junit4 jar完整包

    2018-03-05 13:23:13
    java junit4 jar完整包,junit可用来项目的单元测试。
  • junit4学习文档

    2015-07-01 16:34:38
    junit4学习文档,有实例,非常详细,不懂的可以参考

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 377,730
精华内容 151,092
关键字:

junit4