一般还见面为此到一个或多单单元测试框架。如果非用单元测试的言辞量如这么形容测试代码了。

证实方法会抛出某些老

有些时候,抛来异常是一个智对工作之同有。比如一个除法函数,当除数是0的时光,它应当抛出异常,告诉外界,传入的被除数是0,示例代码如下:

public class Calculator {

    // Omit testAdd() and testMultiply() for brevity

    public double divide(double divident, double dividor) {
        if (dividor == 0) throw new IllegalArgumentException("Dividor cannot be 0");

        return divident / dividor;
    }}

这就是说什么样测试当传入的除数是0的时刻,这个法应该抛出IllegalArgumentException异常呢?
每当Junit中,可以通过叫@Test
annotation传入一个expected参数来上这个目的,如下:

public class CalculatorTest {
    Calculator mCalculator;

    @Before
    public void setup() {
        mCalculator = new Calculator();
    }

    // Omit testAdd() and testMultiply() for brevity

    @Test(expected = IllegalArgumentException.class)
    public void test() {
        mCalculator.divide(4, 0);
    }

}

@Test(expected = IllegalArgumentException.class)表示验证这个测试方法将抛出IllegalArgumentException特别,如果无丢来的口舌,则测试失败。

9、fail()

深受测试方法失败

在意:上面的每一个艺术,都起一个重载的措施,可以在前加一个String类型的参数,表示如证明失败以来,将据此是字符串作为黄的结果报告。
比如:
assertEquals(“Current user Id should be 1”, 1, currentUser.id());
当currentUser.id()的价值未是1之时刻,在结果报道中将显示”Current user Id
should be 1″,这样好叫测试结果更具有可读性,更懂错误的原故是啊。
较好玩的是最后一个艺术,fail(),你也许会好奇,这个产生什么用呢?其实这当多状下要管用之。你得证明你的测试代码真的是走了的。

Ignore一些测试方法

博时段,因为一些原因(比如正式代码还从来不落实等),我们可能想为JUnit忽略某些方法,让它于走所有测试方法的当儿绝不跑者测试方法。要达成这目的呢够呛粗略,只待以苟给忽视的测试方法前面加上@Ignore纵然可以了,如下:

public class CalculatorTest {
    Calculator mCalculator;

    @Before
    public void setup() {
        mCalculator = new Calculator();
    }

    // Omit testAdd() and testMultiply() for brevity

    @Test
    @Ignore("not implemented yet")
    public void testFactorial() {
    }
}

1、为什么要就此单元测试呢?

起太基本的游说自。假设我们来如此一个像样

public class Calculator{
      public int add(int one, int another){
            return one + another;
      }

      public int multiply(int one, int another){
            return one * another;
      }
}

若是非用单元测试的言辞量如这么形容测试代码了

public class CalculatorTest{
    public static void main(String[]  args){
        Calculator mCalculator = new Calculator();
        int sum = mCalculator.add(1, 2);
         if(sum == 3){
            Log.e("123", "add works");
        }else{
            Log.e("123", "add not works");
        }

        int product  = mCalculator.multiply(2, 4);
        if(product == 8){
              Log.e("123", "multiply works");
        }else{
              Log.e("123", "multiply not works");
        }
    }

}

末段当运行此CalculatorTest的main方法,在支配高出口结果,如果我们发为数不少类,每个接近都生许多措施,那么就要写一积聚代码。如果用Junit的语,我们可按照如下的措施写测试代码。

public  class CalculatorTest{
    @Test
    public void testAdd() throws Exception{
          Calculator  mCalculator = new Calculator();
          int sum = mCalculator.add(1, 2);
          Assert.assertEquals(3, sum);
    }

    @Test
    public void testMultiply() throws Exception{
          Calculator mCalculator = new Calculator();
          int  product = mCalculator.mutiply(2, 4);
          Assert.assertEquals(8, product);
    }

}

一个测试方法包括三单部分
1、setUp
2、执行操作。
3、验证结果
以方的代码中,testAdd()和testMultiply()都发平等的setUp:也尽管是初始化Calculator
mCalculator = new Calculator();,可以透过@Before来实现。

public class CalculatorTest {
    Calculator mCalculator;

    @Before
    public void setup() {
        mCalculator = new Calculator();
    }

    @Test
    public void testAdd() throws Exception {
        int sum = mCalculator.add(1, 2);
        assertEquals(3, sum);  //为了简洁,往往会static import Assert里面的所有方法。
    }

    @Test
    public void testMultiply() throws Exception {
        int product = mCalculator.multiply(2, 4);
        assertEquals(8, product);
    }

}

俺们形容单元测试,一般还见面因此到一个或者多独单元测试框架,在此,我们介绍一下JUnit4斯测试框架。这是Java界用底不过广泛,也是极度基础的一个框架,其他的成千上万框架,包括我们后会看底Robolectric,都是依据或兼容JUnit4的。
然而首先要缓解之问题是。。。

2、在androidTest包下新建一个CalculatorTest:
public class CalculatorTest {

    private Calculator mCalculator;

    @Before
    public void setup(){
        mCalculator = new Calculator();
    }

    @Test
    public void testAdd(){
        int add = mCalculator.add(1, 11);
        Assert.assertEquals(12, add);
    }
}

小结

这首文字大概简单介绍了JUnit的下,相对来说是比较简单,也是比容易了解的,希望会协助及大家。其中Assert部分,可以拉咱证实一个计的归结果。然而,这些只能救助我们测试出返回值的那些方法。在首先首稿子中我们说了,一个看似的艺术分点儿种,一凡出返回值的方式,这些好通过我们今天开口的JUnit来做测试。而另外一种植没有返回值的主意,即void方法,则只要通过另外一个框架,Mockito,来证实其的没错。至于何以验证void方法的正确,以及Mockito的动,请关注下同样篇稿子。

抱最新篇章要纪念加入安卓单元测试交流群,请关注人世公众号

呼救!!!我亲婶婶,肝移植需要30万,还不一10万左右,求大家帮忙拉,求支持中转,有闲钱的讲话求捐一点!感谢感谢!!!

参考:
http://junit.org/junit4/
http://www.vogella.com/tutorials/JUnit/article.html

每当Android中采取单元测试。

本的Android开发以了Android
studio变得便捷了众多,简单的单元测试已经合并好了,在新建mudule的下在src/java下会看到androidTest、main和test包。

为何要采取单元测试框架为

或者换句话说,单元测试框架能够为我们开呀啊?
自太基本的起说打,假如我们发这般一个类:

public class Calculator {
    public int add(int one, int another) {
        // 为了简单起见,暂不考虑溢出等情况。
        return one + another;
    }

    public int multiply(int one, int another) {
        // 为了简单起见,暂不考虑溢出等情况。
        return one * another;
    }
}

若无用单元测试框架的话,我们只要怎么写测试代码呢?我们或许得勾来脚这样的代码:

public class CalculatorTest {
    public static void main(String[] args) {
        Calculator calculator = new Calculator();
        int sum = calculator.add(1, 2);
        if(sum == 3) {
            System.out.println("add() works!")
        } else {
            System.out.println("add() does not works!")
        }

        int product = calculator.multiply(2, 4);
        if (product == 8) {
            System.out.println("multiply() works!")
        } else {
            System.out.println("multiply() does not works!")
        }
    }
}

接下来我们再度经某种方式,比如命令执行抑IDE,运行是CalculatorTestmain主意,在拘留正在terminal的出口,才晓得测试是透过或者败诉。想想一下,如果我们发出多底好像,每个接近都发生好多智,那么就要写一堆放这样的代码,每个接近对于一个分包main方法的test类,同时main艺术中会时有发生同一堆积代码。这样既写起来痛苦,跑起又痛,比如说,你怎么样一次性跑所有的测试类呢?所以,一个测试框架为咱开的最为基本的业务,就是允许我们以某种更简便易行的章程写测试代码,把每一个测试单元写以一个测试方法里面,然后它会活动寻有有的测试方法,并且根据你的消,运行具有的测试方法,或者是运行单个测试方法,或者是运作有测试方法等等。
对地方的Calculator事例,如果应用Junit的语,我们可以以如下的方写测试代码:

public class CalculatorTest {

    @Test
    public void testAdd() throws Exception {
        Calculator calculator = new Calculator();
        int sum = calculator.add(1, 2);
        Assert.assertEquals(3, sum);
    }

    @Test
    public void testMultiply() throws Exception {
        Calculator calculator = new Calculator();
        int product = calculator.multiply(2, 4);
        Assert.assertEquals(8, product);
    }

}

各一个于测试的道(add(), multiply()),写一个对应的测试方法(testAdd(), testMultiply())。那JUnit怎么掌握那些是测试方法,哪些不是吗?这个是经过前的@Test注解来表明的,只要来此注解,JUnit4就见面当是一个测试方法,方法名其实是得擅自起的。当然,名字或应从的复发生可读性一点,让人同一看就亮,这个测试方法是测试了于测量的近乎的深方式,或者是测试了挺功能点等等。
除去救助咱摸索有装有的测试方法,并且有利于运行意外,单元测试框架还扶咱举行了其余工作。在斯系列之首先篇文章受到我们提到,一个测试方法主要不外乎三单部分:

  1. setup
  2. 推行操作
  3. 说明结果

比方一个单元测试框架,可以叫咱们再度便民的刻画点的各个一样步之代码,尤其是第一步和老三总理。比如说,在方的CalculatorTest中,testAdd()testMultiply()犹出同等的setup:
Calculator calculator = new Calculator();,如果Calculator还闹外的法子吧,这行代码就得重复更累,这种duplication是从来不必要的。绝大多数单元测试框架考虑到了这一点,它们了解一个测试类的成百上千测试方法可能用平等之setup,所以呢我们提供了便利方式。对于JUnit4,是经过@Before来落实的:

public class CalculatorTest {
    Calculator mCalculator;

    @Before
    public void setup() {
        mCalculator = new Calculator();
    }

    @Test
    public void testAdd() throws Exception {
        int sum = mCalculator.add(1, 2);
        assertEquals(3, sum);  //为了简洁,往往会static import Assert里面的所有方法。
    }

    @Test
    public void testMultiply() throws Exception {
        int product = mCalculator.multiply(2, 4);
        assertEquals(8, product);
    }

}

倘一个术被@Before修饰了了,那么在每个测试方法调用之前,这个主意还见面拿走调用。所以地方的事例中,testAdd()深受运行前,setup()会晤受调用一次,把mCalculator实例化,接着运行testAdd()testMultiply()让周转前,setup()再就是见面让调用一破,把mCalculator重新实例化,接着运行testMultiply()。如果还来另的测试方法,则盖此类推。
对应于@Before的,有一个@After,作用估计你吧猜测得到,那就算是每个测试方法运行了之后,会获取周转的法。比如一个测试文件操作的切近,那么当它们的测试类吃,可能@Before内用去开辟一个文书,而每个测试方法运行了后,都要去close这个文件。这个时候就是足以将公文close的操作放在@After里头,让它们自动去实践。
类似的,还有@BeforeClass@AfterClass@BeforeClass的来意是,在走一个测试类的富有测试方法之前,会实行同样不良让@BeforeClass修饰的法,执行完毕所有测试方法之后,会实施同一总体被@AfterClass修饰的艺术。这有限单办法可以据此来setup和release一些共用的资源,需要小心的凡,被当下半个annotation修饰的方法必须是静态的。

面前说的是单元测试框架对于一个测试方法的第一步“setup”,为咱召开的工作。而于第三统“验证结果”,则一般是透过有些assert方法来形成的。JUnit也咱提供的assert方法,多数且当Assert斯看似中。最常用之那些如下:

assertEquals(expected, actual)
验证expected的值跟actual是同样的,如果是同一吧,测试通过,不然的话,测试失败。如果传入的凡object,那么这里的自查自纠用的是equals()

assertEquals(expected, actual, tolerance)
这边传出的expected和actual是float或double类型的,大家领略计算机表示浮点型数据都来一定之讹,所以就理论及他们是相当的,但是就此微机表示出则可能不是,所以这边运行传入一个偏差值。如果个别单数的差异在是偏差值之内,则测试通过,否者测试失败。

assertTrue(boolean condition)
验证contidion的值是true

assertFalse(boolean condition)
验证contidion的值是false

assertNull(Object obj)
验证obj的值是null

assertNotNull(Object obj)
验证obj的价不是null

assertSame(expected, actual)
验证expected和actual是跟一个对象,即针对同一个目标

assertNotSame(expected, actual)
验证expected和actual不是和一个靶,即对不同之对象

fail()
叫测试方法失败

小心:上面的各个一个道,都起一个重载的措施,可以在前方加一个String类型的参数,表示要证实失败以来,将为此之字符串作为黄的结果报告。
比如:
assertEquals("Current user Id should be 1", 1, currentUser.id());
currentUser.id()的价不是1底时刻,在结果报道中将显示”Current user
Id should be
1″,这样好叫测试结果再次富有可读性,更明了错误的由是什么。
较有意思的是最终一个计,fail(),你也许会惊叹,这个来啊用吗?其实这于无数情形下还是有效的,比如最醒目的一个意就是是,你可印证你的测试代码真的是飞了之。
另外,它还有另外一个要作用,那就是认证某个被测试的方法会正确的废弃来好,不过就点好经过下说到之艺术,更便于之成功,所以尽管不出口了。
眼看一部分相对来说还是非常好理解的,不开了多讲。

6、assertNotNull(Object obj)

验证obj的值不是null

JUnit的别功能

7、assertSame(expected, actual)

验证expected和actual是暨一个靶,即对同一个对象

于Android项目里面用JUnit

以Android项目内用JUnit是甚简单的,你不过需要以JUnit这个library加到您的dependencies里面。
testCompile 'junit:junit:4.12'
若你通过AndroidStudio创建一个型,这个dependency默认是加上了底,所以若居然就步都得大概。
另外,你要拿测试代码放到src/test/java 目录下面。
接通下去关于怎样运行测试代码,怎么样看结果,请参见夫系列的首先篇稿子的连锁部分,因为贪图于多,这边就无又了。
此地为大家看一下运行的结果是啊则的,其中有一个砸的测试用例是故的。如果你直接当AndroidStudio里面走者的测试接近CalculatorTest的有所测试方法的语句,会见到如下的结果:

左手可以看到有的测试方法,以及每个方法跑出去的结果,绿色代表测试通过的测试方法,黄色的慨叹号或红的象征测试失败的。第三个坏有条纹的球球表示为忽视的测试方法。
苟是由此terminal跑的言辞,则会相如下的测试结果:

当即首稿子的系代码可以于github的这个project看到。

证办法抛来怪:

以给除数是0.

    public class CalculatorTest {
    Calculator mCalculator;

    @Before
    public void setup() {
        mCalculator = new Calculator();
    }

    // Omit testAdd() and testMultiply() for brevity

    @Test(expected = IllegalArgumentException.class)
    public void test() {
        mCalculator.divide(4, 0);
    }

}

4、assertFalse(boolean condition)

验证contidion的值是false

@BeforeClass:

于跑一个测试类的拥有测试方法之前,会履同样不善给@BeforeClass修饰的法。

JUnit为我们提供了Assert方法:

@AfterClass:

实施完毕所有测试方法之后,会执行同样整被@AfterClass修饰的艺术。
顾后少只方式修饰的方式必须是静态的。

@Ignore:

让某些方法以测试的早晚不需跑,要达标这个目的就是是以不经意测试的法门面前加上@Ignore就足以了。

2、assertEquals(expected, actual, tolerance);

此间流传的expected和actual是float或者double类型的,计算机表示浮点数据都发出必然的过错,所以即便理论及她们是等的,在计算机表示出则可能未是,所以这边传出一个偏差值。如果个别独数差异在这偏差值之内,则透过,否则测试失败

3、点击运行

图片 1

Paste_Image.png

@Before:

倘若一个主意让@Before修饰过,那么当每个测试方法调用前,这个法都见面获取调用。在testAdd()调用之前,setUp()会为调用一赖。

8、assertNotSame(expected, actual)

验证expected和actual不是与一个对象,即针对不同的目标

3、assertTrue(boolean condition)

验证contidion的值是true

@After:

每个测试方法运行了以后,会取得周转的法子,比如关闭文件的操作等等。

1、在main下创造一个好像:Calculator
public class Calculator {
    public int add(int a, int b){
        return a + b;
    }
}

5、assertNull(Object obj)

验证obj的值是null

4、在控制台查看结果

图片 2

Paste_Image.png

绿色代表成功了,红色表示即是大错特错。

顿时就是简单的单元测试。

1、assertEquals(expected, actual)

验证expected的值跟actual是一模一样的,如果是一模一样吧,测试通过,不然就测试失败,如果传入的凡Object,那么这里的对立统一用的是equals()

相关文章