青鸟Junit4的使用
Junit4单元测试框架的常用方法介绍
Junit4单元测试框架的常⽤⽅法介绍Junit 介绍:Junit是⼀套框架（⽤于JAVA语⾔），由 Erich Gamma 和 Kent Beck 编写的⼀个回归测试框架（regression testing framework），即⽤于⽩盒测试。
本⽂介绍的内容:1 Junit Myeclipse测试类的⽣成2 JUnit 4 常⽤的⼏个annotation 介绍与使⽤ (@Before @After @Test @Ignore @BeforeClass @AfterClass)3 常⽤的断⾔介绍4 特殊的处理(限时测试，异常测试)5 参数化配置(@Parameters)准备测试代码测试的⽅法（正确、错误⽅法、死循环、抛异常）LogicServicepackage com.logic;public class LogicService {public int add(int x ,int y){ //加法return x+y;}public int sub(int x ,int y){ //减法return x-y;}public int div(int x ,int y){ //除法return x/y;}public int div2(int x ,int y){ //除法做了异常判断try {int z = x/y;} catch (Exception e) {e.printStackTrace();}return x/y;}public void loop(int x ,int y){ //死循环for(;;)x=y;}public void unCompleted(int x ,int y){ //未完成的模块//还在开发中}}⼀ Myeclipse测试类的⽣成1 对需要测试的类点右键 NEW ⼀个Junit Test Case2 点击NEXT注意 1 选择NEW Junit 4 test2 source folder 是默认会填写上之前右键NEW的那个类，如果不是的话，请⾃⾏进⾏修改3 package 默认会填写当前的包名个⼈建议重新开个测试包-即在包后⾯加上.test 表⽰是单元测试⽤例专⽤包与源代码分离4 name 默认会在之前右键NEW的那个类的基础的后⾯加上Test 如果不是的话，建议⾃⾏进⾏修改，便于标⽰5 初始化的⽅法，我⼀般会勾上个setUp，这个请随意。
JUnit如何使用介绍
JUnit如何使用介绍第一步，使用前的环境配置准备工作。
（在此文档中我使用JUnit的版本为JUnit4.3.1）先检查一下你的Eclipse环境是否已经有编写JUnit测试类的环境了，如果有了就可以直接使用了，如果没有安装，请参考以下操作，如：在Eclipse要安装那些插件和写JUnit测试类时，项目中要导入那些相应的.jar包。
按照下列步骤执行：1，从官方网站或其他途径下载你需要版本的JUnit包。
2，把你下载的包释放在自己电脑的某个目录。
（比如：D:\java）3，把你释放文件中的如：org.junit4_4.3.1文件拷贝Eclipse的\plugins目录下，如果你的电脑上的环境安装了MyEclipse6.0插件了，这个文件也就存在\plugins目录下了，也就是说你要写JUnit的测试类环境已经好了，可以直接写了。
在\plugins目录下需要的JUnit文件为：4，以下是如何检验JUnit是否已经安装成功：第一种方法：在Eclipse→Window→Preferences→Java→JUnit是否存在，如果存在JUnit 就算安装好了。
如下图所示：另一种方法：在Eclipse→Window→ShowView→Other→Java→JUnit是否存在，如果存在JUnit 就算安装好了。
如下图所示：接下来，我们要来往要使用JUnit测试的项目中，导入JUnit相应的版本包，如下所示：在项目中要导入的.jar文件：第二步，我们来编写第一个JUnit测试类，从数据库中取出一条记录的测试类。
1，要在项目里选中的test路径下创建测试类，如下图所示：2，在选中的test路径上右击New→Other→JUnit→JUnit Test Case如下图所示：3，在选中JUnit Test Case时，点击Next按钮出现下图所示：4，在红框中有Name:输入框里填写上测试类的名称，如：TestGetOneData，点击Finish按钮即可，TestGetOneData.java测试类就创建完成了。
Junit4Tutorials（Junit4教程）三、Junit4断言方法
Junit4Tutorials （Junit4教程）三、Junit4断言方法Junit 4 断言方法允许检查测试方法的期望结果值和真实返回值。
Junit 的org.junit.Assert 类提供了各种断言方法来写junit 测试。
这些方法被用来检查方法的真实结果值和期望值。
下列一些有用的断言方法列表：Junit 4 Assert MethodsMethodDescription assertNull(ng.Object object)检查对象是否为空 assertNotNull(ng.Object object)检查对象是否不为空 assertEquals(long expected, long actual) 检查long 类型的值是否相等 assertEquals(double expected, double actual, double delta)检查指定精度的double 值是否相等 assertFalse(boolean condition)检查条件是否为假 assertTrue(boolean condition) 检查条件是否为真assertSame(ng.Object expected, ng.Object actual) 检查两个对象引用是否引用同一对象（即对象是否相等）assertNotSame(ng.Objectunexpected, ng.Object actual) 检查两个对象引用是否不引用统一对象(即对象不等)Junit 4断言方法样例AssertionsTest.java junit 测试用例，显示各种断言方法：1.import static org.junit.Assert.*; 2.3.import java.util.ArrayList; 4.import java.util.List; 5.6.import org.junit.Test; 7.8./** 9.* @author javatutorials.co.in 10.*/ 11.public class AssertionsTest { 12.13.@Test14.public void testAssertNull() {15.String str = null;16.assertNull(str);17.}18.19.@Test20.public void testAssertNotNull() {21.String str = "hello Java!!";22.assertNotNull(str);23.}24.25.@Test26.public void testAssertEqualsLong() {27.long long1 = 2;28.long long2 = 2;29.assertEquals(long1, long2);30.}31.32.@Test33.public void testAssertEqualsDouble() {34.// test case is successfull as double1 and double 235.// differ by 0.001 which is less than our specified delta36.double double1 = 1.236;37.double double2 = 1.237;38.double delta = 0.002;39.assertEquals(double1, double2, delta);40.}41.42.@Test43.public void testAssertTrue() {44.List<String> list = new ArrayList<String>();45.assertTrue(list.isEmpty());46.}47.48.@Test49.public void testAssertFalse() {50.List<String> list = new ArrayList<String>();51.list.add("hello");52.assertFalse(list.isEmpty());53.}54.55.@Test56.public void testAssertSame() {57.String str1 = "hello world!!";58.String str2 = "hello world!!";59.assertSame(str2, str1);60.}61.62.@Test63.public void testAssertNotSame() {64.String str1 = "hello world!!";65.String str3 = "hello Java!!";66.assertNotSame(str1, str3);67.}68.}样例输出在eclipse Junit 窗口的输出如下：。
junit4单元测试案例
junit4单元测试案例
Junit4是Java编程语言中用于编写单元测试的一个重要框架。
在使用Junit4编写单元测试案例时，您需要按照以下步骤进行：
1. 导入Junit4库，首先，在您的Java项目中，需要在构建路
径中导入Junit4库，以便能够使用Junit4框架提供的各种功能。
2. 编写测试类，您需要创建一个与被测试类对应的测试类，并
在测试类中编写测试方法。
测试方法需要使用`@Test`注解进行标记，以便Junit4能够识别并执行这些测试方法。
3. 准备测试数据，在测试方法中，您需要准备好测试数据，并
调用被测试类的方法进行测试。
4. 断言测试结果，在测试方法中，您需要使用Junit4提供的
断言方法来验证被测试方法的返回结果是否符合预期。
5. 运行测试，最后，您可以使用Junit4提供的测试运行器来
运行测试类，以便执行其中的测试方法并查看测试结果。
总的来说，编写Junit4单元测试案例需要您导入Junit4库、编写测试类和测试方法、准备测试数据、使用断言验证测试结果，并最后运行测试以检查代码的正确性。
希望这些信息能够帮助您更好地理解Junit4单元测试案例的编写过程。
浅谈junit4单元测试高级用法
浅谈junit4单元测试⾼级⽤法Junit单元测试框架是程序开发必备的测试利器，现在最常⽤的就是Junit4了，在Junit4中所有的测试⽤例都使⽤了注解的形式，这⽐Junit3更加灵活与⽅便。
之前在公司的关于单元测试的培训课程中，讲师仅仅讲述了Junit4的基本的与⽣命周期相关的注解的使⽤，主要包括@BeforeClass、@Before、@Test、@After、@AfterClass这些注解，这些在应付普通简单的单元测试已经⾜够，然⽽有很多更加复杂且也会经常遇到的测试需求依靠这些⽣命周期注解并不能完成！因此这篇分享将为您呈现Junit4的另⼀⽚新⼤陆，且看陈述…其实，在单元测试培训课程中，讲师并没有讲到Junit4的核⼼，例如为什么Junit没有main()⽅法就能运⾏(因为我们知道⽆论是什么程序都必须得有⼀个程序⼊⼝，⽽它通常是main)；在例如Junit的核⼼组成部分是什么？如何更改Junit在运⾏单元测试时获取数据和执⾏测试的⾏为？更具体⼀点，如果我要为⼀个需要两个参数的⽅法进⾏测试，如何使⽤我所提供的参数的所有排列组合对⽅法进⾏测试？如果我需要在茫茫的测试⽤例中只测试与特定类相关的⽤例该怎么做…….在这之前，先纠正⼀点------Junit4可以直接运⾏我们的某个⽅法，没有main⼊⼝函数是断然不⾏的。
正如我之前给我们组的⼀个妹⼦讲Spring的时候告诉她，在测试⽅法中，对测试⽅法所在的类添加Spring的 (Compent注解或者为该类的成员变量添加)Resource注解并没有什么卵⽤，即Spring根本不会来扫描这个测试类，更不会为这个类注⼊属性值。
为什么这么说呢？因为Spring是在测试类中由被@Before标注的⽅法所启动的，这时候，JVM已经将此测试类实例化了，⽽这并不是由Spring实例化的，Spring晚了⼀步，所以在Spring的容器中并没有此类的实例。
那么Junit4真的有main⽅法吗？没错，既然它能直接运⾏我们的⽅法，那它必然⾃⼰为JVM提供了程序⼊⼝。
junit4中用例执行顺序
junit4中⽤例执⾏顺序
@BeforeClass：针对所有测试，只执⾏⼀次，且必须为static void
@Before：初始化⽅法
@Test：测试⽅法，在这⾥可以测试期望异常和超时时间
@After：释放资源
@AfterClass：针对所有测试，只执⾏⼀次，且必须为static void
junit4.x版本我们常⽤的注解：
A、@Before 注解：与junit3.x中的setUp()⽅法功能⼀样，在每个测试⽅法之前执⾏；
B、@After 注解：与junit3.x中的tearDown()⽅法功能⼀样，在每个测试⽅法之后执⾏；
C、@BeforeClass 注解：在所有⽅法执⾏之前执⾏；
D、@AfterClass 注解：在所有⽅法执⾏之后执⾏；
E、@Test(timeout = xxx) 注解：设置当前测试⽅法在⼀定时间内运⾏完，否则返回错误；
F、@Test(expected = Exception.class) 注解：设置被测试的⽅法是否有异常抛出。
抛出异常类型为：Exception.class；
G、@Ignore 注解：注释掉⼀个测试⽅法或⼀个类，被注释的⽅法或类，不会被执⾏。
JUNIT4使用介绍
JUNIT3实现示例
• public class AddOperationTest extends TestCase{ public void setUp() throws Exception { } public void tearDown() throws Exception { } public void testAdd() { System.out.println(\"add\"); int x = 0; int y = 0; AddOperation instance = new AddOperation(); int expResult = 0; int result = instance.add(x, y); assertEquals(expResult, result); } }
工具篇-part1
JUNIT4
JUNIT4介绍
• JUnit4 相比JUnit3来说基本上是一个新框架， 它是JUnit框架有史以来的最大改进，其主 要目标是利用Java5的Annotation特性简化测 试用例的编写。 • 要求：JDK 5.0或以上版本。
实例对比
• 我们先看一下在JUnit 3中我们是怎样写一个 单元测试的。比如下面一个类： public class AddOperation { public int add(int x,int y){ return x+y; } }
@Test(timeout=xxx): 该元数据传入了一个时间（毫秒）给测试方法， 如果测试方法在制定的时间之内没有运行完，则测试也失败。 @ignore： 该元数据标记的测试方法在测试中会被忽略。当测试的方法还没有实现， 或者测试的方法已经过时，或者在某种条件下才能测试该方法（比如需 要一个数据库联接，而在本地测试的时候，数据库并没有连接），那么 使用该标签来标示这个方法。同时，你可以为该标签传递一个String的 参数，来表明为什么会忽略这个测试方法。比如：@lgnore(“该方法还 没有实现”)，在执行的时候，仅会报告该方法没有实现，而不会运行测 试方法。 @RunWith(TestClassRunner.class) 该元数据用来指定Junit用哪一个运行器来执行测试代码。在JUnit中有很 多个Runner，他们负责调用你的测试代码，每一个Runner都有各自的特 殊功能，你要根据需要选择不同的Runner来运行你的测试代码。如果没 有指定，那么系统自动使用默认Runner来运行你的代码。
junit4生成代码用例
junit4生成代码用例JUnit4是一个Java编程语言的单元测试框架，它允许开发人员以一种简单、快捷和可重复的方式编写和执行代码用例。
在本文中，我们将探讨如何使用JUnit4生成代码用例。
JUnit4提供了一套丰富的注解和断言方法，使得编写和运行单元测试变得非常简单。
通过使用JUnit4，开发人员可以快速、准确地验证其代码的功能和正确性，并且可以自动化测试过程，从而减少人工错误和提高代码质量。
要使用JUnit4生成代码用例，我们需要按照以下步骤进行操作：第一步，导入JUnit4依赖。
在项目的构建文件中，我们需要添加JUnit4的依赖项，以便我们可以在项目中使用JUnit4的功能。
具体的依赖项配置取决于项目使用的构建工具，例如Maven或Gradle。
第二步，创建测试类。
在项目的测试代码目录中，我们需要创建一个或多个测试类来编写和组织我们的代码用例。
测试类应该以Test作为后缀，并且应该使用JUnit4的@Test注解来标记测试方法。
例如：```javaimport org.junit.Test;public class MyTestClass {@Testpublic void testMethod() {// 测试方法的代码逻辑}}```在测试方法中，我们可以编写代码来验证我们的代码的功能和正确性。
我们可以使用JUnit4提供的断言方法来断言某些条件是否为真。
例如，我们可以使用`assertEquals`方法来断言预期结果和实际结果是否相等：```javaimport org.junit.Test;import static org.junit.Assert.*;public class MyTestClass {@Testpublic void testMethod() {int result = someMethod();assertEquals(5, result);}}```第三步，运行测试。
junit4osgi的使用
junit4osgi的使用介绍1.简介Junit4OSGi继承于junit的简单测试框架，可以在OSGI运行环境中进行测试。
针对集成测试或是需要在一个OSGI环境中进行单元测试。
结构如下：它分为三个部分：（1）Testsy stem 是真正的应用，被测试的系统（比如：声明式服务部分的测试）。
（2）Tests是包含测试代码的bundle，用来测试被测试的系统。
（3）Framework是测试框架，包括启动测试Runner和执行测试Runtime，在测试声明式服务中我们使用内嵌的loong框架作为测试框架。
2.使用Junit4OSGi进行测试的操作说明：（1）要对被测试的系统进行测试时，Tests必须是一个新建maven工程，测试的代码必须在src/main/java目录下，而不能在被测试部分src\test\java目录下直接写测试代码（比如要测试声明式服务loong-dservice-impl中的服务注册方面，我们不能在它的src\test\java目录下写测试代码）。
（2）所写的测试用例必须继承OSGiTestCase，这个类这个类继承自TestCase，并在它的基础上对OSGI中应用到的一些方法进行了封装，比如getBundle，getContext，getServiceObjects 等，方便在写测试代码时获取bundle或是服务的一些信息。
（3）在测试之前，要对测试代码所在工程的pom文件中进行如下信息的配置：1）添加测试时所需的依赖。
测试时所要用到的bundle通过添加依赖的方式添加到pom 文件中，其中loong-junit4osgi、loong-dservice-metadata为必须添加的依赖。
具体操作如下：<dependency><groupId>org.trustie.loong.modules.loong-dservice</groupId><artifactId>loong-junit4osgi</artifactId><version>0.1.0-SNAPSHOT</version></dependency><dependency><groupId>org.trustie.loong.modules.loong-dservice</groupId><artifactId>loong-dservice-metadata</artifactId><version>0.1.0-SNAPSHOT</version></dependency>2）配置所需的插件，必须配置loong-junit4osgi-plugin插件，如果对声明式服务进行测试时必需配置loong-dservice-plugin插件，具体操作如下：<plugin><groupId>org.trustie.loong.modules.loong-dservice</groupI><artifactId>loong-junit4osgi-plugin</artifactId><version>0.1.0-SNAPSHOT</version><executions><execution><goals><goal>test</goal></goals><configuration><framework>loong</framework></configuration></execution></executions></plugin><plugin><groupId>org.trustie.loong.modules.loong-dservice</groupId><artifactId>loong-dservice-plugin</artifactId><version>0.1.0-SNAPSHOT</version><executions><execution><goals><goal>dservice-bundle</goal></goals></execution></executions></plugin>其中在configuration中配置的框架为测试执行的框架，目前支持loong和Felix这两种。
Junit4入门参考手册.
Junit4入门参考手册.在实际运用中，借助Eclipse或者MyEclipse工具，将Junit 的包导入到工程中即可。
在需要做测试的类上点击鼠标左键，选择new→other→junit test case.即可看到如下界面。
点击Finish后会报错，原因是junit包未和工程关联。
在报错部分点击红叉，然后选中要添加的包即可。
以下部分内容，只对注解及部分参数使用进行说明。
JAVA源码部分（需要测试的类）public class Calculator {private static int result; // 静态变量，用于存储运行结果public void add(int n) {result = result + n;}public void substract(int n) {result = result - 1; //Bug: 正确的应该是 result =result-n }public void multiply(int n){} // 此方法尚未写好public void divide(int n){result = result / n;}public void square(int n){result = n * n;}public void squareRoot(int n) {for (; ;) ; //Bug : 死循环}public void clear(){// 将结果清零result = 0;}public int getResult(){return result;}}基本的测试import static org.junit.Assert.*;import org.junit.Before;import org.junit.Ignore;import org.junit.Test;import org.junit.runner.Description;import org.junit.runner.RunWith;import org.junit.runner.Runner;import org.junit.runner.notification.RunNotifier;/*** @author Administrator**/public class CalculatorTest{//每个测试类只能有一个方法被标注为@BeforeClass 或 @AfterClass，//并且该方法必须是Public和Static的// @Test(timeout = 1000)防止死循环设定测试的超时时间//@Test(expected = ArithmeticException.class)private static Calculator calculator = new Calculator();/*** @throws ng.Exception* before方法是一个复原方法会将各部分测试的值独立开来*/@Beforepublic void setUp() throws Exception {//将结果清0calculator.clear();}/*** Test method for {@link com.my.calculator.Calculator#add(int)}. */@Testpublic void testAdd() {//fail("Not yet implemented");calculator.add(2);calculator.add(3);assertEquals(5, calculator.getResult());}/*** Test method for {@link com.my.calculator.Calculator#substract(int)}. */@Testpublic void testSubstract() {//result作为全局变量经过上面的相加运算后变成了15//减法实为15-1 所以结果应该是14calculator.add(10);calculator.substract(2);assertEquals(9, calculator.getResult());}/*** Test method for {@link com.my.calculator.Calculator#multiply(int)}. * @Ignore忽略*/@Ignore("multiply() Not yet implemented")@Testpublic void testMultiply() {//fail("Not yet implemented");}/*** Test method for {@link com.my.calculator.Calculator#divide(int)}.*/@Testpublic void testDivide() {calculator.add(8);calculator.divide(2);assertEquals(4, calculator.getResult());}}通过参数方式进行测试import static org.junit.Assert.assertEquals;import org.junit.Test;import org.junit.runner.RunWith;import org.junit.runners.Parameterized;import org.junit.runners.Parameterized.Parameters;import java.util.Arrays;import java.util.Collection;/*** 通过参数方式进行测试* @author Administrator**/@RunWith(Parameterized.class)public class SquareTest {private static Calculator calculator = new Calculator(); private int param;private int result;//参数和预想得到的结果通过如下方式定义//以下内容中{2,4} 2为参数 4为结果//位置取决于构造函数的定义@Parameterspublic static Collection data(){return Arrays.asList(new Object[][]{{2, 4},{0, 0},{-3, 9},});}//构造函数，对变量进行初始化public SquareTest(int param, int result){this.param = param;this.result = result;}@Testpublic void square(){//为乘法运算赋予参数calculator.square(param);assertEquals(result, calculator.getResult());}}多个测试单元打包测试import org.junit.runner.RunWith;import org.junit.runners.Suite;/*** @author Administrator*打包测试针对多个测试类的测试就可以采用这种方式*/@RunWith(Suite.class)@Suite.SuiteClasses({CalculatorTest.class,SquareTest.class})public class AllCalculatorTests { }。
自己整理的Junit4学习教程
JUnit4概述JUnit4是JUnit框架有史以来的最大改进，其主要目标便是利用Java5的Annotation特性简化测试用例的编写。
先简单解释一下什么是Annotation，这个单词一般是翻译成元数据。
元数据是什么？元数据就是描述数据的数据。
也就是说，这个东西在Java里面可以用来和public、static等关键字一样来修饰类名、方法名、变量名。
修饰的作用描述这个数据是做什么用的，差不多和public 描述这个数据是公有的一样。
想具体了解可以看Core Java2。
废话不多说了，直接进入正题。
我们先看一下在JUnit 3中我们是怎样写一个单元测试的。
比如下面一个类：public class AddOperation {public int add(int x,int y){return x+y;}}我们要测试add这个方法，我们写单元测试得这么写：import junit.framework.TestCase;import static org.junit.Assert.*;public class AddOperationTest extends TestCase{public void setUp() throws Exception {}public void tearDown() throws Exception {}public void testAdd() {System.out.println(\"add\");int x = 0;int y = 0;AddOperation instance = new AddOperation();int expResult = 0;int result = instance.add(x, y);assertEquals(expResult, result);}}可以看到上面的类使用了JDK5中的静态导入，这个相对来说就很简单，只要在import关键字后面加上static关键字，就可以把后面的类的static的变量和方法导入到这个类中，调用的时候和调用自己的方法没有任何区别。
junit4 mock写法
junit4 mock写法在JUnit4中，我们可以使用Mockito来进行mock对象的写法。
首先，我们需要在项目中引入Mockito的依赖。
在Maven项目中，可以在pom.xml文件中添加以下依赖：xml.<dependency>。
<groupId>org.mockito</groupId>。
<artifactId>mockito-core</artifactId>。
<version>3.11.2</version>。
<scope>test</scope>。
</dependency>。
接下来，我们可以使用Mockito来创建mock对象并设置行为。
假设我们有一个名为UserService的接口，我们想要mock它的行为。
我们可以使用Mockito来创建一个UserService的mock对象，并设置它的行为，例如：java.import static org.mockito.Mockito.;public class UserServiceTest {。
@Test.public void testGetUserName() {。
// 创建mock对象。
UserService userService =mock(UserService.class);// 设置mock对象的行为。
when(userService.getUserName(1)).thenReturn("John");// 调用被测试的方法。
String result = userService.getUserName(1);// 验证行为。
assertEquals("John", result);}。
}。
在上面的例子中，我们使用Mockito的`mock`方法创建了一个UserService的mock对象，然后使用`when`和`thenReturn`方法设置了当调用`getUserName`方法时应该返回的值。
junit4 jmovkit的expectations用法
junit4 jmovkit的expectations用法如何在JUnit4中使用jmockit的expectations功能。
一、引言在软件开发中，单元测试是非常重要的环节。
JUnit是一个常用的Java单元测试框架，通过使用JUnit，我们可以对代码进行自动化测试，确保代码的正确性。
而jmockit是一个强大的Java工具，它可以扩展JUnit，提供了更多的测试功能。
本文将介绍如何在JUnit4中使用jmockit的expectations功能。
expectations功能可以用于对方法调用进行模拟，以便进行更全面的测试。
二、jmockit的安装首先，我们需要将jmockit添加到项目的依赖中。
可以在项目的pom.xml 文件中添加以下依赖：<dependency><groupId>org.jmockit</groupId><artifactId>jmockit</artifactId><version>1.49</version><scope>test</scope></dependency>或者，如果你使用的是Gradle，可以在build.gradle文件中添加以下依赖：testCompile group: 'org.jmockit', name: 'jmockit', version: '1.49'三、使用expectations功能1. 导入所需的类在使用expectations功能前，我们首先需要导入所需的类。
在测试类的顶部，添加以下导入语句：import mockit.*;import org.junit.*;2. 创建测试方法在测试类中创建一个测试方法。
我们将以对一个简单的类进行测试为例。
假设我们有一个名为Calculator的类，其中有一个add方法：public class Calculator {public int add(int a, int b) {return a + b;}}我们将对这个add方法进行测试。
junit4单元测试的注释使用说明
junit4单元测试的注释使用说明junit4单元测试的使用说明右键项目->properties->Java Build Path->Libraies->Add Library->JUnit->next->JUnit 4->Finish左键要进行测试的类（比如 Hourse.java）->junit test case ->选择所要测试的方法->finish->生成一个要测试的类+Test.java的新类(HourseTest.java)assertEquals()对结果的判断,为真是测试方法通过。
junit4单元测试的标签：@BeforeClass 在测试初始化时执行@Before 每次执行@Test方法测试前执行@Ignore 忽略测试@Test 测试方法@After 每次执行@Test方法测试后执行@AfterClass 在所有测试结束后执行每个测试类只能有一个方法被标注为@BeforeClass 或 @AfterClass，并且该方法必须是Public和Static 的。
限时测试@Test(timeout = 1000) timeout 毫秒数测试异常：如果函数应该抛出异常，但是它没抛出，JUnit帮助我们找到这种Bug。
例如，我们写的计算器类有除法功能，如果除数是一个0，那么必然要抛出“除0异常”。
因此，我们很有必要对这些进行测试。
代码如下：@Test(expected = ArithmeticException.class) expected 异常类Runner (运行器)大家有没有想过这个问题，当你把测试代码提交给JUnit框架后，框架如何来运行你的代码呢？答案就是——Runner。
在JUnit中有很多个Runner，他们负责调用你的测试代码，每一个Runner都有各自的特殊功能，你要根据需要选择不同的Runner来运行你的测试代码。
JUnit4快速入门
1.JUnit 4JUnit 4是JUnit框架有史以来的最大改进，其主要目标便是利用Java 5的Annotation特性简化测试用例的编写。
让我们看看如何使用JUnit 4来进行Unit测试。
请注意：本文主要介绍JUnit 4的最新特性和用法，并不会讲解Unit测试的基础。
如果你对JUnit框架还不熟悉，请先参考“Eclipse快速上手指南(2) 使用JUnit测试”一文，学习如何编写JUnit测试。
我们使用的开发环境是Eclipse 3.2，它已经自带了JUnit 4.1，你需要将JUnit 4 Library添加到项目用到的Library中。
另外，必须使用JDK 5.0或更高版本。
要在Eclipse环境之外运行JUnit，需要下载JUnit 4.1，具体请访问。
我们先看一个简单的Math类：package com.javaeedev.junit4;public class Math {public int abs(int value) {return value>=0 ? value : (-value);}public int div(int a, int b) {return a / b;}/*** BUG: if b less than 0!*/public float exp(int a, int b) {float r = 1;for(int i=0; i<b; i++)r = r * a;return r;}}注意exp()方法是有Bug的，如果传入参数2, -1，则期待的返回值应为0.5F，但实际返回值为1.0F。
下面我们看看传统的JUnit的TestCase：public class MathTest extends TestCase {public void setUp() { super.setUp(); }public void tearDown() { super.tearDown(); }public void testAbs() { assertTrue(true); }public void testDiv() {...}public void testExp() {...}}JUnit依赖反射来执行每个以test开头的方法。
JUnit4使用入门指南
JUnit4使用入门指南*以下的内容以Eclipse上的JUnit为准现在的Eclipse中一般都自带了JUnit组件，包含两个版本：JUnit3和JUnit4，由于Junit4引入了java 5.0的注释技术，所以写起测试用例更方便，有些注解方法非常人性化。
简单介绍一下JUnit4的特性：1. JUnit4引入了类范围的setUp() 和tearDown() 方法。
任何用@BeforeClass 注释的方法都将在该类中的测试方法运行之前刚好运行一次，而任何用@AfterClass注释的方法都将在该类中的所有测试都运行之后刚好运行一次。
2. 异常测试：异常测试是Junit4中的最大改进。
Junit3的异常测试是在抛出异常的代码中放入try块，然后在try块的末尾加入一个fail()语句。
例如除法方法测试一个被零除抛出一个ArithmeticException:该方法不仅难看，而且试图挑战代码覆盖工具，因为不管测试是否通过还是失败，总有一些代码不被执行。
在JUni4中，可以编写抛出异常的代码，并使用注释来声明该异常是预期的：如果没有异常抛出或者抛出一个不同的异常，那么测试就将失败。
3. JUnit4添加了两个比较数组的assert() 方法：public static void assertEquals(Object[] expected,Object[]actual)public static void assertEquals(String message, Object[]expected,Object[] actual)这两个方法以最直接的方式比较数组：如果数组长度相同，且每个对应的元素相同，则两个数组相等，否则不相等。
数组为空的情况也作了考虑。
4. JUnit 4引入了注解技术，下面列出常用的几个annotation 介绍a). @Before：初始化方法，在任何一个测试执行之前必须执行的代码;b). @After：释放资源，在任何测试执行之后需要进行的收尾工作;c). @Test：测试方法，表明这是一个测试方法。
junit4 用法
JUnit 4是 Java 中广泛使用的单元测试框架，它使得开发人员可以快速地编写和运行自动化测试以验证代码正确性。
以下简要介绍了JUnit 4的基本用法。
1. 在你的项目中添加 JUnit 4 依赖。
对于 Maven 项目，在 `pom.xml` 文件中加入以下依赖：<dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.13.2</version><scope>test</scope></dependency>对于 Gradle 项目，在 `build.gradle` 文件中加入以下依赖：dependencies {testImplementation 'junit:junit:4.13.2'}1. 创建一个测试类。
选择一个要测试的类并创建一个新的测试类。
通常，测试类的命名约定是将 "Test" 附加到所测试类的名称。
例如，要为名为 `Calculator` 的类编写测试，创建一个名为 `CalculatorTest` 的新类。
1. 导入JUnit 4 注解和其他依赖。
在您的测试类中，导入以下依赖项：import org.junit.Test;import static org.junit.Assert.*;1. 编写测试方法。
在您的测试类中，使用 `@Test` 注解来标记测试方法。
测试方法应该是公共的、无参数的，并返回 `void`。
通过使用 `Assert` 类中的断言方法，如`assertEquals`，来验证代码行为。
例如，在`CalculatorTest` 类中，可以添加以下方法来测试`Calculator` 类的`add` 方法：@Testpublic void testAdd() {Calculator calculator = new Calculator();int result = calculator.add(5, 3);assertEquals("Sum of 5 and 3 should be 8", 8, result);}1. 运行测试。
junit4使用说明
测试任何可能的错误。
单元测试不是用来证明您是对的，而是为了证明您没有错。
2、单元测试代码和被测试代码使用一样的包，不同的目录。
－－junit4.0使用注意说明；3、测试方法必须按照规范书写1. 测试方法必须使用注解修饰。
2. 测试方法必须使用 public void 修饰，而且不能带有任何参数。
@Test public void wordFormat4DBegin(){String target = "EmployeeInfo";String result = WordDealUtil.wordFormat4DB(target);assertEquals("employee_info", result);}4、同一测试类中的所有测试方法都可以共用它来初始化 Fixture 和注销 Fixture。
和编写 JUnit 测试方法一样，公共 Fixture 的设置也很简单，您只需要：1. 使用注解 org,junit.Before 修饰用于初始化 Fixture 的方法。
2. 使用注解修饰用于注销 Fixture 的方法。
3. 保证这两种方法都使用 public void 修饰，而且不能带有任何参数。
//初始化Fixture方法@Before public void init(){……}//注销Fixture方法@After public void destroy(){……}引入了类级别的 Fixture 设置方法，编写规范如下：1. 使用注解 org,junit.BeforeClass 修饰用于初始化 Fixture 的方法。
2. 使用注解修饰用于注销 Fixture 的方法。
3. 保证这两种方法都使用 public static void 修饰，而且不能带有任何参数//类级别Fixture初始化方法@BeforeClass public static void dbInit(){……}//类级别Fixture注销方法@AfterClass public static void dbClose(){……}类级别的 Fixture 仅会在测试类中所有测试方法执行之前执行初始化，并在全部测试方法测试完毕之后执行注销方法。
Junit4测试中使用定时任务操作
Junit4测试中使⽤定时任务操作难度：测试中执⾏线程操作1package com.hfepc.job.dataCollection.test;23import java.util.Date;4import java.util.List;5import java.util.Map;6import java.util.Timer;7import java.util.TimerTask;8import java.util.concurrent.CountDownLatch;910import javax.annotation.Resource;1112import org.junit.Test;13import org.junit.runner.RunWith;14import org.pentaho.di.job.Job;15import org.slf4j.Logger;16import org.slf4j.LoggerFactory;17import org.springframework.test.context.ActiveProfiles;18import org.springframework.test.context.ContextConfiguration;19import org.springframework.test.context.transaction.TransactionConfiguration;20import org.springframework.transaction.annotation.Transactional;2122import com.hfepc.service.dataCollection.IDataCollectionService;23import com.hfepc.service.zkinsp.MySpringJUnit4ClassRunner;2425 @SuppressWarnings("unused")26 @RunWith(MySpringJUnit4ClassRunner.class)27 @ContextConfiguration(locations = { "classpath*:spring-context.xml",28 "classpath*:spring-servlet.xml", "classpath*:cxf-client.xml" })29 @ActiveProfiles("development")30 @Transactional31 @TransactionConfiguration(transactionManager = "transactionManager", defaultRollback = false)32public class DataCollectionTest extends Job {3334private final Logger log = LoggerFactory35 .getLogger(DataCollectionTest.class);3637 @Resource(name = "IDataCollectionService")38private IDataCollectionService IDataCollectionService;3940private final int i = 3;41/*42 * 线程计数器43 * 将线程数量初始化44 * 每执⾏完成⼀条线程，调⽤countDown()使计数器减145 * 主线程调⽤⽅法await()使其等待，当计数器为0时才被执⾏46*/47private final CountDownLatch latch = new CountDownLatch(i);4849 @Test50public void createTest() {51 Timer timer;52 timer = new Timer();53 timer.schedule(new TimerTaskTest03(), 0, 60000);54//三个参数55//第⼀个执⾏内容：内容是定时任务的执⾏内容，通过实现抽象类来完成这个动作56//第⼆个参数内容：是在第多少时间之后开始执⾏定时任务内容，该参数不能⼩于057//第三个参数内容：是在两个任务之间的执⾏时间间隔，该参数不能⼩于等于058try {59 latch.await(); // 主线程等待60 } catch (InterruptedException e) {61 e.printStackTrace();62 }7091private class TimerTaskTest03 extends TimerTask {9293 @Override94public void run() {95 Date date1 = new Date(this.scheduledExecutionTime());96 String date = DateUtils.format(DateUtils.getCurDate(),97 "yyyy/MM/dd");99 log.error("本次执⾏该线程的时间为：" + date1);100 ("时间：" + date);101 String sql = "SELECT A.[Date] AS 'date_sta',A.barcode1 AS 'barcode1_sta',A.barcode2 AS 'barcode2_sta',A.HeightNum1Range AS 'HeightNum1Range',A.HeightNum2Range AS 'HeightNum2Range',A.HeightNum3Range AS 'HeightNu 102 + date + "%'";103 List<Map<String, Object>> rows = IDataCollectionService104 .readSQLData(sql);105 ("返回标签：" + rows.size());106 ("返回标签：" + (String) rows.get(0).get("barcode2_sta"));108 }109 }110111 }。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
JUnit和单元测试入门简介1.几个相关的概念白盒测试——把测试对象看作一个打开的盒子，程序内部的逻辑结构和其他信息对测试人员是公开的。
回归测试——软件或环境的修复或更正后的“再测试”，自动测试工具对这类测试尤其有用。
单元测试——是最小粒度的测试，以测试某个功能或代码块。
一般由程序员来做，因为它需要知道内部程序设计和编码的细节。
JUnit ——是一个开发源代码的Java测试框架，用于编写和运行可重复的测试。
他是用于单元测试框架体系xUnit的一个实例（用于java语言）。
主要用于白盒测试，回归测试。
图1 项目测试中单元测试是最小粒度的测试2.单元测试概述1)单元测试的好处A、提高开发速度——测试是以自动化方式执行的，提升了测试代码的执行效率。
B、提高软件代码质量——它使用小版本发布至集成，便于实现人员除错。
同时引入重构概念，让代码更干净和富有弹性。
C、提升系统的可信赖度——它是回归测试的一种。
支持修复或更正后的“再测试”，可确保代码的正确性。
单元测试不仅仅是保证代码在方法级别的正确性，它还能改进设计，易于对代码重构。
经验证明，凡是容易编写单元测试的代码，往往是优秀的设计和松耦合的组件，凡是难于编写单元测试的代码，往往是设计不佳和耦合度高的系统，因此，编写单元测试不仅仅是掌握单元测试框架的用法，更重要的是在编写单元测试的过程中发现设计缺陷，改进系统结构，从而实现良好的可扩展性。
2)单元测试的针对对象A、面向过程的软件开发针对过程。
B、面向对象的软件开发针对对象。
C、可以做类测试，功能测试，接口测试（最常用于测试类中的方法）。
3)单元测试工具和框架目前的最流行的单元测试工具是xUnit系列框架，常用的根据语言不同分为JUnit（java），CppUnit（C++），DUnit （Delphi ），NUnit（.net），PhpUnit（Php ）等等。
该测试框架的第一个和最杰出的应用就是由Erich Gamma （《设计模式》的作者）和Kent Beck（XP（Extreme Programming）的创始人）提供的开放源代码的JUnit。
3.单元测试规范本项目的单元测试使用Junit4进行测试，Eclipse内置了Junit4的支持。
1)测试类命名在项目的DAO与service层的实现类都必须编写测试用例,action由于struts2.0支持测试，所以也应该测试：A、测试用例命名规则为：类名+ Test。
（junit4支持非这样的命名方式，但是为了统一管理，还是采用这样的方式命名）B、建立一个和src平行的test包，所有测试用例都放在相应的包内，便于统一管理，合成测试套件。
C、同一个包的测试用例，合成一个测试套件。
D、整个工程的测试套件，合成一个统一的测试套件。
2)测试用例的编写A、测试方式都是test开头的方法(testXXXX)，JUnit按照在测试用例中的顺序执行。
测试方法可以和被测试的方法一一对应，测试方法也可以包含多个被测试的方法。
B、测试方法中，使用断言(assertXXX和fail，详细资料请查阅JUnit文档)来进行测试结果判断，也可以辅以文字打印说明，如果测试程序抛出异常，则显示为错误，如果断言失败，则显示故障。
C、测试用例必须覆盖被测试类、方法的所有功能，包括正常情况、异常情况和发生错误的情况都必须覆盖，才能保证测试的完整性。
3)测试数据的准备为了防止数据库的更改对测试结果的影响，测试数据由统一的sql脚本来创建，测试前执行一下脚本创建数据。
也可以使用数据回滚的方式进行与数据相关的测试。
4)实体层的测试由于本次项目的Entity model由之前的贫血模型改为到充血模型，所以对于Entity 的测试不能够再忽略，对于Entity自身的除set/get以为的方法都应该进行单元测试。
5)DAO层的测试每一个DAO类都必须编写测试用例，对DAO的每一个公开方法进行测试，测试用例必须使用有代表性的测试代码，覆盖的所有可能的输入和输出情况，包括创建，更改，删除对象以及输入错误数据等测试。
6)Service层的测试Service层的测试必须测试Service对象是否满足功能要求，事务完整性等功能。
7)控制器层的测试控制器层的测试必须测试Controller对象的传参和业务处理是否正确。
8)Struts层和浏览器层的测试待定4.单元测试流程图2单元测试流程图5.Junit入门简介1)JUnit的好处A、可以使测试代码与产品代码分开。
B、针对某一个类的测试代码通过较少的改动便可以应用于另一个类的测试。
C、易于集成到测试人员的构建过程中，JUnit和Ant的结合可以实施增量开发。
D、JUnit是公开源代码的，可以进行二次开发。
C、可以方便地对JUnit进行扩展。
2)JUnit单元测试编写原则A、是简化测试的编写，这种简化包括测试框架的学习和实际测试单元的编写。
B、是使测试单元保持持久性。
C、是可以利用既有的测试来编写相关的测试。
3)JUnit的特征A、使用断言方法判断期望值和实际值差异，返回Boolean值。
图3 Junit常用断言方法B、测试驱动设备使用共同的初始化变量或者实例。
C、测试包结构便于组织和集成运行。
D、支持图型交互模式和文本交互模式。
4)JUnit框架组成图4 Junit框架图A、对测试目标进行测试的方法与过程集合，可称为测试用例(TestCase)。
B、测试用例的集合，可容纳多个测试用例(TestCase)，将其称作测试包(TestSuite)。
C、测试结果的描述与记录。
(TestResult) 。
D、测试过程中的事件监听者(TestListener)。
E、每一个测试方法所发生的与预期不一致状况的描述，称其测试失败元素(TestFailure)F、JUnit Framework中的出错异常（AssertionFailedError）。
G、JUnit框架是一个典型的Composite模式：TestSuite可以容纳任何派生自Test的对象；当调用TestSuite对象的run()方法是，会遍历自己容纳的对象，逐个调用它们的run()方法。
5)JUnit4和JUnit3.X的比较图5 Junit4和Junit3.x的比较6.Eclipse中JUnit的用法这里不详细介绍JUnit的用法，详细的用法自己找文档进行学习。
下面举一个简单的例子说明Eclipse中JUnit的用法：我们假设我们要写一个整数除法的类，并且给他写测试用例：1)建立Math类2)建立测试用例选中需要建立测试用例的包，选择new->other。
这里main方法不需要，我们可以直接用IDE进行测试。
setUp()方法在测试方法前调用，一般用来做测试准备工作。
tearDown()方法在测试方法后调用，一般作测试的清理工作。
setUpBeforeClass()方法在整个类初始化之后调用，一般用来做测试准备工作。
tearDownAfterClass()方法在整个类结束之前调用，一般作测试的清理工作。
constructor()为是否包含构造方法。
选择下一步：选择需要测试的方法，完成。
系统生成以下代码：说明：@BeforeClass标签注释的方法用于在整个类测试过程的初始化后调用一次，@AfterClass标签注释的方法则是整个测试类结束之前调用一次。
这2个标间的搭配可以避免使用@Before、@After标签组合在每个测试方法前后都调用的弊端，减少系统开销，提高系统测试速度。
(不过对环境独立性的测试还是应当使用@Before、@After来完成) @Test标签用来标注待测试的方法，按照类中声明的顺序执行。
我们在testDivide方法加入测试代码，分别测试三种情况：a.完全正确也没有可能出错的数据，如：9除3 结果必须等于3b.可能有问题的边缘数据，如：10除3 结果也必须等于3c.错误的数据，如：10除0 必须抛出异常忽略testMultiple方法代码如下：图6 常用断言方法说明说明:Junit4为测试方法增加了判断异常的方式，避免了以前还要通过try/catch块捕捉异常再抛出的复杂方式，简单的这样声明“@Test(expected=ArithmeticException.class)”Junit4就会检查此方法是否抛出ArithmeticException异常，如果抛出则测试通过，没抛出则测试不通过（@Test标签还有一些其他参数，例如超时测试，但是由于并不能准确反应实际时间，所以应用较少）@Ignore标签会告诉Junit4忽略它所标注的方法，例如数据库不可用时可以用此标注标注一些测试数据库连接的方法来避免测试失败。
3)运行测试或者系统会打开JUnit透视图，如果测试全部通过，则显示如下，颜色条为绿色：我们将assertEquals(3,Math.divide(9,3));改成assertEquals(2,Math.divide(9,3));则显示如下，颜色条为红色：可以对错误或者故障的地方进行追踪。
4)创建测试套件测试套件可以将多个测试用例合在一起测试，将相关的测试用例合成一个测试套件，在做一个修改后，只需要运行测试套件就可以，不需要运行每一个测试用例。
Junit4没有采用以前的套件测试方法，同样使用annotation的方式来进行。
简单在你所要构建测试套件的包里创建一个文件，一般以包名+4Suite下面我在上面的测试包中复制一下之前的测试类并且一个改名字叫做MathTestAnother，新建一个class类叫做Uitl4Suite，代码如下：Array说明：通过@RunWith和@SuiteClasses标签来注释一个空的包含无参数构造函数的类来作为套件类，将需要组成套件运行的类加到@SuiteClasses的属性中即可。
运行正确后的结构如图：可以看到运行套件类的结果是2个测试类都进行了测试。
5) 参数测试修改 testMultiple编写参数方法：说明：需要使用@Parameters 标签注解一个静态的返回集合对象的方法增加成员变量和构造函数：说明：注意类型要匹配好，不要搞错了最后在给测试类增加如下注释：OK,大功告成。
测试看看，结果如下：成功运行了9次。
7. 一些使用JUnit 经验a. 不要用TestCase 的构造函数初始化，而要用setUp()和tearDown()方法。
b. 不要依赖或假定测试运行的顺序，因为JUnit 利用Vector 保存测试方法。
所以不同的平台会按不同的顺序从Vector 中取出测试方法。
c. 避免编写有副作用的TestCase 。
例如：如果随后的测试依赖于某些特定的交易数据，就不要提交交易数据。
简单的回滚就可以了。