文档章节

Unit Testing with JUnit - Tutorial

Zuo_W
 Zuo_W
发布于 2013/11/14 16:13
字数 2766
阅读 301
收藏 0

1. Types of tests

1.1. Unit tests and unit testing

A unit test is a piece of code written by a developer that executes a specific functionality in the code which is tested. The percentage of code which is tested by unit tests is typically called test coverage.

A unit test targets a small unit of code, e.g. a method or a class, (local tests).

Unit tests ensure that code works as intended. They are also very helpful to ensure that the code still works as intended in case you need to modify code for fixing a bug or extending functionality. Having a high test coverage of your code allows you to continue developing features without having to perform lots of manual tests.

1.2. Test fixture

The text fixture is a fixed state of the software under test used as a baseline for running tests.

1.3. Functional and integration tests

An integration test has the target to test the behavior of a component or the integration between a set of components. The term functional test is sometimes used as synonym for integration test.

These kind of tests allow you to translate your user stories into a test suite, i.e., the test would resemble a expected user interaction with the application.

1.4. Performance tests

Performance tests are used to measure performance of software components in a repeatable way.

2. Test organization

2.1. Test organization for Java projects

Typically unit tests are created in a separate project or separate source folder to avoid that the normal code and the test code is mixed.

2.2. What should you test?

What is test is a hot topic for discussion. Some developers believe every statement in your code should be tested.

In general it is save to ignore trivial code, as for example getter and setter methods which simply assign values to fields. Writing tests for these statements is time consuming and pointless, as you would be testing the Java virtual machine. The JVM itself has already test cases for this and you are save to assume that field assignment works in Java if you are developing end user applications.

You should write software tests in any case for the critical and complex parts of your application. A solid test suite also protects you against regression in existing code, if you introduce new features.

2.3. Introducing tests in legacy code

If you start developing tests for an existing code base without any tests, it is good practice to start writing tests for the parts of the application in which most errors happened in the past. This way you can focus on the critical parts of your application.

3. Using JUnit

3.1. Unit testing with JUnit

JUnit in version 4.x is a test framework which uses annotations to identify methods that specify a test. Typically these test methods are contained in a class which is only used for testing. It is typically called a Test class.

The following code shows a JUnit test method . It can be created via FileNewJUnitJUnit Test case.


@Test public void testMultiply() { // MyClass is tested MyClass tester = new MyClass(); // check if multiply(10,5) returns 50 assertEquals("10 x 5 must be 50", 50, tester.multiply(10, 5));
 }


JUnit assumes that all test methods can be executed in an arbitrary order. Therefore tests should not depend on other tests.

To write a test with JUnit you annotate a method with the@org.junit.Test annotation and use a method provided by JUnit to check the expected result of the code execution versus the actual result.

You can use the Eclipse user interface to run the test, via right-click on the test class and selecting Run Run AsJUnit Test. Outside of Eclipse you can useorg.junit.runner.JUnitCoreclass to run the test. You can also mark a test method in a class and select to run the test. Only the selected method will be executed.

3.2. Available JUnit annotations

The following table gives an overview of the available annotations in JUnit 4.x.


Table 1. Annotations

Annotation Description

@Test
public void method()

The@Testannotation identifies a method as a test method.
@Test (expected = Exception.class) Fails, if the method does not throw the named exception.
@Test(timeout=100) Fails, if the method takes longer than 100 milliseconds.
@Before
public void method()
This method is executed before each test. It is used to can prepare the test environment (e.g. read input data, initialize the class).
@After
public void method()
This method is executed after each test. It is used to cleanup the test environment (e.g. delete temporary data, restore defaults). It can also save memory by cleaning up expensive memory structures.
@BeforeClass
public static void method()
This method is executed once, before the start of all tests. It is used to perform time intensive activities, for example to connect to a database. Methods annotated with this annotation need to be defined asstaticto work with JUnit.
@AfterClass
public static void method()
This method is executed once, after all tests have been finished. It is used to perform clean-up activities, for example to disconnect from a database. Methods annotated with this annotation need to be defined asstaticto work with JUnit.
@Ignore Ignores the test method. This is useful when the underlying code has been changed and the test case has not yet been adapted. Or if the execution time of this test is too long to be included.


3.3. Assert statements

JUnit provides static methods in theAssertclass to test for certain conditions. These assertion methods typically start withassertand allow you to specify the error message, the expected and the actual result. An assertion method compares the actual value returned by a test to the expected value, and throws anAssertionExceptionif the comparison test fails.

The following table gives an overview of these methods. Parameters in [] brackets are optional.


Table 2. Test methods

Statement Description
fail(String) Let the method fail. Might be used to check that a certain part of the code is not reached. Or to have a failing test before the test code is implemented. The String parameter is optional.
assertTrue([message], boolean condition) Checks that the boolean condition is true.
assertFalse([message], boolean condition) Checks that the boolean condition is false.
assertEquals([String message], expected, actual) Tests that two values are the same. Note: for arrays the reference is checked not the content of the arrays.
assertEquals([String message], expected, actual, tolerance) Test that float or double values match. The tolerance is the number of decimals which must be the same.
assertNull([message], object) Checks that the object is null.
assertNotNull([message], object) Checks that the object is not null.
assertSame([String], expected, actual) Checks that both variables refer to the same object.
assertNotSame([String], expected, actual) Checks that both variables refer to different objects.


Note

You should provide meaningful messages in assertions so that it is easier for the developer to identify the problem. This helps in fixing the issue, especially if someone looks at the problem, which did not write the code under test or the test code.

3.4. Create a JUnit test suite

If you have several test classes you can combine them into a test suite. Running a test suite will execute all test classes in that suite in the specified order.

The following example code shows a test suite which defines that two test classes should be executed. If you want to add another test class you can add it to@Suite.SuiteClassesstatement.


package com.vogella.junit.first; import org.junit.runner.RunWith; import org.junit.runners.Suite; import org.junit.runners.Suite.SuiteClasses; @RunWith(Suite.class) @SuiteClasses({ MyClassTest.class, MySecondClassTest.class }) public class AllTests {

}


3.5. Run your test outside Eclipse

Eclipse provides support for running your test interactively in the Eclipse IDE. You can also run your JUnit tests outside Eclipse via standard Java code. Theorg.junit.runner.JUnitCoreclass provides therunClasses()method which allows you to run one or several tests classes. As a return parameter you receive an object of the typeorg.junit.runner.Result. This object can be used to retrieve information about the tests.

In yourtestfolder create a new classMyTestRunnerwith the following code. This class will execute your test class and write potential failures to the console.


package de.vogella.junit.first; import org.junit.runner.JUnitCore; import org.junit.runner.Result; import org.junit.runner.notification.Failure; public class MyTestRunner { public static void main(String[] args) {
    Result result = JUnitCore.runClasses(MyClassTest.class); for (Failure failure : result.getFailures()) {
      System.out.println(failure.toString());
    }
  }
}


To run your JUnit tests outside Eclipse you need to add the JUnit library jar to the classpath of your program. Typically build frameworks like Apache Ant or Apache Maven are used to execute tests automatically on a regular basis.

4. Installation of JUnit

4.1. Using JUnit integrated into Eclipse

Eclipse allows you to use the version of JUnit which is integrated in Eclipse. If you use Eclipse no additional setup is required. In this case you can skip the following section.

4.2. Downloading the JUnit library

If you want to control the used JUnit library explicitly, download JUnit4.x.jar from the following JUnit website. The download contains thejunit-4.*.jarwhich is the JUnit library. Add this library to your Java project and add it to the classpath.


http://junit.org/ 


5. Eclipse support for JUnit

5.1. Creating JUnit tests

You can write the JUnit tests manually but Eclipse supports the creation of JUnit tests via wizards.

For example to create a JUnit test or a test class for an existing class, right-click on your new class, select this class in the Package Explorer view, right-click on it and select NewJUnit Test Case.

Alternatively you can also use the JUnit wizards available under FileNew Other...JavaJUnit.

5.2. Running JUnit tests

To run a test, select the class which contains the tests, right-click on it and select Run-asJUnit Test. This starts JUnit and executes all test methods in this class.

Eclipse provides the Alt+Shift+X, ,T shortcut to run the test in the selected class. If you position the cursor on one method name, this shortcut runs only the selected test method.

To see the result of an JUnit test, Eclipse uses the JUnit view which shows the results of the tests. You can also select individual unit test in this view , right-click them and select Run to execute them again.


JUnit view


By default this view shows all tests you can also configure, that it shows only failing tests.


JUnit view


You can also define that the view is only activated if you have a failing test.


JUnit view


Note

Eclipse creates run configurations for tests. You can see and modify these via the RunRun Configurations... menu.

5.3. JUnit static imports

JUnit uses static methods and Eclipse cannot always create the correspondingstatic importstatements automatically.

You can make the JUnit test methods available via the Content Assists. Content Assists is a functionality in Eclipse which allows the developer to get context sensitive code completion in an editor upon user request.

Open the Preferences via WindowPreferences and select JavaEditorContent AssistFavorites.

Use the new New Type button to add theorg.junit.Asserttype. This makes for example theassertTrue,assertFalseandassertEqualsmethods directly available in the Content Assists.


Adding static imports to the preferences


You can now use Content Assists (shortcut: Ctrl+Space) to add the method and the import.

5.4. Wizard for creating test suites

To create a test suite in Eclipse you select the test classes which should be included into this in the Package Explorer view, right-click on them and select New Other...JUnitJUnit Test Suite.


Create a test suite


5.5. Testing exception

The@Test (expected = Exception.class)annotation is limited as it can only test for one exception. To test exceptions you can use the following test pattern.


try {
   mustThrowException(); 
   fail();
} catch (Exception e) { // expected // could also check for message of exception, etc. }


6. Exercise: Using JUnit

6.1. Project preparation

Create a new project called com.vogella.junit.first.

Create a new source foldertest. For this right-click on your project, select Properties and choose the Java Build Path . Select the Source tab.


Create new source folder for the tests


Press the Add Folder button, afterwards press the Create New Folder button. Create thetestfolder.

The result is depicted in the following sceenshot.


Creating a new folder


Alternatively you can add a new source folder by right-clicking on a project and selecting New Source Folder.

6.2. Create a Java class

In thesrcfolder, create thecom.vogella.junit.firstpackage and the following class.


package com.vogella.junit.first; public class MyClass { public int multiply(int x, int y) { // the following is just an example if (x > 999) { throw new IllegalArgumentException("X should be less than 1000");
    } return x / y;
  }
}


6.3. Create a JUnit test

Right-click on your new class in the Package Explorer view and select NewJUnit Test Case.

In the following wizard ensure that the New JUnit 4 test flag is selected and set the source folder totest, so that your test class gets created in this folder.


Create new test class


Press the Next button and select the methods that you want to test.


Selecting the methods to test


If the JUnit library is not part of the classpath of your project, Eclipse will prompt you to add it. Use this to add JUnit to your project.


Eclipse prompt for adding JUnit to the project classpath


Create a test with the following code.


package com.vogella.junit.first; import static org.junit.Assert.assertEquals; import org.junit.AfterClass; import org.junit.BeforeClass; import org.junit.Test; public class MyClassTest { @BeforeClass public static void testSetup() {
  } @AfterClass public static void testCleanup() { // Teardown for data used by the unit tests } @Test(expected = IllegalArgumentException.class) public void testExceptionIsThrown() {
    MyClass tester = new MyClass();
    tester.multiply(1000, 5);
  } @Test public void testMultiply() {
    MyClass tester = new MyClass();
    assertEquals("10 x 5 must be 50", 50, tester.multiply(10, 5));
  }
}


6.4. Run your test in Eclipse

Right-click on your new test class and select Run-AsJUnit Test.


Run JUnit test in Eclipse


The result of the tests will be displayed in the JUnit view . In our example one test should be succesful and one test should show an error. This error is indicated by a red bar.


Result of running a unit test


The test is failing because our multiplier class is currently not working correctly. It does a division instead of multiplication. Fix the bug and re-run test to get a green bar.

7. Advanced JUnit options

7.1. Parameterized test

JUnit allows you to use parameters in a tests class. This class can contain one test method and this method is executed with the different parameters provided.

You mark a test class as a parameterized test with the@RunWith(Parameterized.class)annotation.

Such a test class must contain a static method annotated with@Parametersthat generates and returns a Collection of Arrays. Each item in this collection is used as the parameters for the test method.

You need also to create a constructor in which you store the values for each test. The number of elements in each array provided by the method annotated with@Parametersmust correspond to the number of parameters in the constructor of the class. The class is created for each parameter and the test values are passed via the constructor to the class.

The following code shows an example for a parameterized test. It assume that you test themultiply()method of theMyClassclass which was used in an example earlier.


package de.vogella.junit.first; import static org.junit.Assert.assertEquals; 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 MyParameterizedClassTest { private int multiplier; public MyParameterizedClassTest(int testParameter) { this.multiplier = testParameter;

  } // creates the test data @Parameters public static Collection<Object[]> data() {

    Object[][] data = new Object[][] { { 1 }, { 5 }, { 121 } }; return Arrays.asList(data);

  } @Test public void testMultiplyException() {

    MyClass tester = new MyClass();

    assertEquals("Result", multiplier * multiplier,

        tester.multiply(multiplier, multiplier));

  }



}


If you run this test class, the test method is executed with each defined parameter. In the above example the test method is executed three times.

7.2. Rules

Via the@Ruleannotation you can create objects which can be used and configured in your test methods. This adds more flexibility to your tests. You could for example specify which exception message your expect during execution of your test code.


package de.vogella.junit.first; import org.junit.Rule; import org.junit.Test; import org.junit.rules.ExpectedException; public class RuleExceptionTesterExample { @Rule public ExpectedException exception = ExpectedException.none(); @Test public void throwsIllegalArgumentExceptionIfIconIsNull() {
    exception.expect(IllegalArgumentException.class);
    exception.expectMessage("Negative value not allowed");
    ClassToBeTested t = new ClassToBeTested();
    t.methodToBeTest(-1);
  }
}


JUnit provides already several useful implementations of rules. For example theTemporaryFolderclass allows to setup files and folders which are automatically removed after a test.

The following code shows an example for the usage of theTemporaryFolderimplementation.


package de.vogella.junit.first; import static org.junit.Assert.assertTrue; import java.io.File; import java.io.IOException; import org.junit.Rule; import org.junit.Test; import org.junit.rules.TemporaryFolder; public class RuleTester { @Rule public TemporaryFolder folder = new TemporaryFolder(); @Test public void testUsingTempFolder() throws IOException {
    File createdFolder = folder.newFolder("newfolder");
    File createdFile = folder.newFile("myfilefile.txt");
    assertTrue(createdFile.exists());
  }
}


To write your own rule you need to implement theTestRuleinterface.

8. Mocking

Unit testing uses also mocking of objects. In this case the real object is replaced by a replacement which has a predefined behavior the test.

There are several frameworks available for mocking. To learn more about mock frameworks please see the Mockito tutorial and the EasyMock tutorial

本文转载自:http://www.vogella.com/articles/JUnit/article.html

Zuo_W
粉丝 8
博文 23
码字总数 11094
作品 0
南京
程序员
私信 提问
android unit test

Android Unit and Integration testing:https://github.com/codepath/android_guides/wiki/Android-Unit-and-Integration-testing Unit Testing with JUnit - Tutorial:http://www.vogella.c......

智能小松鼠
2015/03/10
0
0
Android 单元测试链接整理

Android单元测试 http://blog.csdn.net/stevenhu223/article/details/8298858 通过JUnit进行Android单元测试:http://www.open-open.com/lib/view/open1328152424546.html 如何进行Android单......

智能小松鼠
2014/12/16
0
0
JUnit Tutorial for Unit Testing

http://www.javacodegeeks.com/2014/11/junit-tutorial-unit-testing.html

perfectspr
2014/11/14
0
0
JMockit+JUnit单元测试初始化问题

一、项目环境: WIN7 64位,Eclipse 4.2,JDK1.6,JUnit 4.11,JMockit 1.10 二、示例代码: 使用JUnit + JMockit进行单元测试,运行JUnit Case时,抛出以下错误: java.lang.IllegalStateEx...

dexterman
2014/08/27
0
0
JUnit 4.13 Beta 1 发布,Java 单元测试框架

JUnit 4.13 版本的首个 Beta 版已发布。 JUnit 是一个 Java 语言的单元测试框架。它有自己的 JUnit 扩展生态圈,多数 Java 开发环境都已经集成了JUnit 作为单元测试的工具。JUnit 测试是程序...

局长
2018/11/27
428
4

没有更多内容

加载失败,请刷新页面

加载更多

Android Camera原理之camera service与camera provider session会话与capture request轮转

上层调用CameraManager.openCamera的时候,会触发底层的一系列反应,之前我们分享过camera framework到camera service之间的调用,但是光看这一块还不够深入,接下来我们讨论一下camera serv...

天王盖地虎626
15分钟前
0
0
科技赋能成效显著!金融壹账通两大赋能项目荣获IDC大奖

7月19日,2019IDC中国未来金融论坛曁颁奖典礼于北京举办。由金融壹账通赋能的长春农商银行多人视频面审智能风控系统、包头农商银行互联网银行SaaS服务两大项目因在项目的创新性、技术领先性、...

IFTNews
昨天
0
0
HTTP协议

HTTP简介 HTTP协议(HyperText Transfer Protocol,超文本传输协议)是因特网上应用最为广泛的一种网络传输协议,所有的WWW文件都必须遵守这个标准。 HTTP是一个基于TCP/IP通信协议来传递数据...

Eappo_Geng
昨天
1
0
聊聊spring cloud consul的TtlScheduler

序 本文主要研究一下spring cloud consul的TtlScheduler TtlScheduler spring-cloud-consul-discovery-2.1.2.RELEASE-sources.jar!/org/springframework/cloud/consul/discovery/TtlSchedule......

go4it
昨天
0
0
内存狂挤牙膏Intel跪了!10nm玩出6种花样

不同于CPU处理器等逻辑芯片的制造工艺都精确到具体数值,闪存、内存工艺一直都是很模糊的叫法,比如10nm-class(10nm级别),只是介于20nm和10nm之间,然后又分为1xnm、1ynm、1znm等不同版本,...

linuxCool
昨天
2
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部