• 基于JUnit3.8的一个简单的测试程序


    实现一个简单的计算

    注:目标类和测试类要放在同一包下, JUnit单元测试基础要点

    目标类:Calculator.java

    [java] view plain copy
    1. package com.junit3_8;  
    2.   
    3. public class Calculator {  
    4.     //加  
    5.     public int add(int a, int b)  
    6.     {  
    7.         return a + b ;  
    8.     }  
    9.     //减  
    10.     public int subtract(int a, int b)  
    11.     {  
    12.         return a - b ;  
    13.     }  
    14.     //乘  
    15.     public int multiply(int a, int b)  
    16.     {  
    17.         return a * b ;  
    18.     }  
    19.     //除  
    20.     public int divide(int a, int b)throws Exception  
    21.     {  
    22.         if (0 == b)  
    23.         {  
    24.             throw new Exception("除数不能为0");  
    25.         }  
    26.         return a / b ;  
    27.     }  
    28.   
    29. }  

    测试类: CalculatorTest.java

    [java] view plain copy
    1. package com.junit3_8;  
    2.   
    3. import junit.framework.Assert;  
    4. import junit.framework.TestCase;  
    5.   
    6. //测试类要继承TestCase  
    7. public class CalculatorTest extends TestCase{  
    8.       
    9.     Calculator cal;  
    10.       
    11.     //在“每个”测试方法执行之前被调用  
    12.     public void setUp()  
    13.     {  
    14.         //这段代码在这写比较方便,只写一次就够,  
    15.         //不用在每个方法里写,因为这个方法每次都被调用,生成不同的对象,供测试方法使用  
    16.         cal = new Calculator();  
    17.         //System.out.println("setUp");  
    18.     }  
    19.       
    20.     //在“每个”测试方法执行之后被调用  
    21.     public void tearDown()  
    22.     {  
    23.         //System.out.println("testDown");  
    24.     }  
    25.       
    26.     //测试方法:方法名要以test为开头,无参数,无返回类型  
    27.     public void testAdd()  
    28.     {  
    29.         //Calculator cal = new Calculator();  
    30.         int result = cal.add(1, 2);  
    31.         //第一个参数是预期的,第二个参数是真实的  
    32.         Assert.assertEquals(3, result);  
    33.           
    34.     }  
    35.       
    36.     public void testSubtract()  
    37.     {  
    38.         //Calculator cal = new Calculator();  
    39.         int result = cal.subtract(1, 2);  
    40.         //第一个参数是预期的,第二个参数是真实的  
    41.         Assert.assertEquals(-1, result);  
    42.           
    43.     }  
    44.       
    45.     public void testMultiply()  
    46.     {  
    47.         //Calculator cal = new Calculator();  
    48.         int result = cal.multiply(1, 2);  
    49.         //第一个参数是预期的,第二个参数是真实的  
    50.         Assert.assertEquals(2, result);  
    51.           
    52.     }  
    53.       
    54.     public void testDivide()  
    55.     {  
    56.         int result = 0;  
    57.         //Calculator cal = new Calculator();  
    58.         try   
    59.         {  
    60.             result = cal.divide(4, 2);  
    61.               
    62.         }  
    63.         catch(Exception e)  
    64.         {  
    65.             e.printStackTrace();  
    66.             //让测试失败  
    67.             Assert.fail();  
    68.         }  
    69.         //第一个参数是预期的,第二个参数是真实的  
    70.         Assert.assertEquals(2, result);  
    71.           
    72.     }  
    73.       
    74.     //除数为0的情况  
    75.     public void testDivideByZero()  
    76.     {  
    77.         Throwable th = null ;  
    78.           
    79.         //Calculator cal = new Calculator();  
    80.         try   
    81.         {  
    82.             cal.divide(1, 0);  
    83.             Assert.fail();  
    84.         }  
    85.         catch(Exception e)  
    86.         {  
    87.             th = e ;  
    88.             //e.printStackTrace();  
    89.         }  
    90.           
    91.         //th 不为空 null  
    92.         Assert.assertNotNull(th);  
    93.         //第一个参数是预期的,第二个参数是真实的  
    94.         Assert.assertEquals(Exception.class, th.getClass());  
    95.         Assert.assertEquals("除数不能为0", th.getMessage());  
    96.           
    97.     }  
    98.       
    99.     //加了这个main方法,可以直接以 Java Application 方式运行 ,也可以以 JUnit Test 运行  
    100.     public static void main(String[] args)  
    101.     {  
    102.         //命令行形式打印  
    103.         junit.textui.TestRunner.run(CalculatorTest.class);  
    104.           
    105.         //awt 界面方式显示  
    106.         //junit.awtui.TestRunner.run(CalculatorTest.class);  
    107.           
    108.         //swing 界面方式显示  
    109.         //junit.swingui.TestRunner.run(CalculatorTest.class);  
    110.     }  
    111.   
    112. }  

    1.调用 Assert.fail() 是让测试失败,该方法一般放在你认为不会到达的地方

    2.这段代码让整个程序简便了许多  Calculator cal;    //在“每个”测试方法执行之前被调用  public void setUp()  {   //这段代码在这写比较方便,只写一次就够,   //不用在每个方法里写,因为这个方法每次都被调用,生成不同的对象,供测试方法使用   cal = new Calculator();  }

  • 相关阅读:
    019_linuxC++之_函数模板引入
    018_linuxC++之_抽象类的引入
    017_linuxC++之_多态的引入
    《将博客搬至CSDN》
    016_linuxC++之_多重继承
    013_linuxC++之_派生类中权限的调整
    015_linuxC++之_覆写
    014_linuxC++之_不同类型的继承
    012_linuxC++之_类的继承定义
    011_linuxC++之_继承的引入
  • 原文地址:https://www.cnblogs.com/hoobey/p/5293974.html
Copyright © 2020-2023  润新知