JUnit 4 单元测试

Individual Project

　　　　　　　　　　——JUnit 4 单元测试

 

---

 

　　学习到JUnit单元测试，我拿来测试之前写过的一个计算器（两个依存类：Calc.java CalcFunction.java）。代码已放到github中。

贴出部分代码：

public class Calc extends javax.swing.JFrame{

        public Calc() {
            initComponents();
        }

        private void initComponents() {
            java.awt.GridBagConstraints gridBagConstraints;

            setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
            setTitle("u8ba1u7b97u5668");
            setBounds(new java.awt.Rectangle(500, 50, 0, 0));
            setResizable(false);

                        ···//界面布局

                }
                //主要监听
        ActionListener listenerEquals = new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                formulaStand.setText(edit + "=");
                hasPoint = false;
                String result;
                try {
                    result = CalcFunction.Evaluate(edit+"=");
                } catch (Exception e1) {
                    result = "syntax error";
                }
                if (Double.parseDouble(result)%1 == 0) {
                    editStand.setText(String.valueOf((int)Double.parseDouble((result))));
                }else{
                    editStand.setText(String.valueOf((float)Double.parseDouble((result))));
                }
                edit = "0";
            }
        }; 
}

 GUI布局类，运行的结果如下图：通过Botton输入表达式，传入CalcFunction类计算结果

这是计算器实现功能计算的类:

package com.school.indivodial;

import java.util.EmptyStackException;
import java.util.Stack;

public class CalcFunction {
    private static String[] TrnsInToSufix(String IFX) { // PFX放后缀表达式，IFX为中缀表达式
        String PFX[] = new String[IFX.length()];
        StringBuffer numBuffer = new StringBuffer();// 用来保存一个数的
        Stack<String> s = new Stack<String>();// 放操作符
        String a;
        s.push("=");// 第一个为等号
        int i = 0, j = 0;
        char ch;

        ··· // 栈操作，中缀表达式转后缀表达式

        return PFX;
    }

    public static String Evaluate(String IFX) throws Exception {// 后缀表达式求值

        String PFX[] = null;
        try {
            PFX = TrnsInToSufix(IFX);
        } catch (EmptyStackException e) {
            return "syntax error";
        }
        int i = 0;
        double x1, x2, n;
        String str;
        Stack<String> s = new Stack<String>();
        while (PFX[i] != "=") {
            str = PFX[i];
            switch (str.charAt(0)) {
            case '0':
            case '1':
            case '2':
            case '3':
            case '4':
            case '5':
            case '6':
            case '7':
            case '8':
            case '9':
                s.push(str);
                break;
            case '+':
                x1 = Double.parseDouble(s.pop());
                x2 = Double.parseDouble(s.pop());
                n = x1 + x2;
                s.push(String.valueOf(n));
                break;
            case '-':
                x1 = Double.parseDouble(s.pop());
                x2 = Double.parseDouble(s.pop());
                n = x2 - x1;
                s.push(String.valueOf(n));
                break;
            case '×':
                x1 = Double.parseDouble(s.pop());
                x2 = Double.parseDouble(s.pop());
                n = x1 * x2;
                s.push(String.valueOf(n));
                break;
            case '÷':
                x1 = Double.parseDouble(s.pop());
                x2 = Double.parseDouble(s.pop());
                n = x2 / x1;
                s.push(String.valueOf(n));
                break;
            case 'o':
                x1 = Double.parseDouble(s.pop());
                n = Math.log10(x1);
                s.push(String.valueOf(n));
                break;
            case 'n':
                x1 = Double.parseDouble(s.pop());
                n = Math.log1p(x1);
                s.push(String.valueOf(n));
                break;
            case 'u221a'://'√'
                x1 = Double.parseDouble(s.pop());
                n = Math.sqrt(x1);
                s.push(String.valueOf(n));
                break;// 开方
            case '^':
                x1 = Double.parseDouble(s.pop());
                x2 = Double.parseDouble(s.pop());
                n = Math.pow(x2, x1);
                s.push(String.valueOf(n));
                break;
            ···//其他运算
    
            }
            i++;
        }
        String result = s.pop();
        return result;
    }

}     

　　下面进行单元测试：测试CalcFunction类的方法计算结果是否有错误。

首先要在该工程下导入JUnit库 具体做法：Build Path -> Config Build Path ... -> Add Libraries ... 选中JUnit Next-> 选择JUnit 4 Finished 

添加完成

创建测试用例  

 new -> Java Test Case  Name：CalcFunctionTest Next-> 选择要测试的方法 ->finished

自动生成一个测试类CalcFunctionTest，里面包含一些空的测试用例，@Test 注解的。只需要将这些测试用例稍作修改即可使用。完整的CalcFunctionTest代码如下：

package com.school.indivodial;

import static org.junit.Assert.assertEquals;

import org.junit.Test;

/**
 * 
 * @author lendoon
 *CalcFunction类是Calc类的功能类，
 *Calc的UI输入中缀表达式调用CalcFunction的静态Evaluate方法计算返回结果
 */
public class CalcFunctionTest {
    
    @Test
    public void testEvaluate_basic() throws Exception {
        Double expectedAnswer = Double.valueOf("90");
        Double actualAnswer = Double.valueOf(CalcFunction.Evaluate("100-(22+6×3)÷4="));
        assertEquals(expectedAnswer, actualAnswer);
    }

    @Test
    public void testEvaluate_pow() throws Exception{
        Double expectedAnswer = Double.valueOf("1024");
        Double actualAnswer = Double.valueOf(CalcFunction.Evaluate("2^10="));
        assertEquals(expectedAnswer, actualAnswer);
    }
    
    @Test
    public void testEvaluate_sqrt() throws Exception{
        Double expectedAnswer = Double.valueOf("8");
        Double actualAnswer = Double.valueOf(CalcFunction.Evaluate("√64="));
        assertEquals(expectedAnswer, actualAnswer);
    }
    
    @Test
    public void testEvaluate_cos() throws Exception{
        Double expectedAnswer = Double.valueOf("1");
        Double actualAnswer = Double.valueOf(CalcFunction.Evaluate("COS(0)="));
        assertEquals(expectedAnswer, actualAnswer);
    }
}

Run As -> JUnit Test,结果如图：

 测试显示绿色的对号是通过的，显示蓝色叉号的，表示没通过failure。如图中的testEvaluate_cos测试方法。

 

运行失败，进度条会变成红褐色的，失败有两种情况：

处理结果与预期的有偏差（failure） 和  处理结果时，则直接抛出了异常——测试错误（error）

如图：测试失败的两种情况 

Failure 一般由单元测试使用的断言方法判断失败引起，它表示在测试点发现了问题，如断言"1" 和"1+1="；

而 error 则是由代码异常引起，这是测试目的之外的发现，它可能产生于测试代码本身的错误（测试代码也是代码，同样无法保证完全没有缺陷），也可能是被测试代码中的一个隐藏的 bug 如图中测试代码传入"1+1"没有=，不是一个表达式，在程序运行中会报错。

 

 全部测试成功时，进度条是绿色的：

 通过测试，现在的代码已经比较稳定，可以作为 API 的一部分提供给其它模块使用了。

 

 总结：

　　经过对JUnit 的了解，简单对之前写的计算器代码做个测试，收获颇丰：JUnit作为最佳实践测试任何可能的错误。单元测试不是用来证明您是对的，而是为了证明您没有错。JUnit还有更强大的功能等着我们去探索。

 　　

JUnit是一个开放源代码的Java测试框架，用于编写和运行可重复的测试。他是用于单元测试框架体系xUnit的一个实例（用于java语言）。它包括以下特性：

1、用于测试期望结果的断言（Assertion）

2、用于共享共同测试数据的测试工具

3、用于方便的组织和运行测试的测试套件

4、图形和文本的测试运行器　　　　（源于百度百科。相对于百科，wiki百科要简洁得多）