zoukankan      html  css  js  c++  java
  • JUnit【1】断言用法之assertEquals/True/False/ArrayEquals

       前段时间去亚信面试,被问到写一个冒泡排序,心想这多新鲜,刷刷几下写好。面试官突然问,你怎么对这个程序进行单元测试?

       单元测试?!
       懵圈...
     
       单元测试
     
       代码是为了什么,当然是重复运行。你的程序主要是由一个个的 Class 组成的,一个类或一个对象当然也是一个单元,而比类更小的单元是类的方法(函式)。如果你的类中的基本单元——如某些方法不能正常工作,在某些输入条件下会得出错误的执行结果,那么如何保证你的类/对象乃至整个应用软件或系统作为一个整体能正常工作呢?所以,简单说,单元测试(优先)的目的就是首先保证一个系统的基本组成单元、模块(如对象以及对象中的方法)能正常工作,这是一种分而治之中的 bottom-up 思想。
       百度百科给出的单元测试的定义:http://baike.baidu.com/link?url=tBjOgVVmpid3gjdl4H_7FbqG5LAnjof7FYrL5thzI861kyumRwU8vS6HmSLUvB1pr0sfmj1O3UIJHGHEnlbWKlCPbej_hyKYA6Tqr4ZskhFjoixqsEQpVtNkjxy8awax
     
     工具

        对于java代码进行单元测试,我选用的是JUnit(推荐使用JUnit4)。
    JUnit 在日常开发中还是很常用的,而且 Java 的各种 IDE (Eclipse、MyEclipse、IntelliJ IDEA)都集成了 JUnit 的组件。当然,自己添加插件也是很方便的。JUnit 框架是 Java 语言单元测试当前的一站式解决方案。这个框架值得称赞,因为它把测试驱动的开发思想介绍给 Java 开发人员并教给他们如何有效地编写单元测试。
     
      断言
     
      断言是编写测试用例的核心实现方式,即期望值是多少,测试的结果是多少,以此来判断测试是否通过。
      1)assertEquals()方法
      判断两个对象是否相等,并返回boolean,int等类型,前为期望值,后为输入值。
       assertEquals(返回值,Object expected,Object actual);
     
      2)assertTrue()/assertFalse()
       判断测试的对错,condition是期望,message是实际值。
       assertTrue(condition,message);
       或assertFalse(condition,message);
      
      3)assertArrayEquals()
      判断两个数组是否相等
      assertArrayEquals(a[],b[]);
     
      例子:
      (1)我于上午编写了一个三角形判定的代码,包含四个小函数,并用assertEquals()与assertTrue()/assertFalse()进行单元测试。
    Triangle.java:
    public class Triangle {
    protected long lborderA = 0;
    protected long lborderB = 0;
    protected long lborderC = 0;
    // Constructor
    public Triangle(long lborderA, long lborderB, long lborderC) {
    this.lborderA = lborderA;
    this.lborderB = lborderB;
    this.lborderC = lborderC;
    }
    /**
     * check if it is a triangle
     * 
     * @return true for triangle and false not
     */
    public boolean isTriangle(Triangle triangle) {
    boolean isTriangle = false;

    // check boundary
    if ((triangle.lborderA > 0 && triangle.lborderA <= Long.MAX_VALUE)
    && (triangle.lborderB > 0 && triangle.lborderB <= Long.MAX_VALUE)
    && (triangle.lborderC > 0 && triangle.lborderC <= Long.MAX_VALUE)) {

    // check if subtraction of two border larger than the third
    if (diffOfBorders(triangle.lborderA, triangle.lborderB) < triangle.lborderC
    && diffOfBorders(triangle.lborderB, triangle.lborderC) < triangle.lborderA
    && diffOfBorders(triangle.lborderC, triangle.lborderA) < triangle.lborderB) {
    isTriangle = true;
    }

    }
    return isTriangle;
    }

    /**
     * Check the type of triangle
     * 
     * Consists of "Illegal", "Regular", "Scalene", "Isosceles"
     */
    public String getType(Triangle triangle) {
    String strType = "Illegal";

    if (isTriangle(triangle)) {
    // Is Regular
    if (triangle.lborderA == triangle.lborderB
    && triangle.lborderB == triangle.lborderC) {
    strType = "Regular";
    }
    // If scalene
    else if ((triangle.lborderA != triangle.lborderB)
    && (triangle.lborderB != triangle.lborderC)
    && (triangle.lborderA != triangle.lborderC)) {
    strType = "Scalene";
    }
    // if isosceles
    else {
    strType = "Isosceles";
    }
    }

    return strType;
    }

    /**
     * calculate the diff between borders
     * 
     * */
    public long diffOfBorders(long a, long b) {
    return (a > b) ? (a - b) : (b - a);
    }

    /**
     * get length of borders
     */
    public long[] getBorders() {
    long[] borders = new long[3];
    borders[0] = this.lborderA;
    borders[1] = this.lborderB;
    borders[2] = this.lborderC;
    return borders;
    }
    }
     TriangleTest.java:

    import static org.junit.Assert.*;

    import org.junit.Test;


    public class TriangleTest {
    Triangle T1 = new Triangle(2, 3, 4);
    Triangle T2 = new Triangle(3, 4, 5);
    Triangle T3 = new Triangle(4, 4, 5);
    Triangle T4 = new Triangle(-1, 4, 5);
    Triangle T5 = new Triangle(4, 4, 4);
    Triangle T6 = new Triangle(6, 4, 5);
    Triangle T7 = new Triangle(10, 4, 5);
    Triangle T8 = new Triangle(6, 4, 5);

    @Test
    public void testIsTriangle() {
    assertEquals(true, T1.isTriangle(T1));
    assertEquals("Isosceles", T3.getType(T3));
    assertEquals(false, T4.isTriangle(T4));
    assertEquals("Regular", T5.getType(T5));
    assertEquals("Scalene", T6.getType(T6));
    assertEquals(false, T7.isTriangle(T7));
    assertEquals(1, T1.diffOfBorders(2, 3));
    assertEquals(2, T1.getBorders()[0]);
    assertEquals("Illegal", T4.getType(T4));
    }
    }
     
    (2)于下午14点编写了一个排序算法,并用assertArrayEquals进行单元测试
     Sorting.java:
      
     import java.util.Comparator;
    import java.util.Random;

    /**
     * A class that contains several sorting routines,
     * implemented as static methods.
     * Arrays are rearranged with smallest item first,
     * using compareTo.
     * @author Mark Allen Weiss
     */
    public final class Sorting
    {
        /**
         * Simple insertion sort.
         * @param a an array of Comparable items.
         */
        public void insertionSort( int[ ] a )
        {
            int j;

            for( int p = 1; p < a.length; p++ )
            {
                 int tmp = a[ p ];
                for( j = p; j > 0 && tmp<a[ j - 1 ]; j-- )
                     a[ j ] = a[ j - 1 ];
                a[ j ] = tmp;
            }
        }

        public  boolean isSorted(int[] a) {
            for(int i=0; i<a.length-1; i++) {
                if(a[i]>a[i+1]) {
                    return false;
                }
            }
            return true;
        }

        //line74
        public static void quicksort( int[ ] a )
        {
            quicksort( a, 0, a.length - 1 );
        }

        private static final int CUTOFF = 10;

        public static final void swapReferences( Object [ ] a, int index1, int index2 )
        {
            Object tmp = a[ index1 ];
            a[ index1 ] = a[ index2 ];
            a[ index2 ] = tmp;
        }
        public static final void swap(int[] a,int index1,int index2) {
            int tmp = a[ index1 ];
            a[ index1 ] = a[ index2 ];
            a[ index2 ] = tmp;
        }

        private static int median3( int[ ] a, int left, int right )
        {
            int center = ( left + right ) / 2;
            if( a[ center ]<a[ left ] )
                swap( a, left, center );
            if( a[ right ] < a[ left ] )
                swap( a, left, right );
            if( a[ right ] < a[ center ] )
                swap( a, center, right );

            // Place pivot at position right - 1
            swap( a, center, right - 1 );
            return a[ right - 1 ];
        }

        private static void quicksort( int[ ] a, int left, int right)
        {
            if( left + CUTOFF <= right )
            {
                int pivot = median3( a, left, right );

                int i = left, j = right - 1;
                for( ; ; )
                {
                    while( a[ ++i ] < pivot )  { }
                    while( a[ --j ] > pivot ) { }
                    if( i < j )
                         swap( a, i, j );
                    else
                        break;
                }

                swap( a, i, right - 1 );   // Restore pivot

                quicksort( a, left, i - 1 );    // Sort small elements
                quicksort( a, i + 1, right );   // Sort large elements
            }
            else  // Do an insertion sort on the subarray
                insertionSort( a, left, right );
        }

        private static void insertionSort( int[ ] a, int left, int right )
        {
            for( int p = left + 1; p <= right; p++ )
            {
                int tmp = a[ p ];
                int j;

                for( j = p; j > left && tmp < a[ j - 1 ]; j-- )
                    a[ j ] = a[ j - 1 ];
                a[ j ] = tmp;
            }
        }
        private static final int NUM_ITEMS = 1000;
        private static int theSeed = 1;
    }
     
     SortingTest1.java:
     import static org.junit.Assert.*;

    import org.junit.Test;


    public class SortingTest1 {

    Sorting s1=new Sorting();

    @Test
    public void testInsertionSort() {

    int a[]={2,3,1,5,3,11};
    int b[]={1,2,3,3,11,5};

    s1.insertionSort(a);
    assertArrayEquals(b,a);
    }

    @Test
    public void testIsSorted() {
    int c[]={3,2,2,4,2};
    int d[]={1,2,2,4,5};
    assertFalse(s1.isSorted(c));
    assertTrue(s1.isSorted(d));
    }

    @Test
    public void testQuicksort() {
    int e[]={2,3,7,5,4,7,0};
    int f[]={0,2,3,4,5,7,7};
    s1.quicksort(e);
    assertArrayEquals(e,f);

    int j[]={7,9,8,0,6,5,4,2,3,1,7};
    int k[]={0,1,2,3,4,5,6,7,7,8,9};
    s1.quicksort(j);
    assertArrayEquals(k,j);

    }

    @Test
    public void testSwapReferences() {
    Sorting s4=new Sorting();
    Object m[]={s4.equals(s4),s4.getClass(),s4.hashCode()};
    Object n[]={s4.hashCode(),s4.getClass(),s4.equals(s4)};
    s4.swapReferences(m, 0, 2);
        assertArrayEquals(n,m);
    }

    @Test
    public void testSwap() {
    int y[]={4,2,0};
    int z[]={0,2,4};
    s1.swap(y, 0, 2);
    assertArrayEquals(z,y);
    }

    }
  • 相关阅读:
    Git之将master合并到自己分支
    React 中的不可变数据 — Immer
    数据治理项目
    每日Excel系列
    Python实战网站开发:Day6编写配置文件
    Python实战网站开发:Day5搭建Web框架
    Python实战网站开发:Day7搭建MVC
    Visual Studio Code调试模式,出现无法打开,文件是目录错误的解决办法
    第1章 Vue.js2.0由浅入深:基本用法
    Python实战网站开发:Day4编写Model
  • 原文地址:https://www.cnblogs.com/1996swg/p/7112236.html
Copyright © 2011-2022 走看看