JUnit及其相关的单元测试技术
JUnit及其相关的单元测试技术
作者：david 来源：javaeye
在实际的工作中，很多项目都没有写单元测试用例。写单元测试用例常常是程序员十分厌倦的一个项目活动，很多人觉得没有必要、浪费时间。所有这些都是因为没有认识到测试的重要性：测试能够使我们尽量早的发现程序的bug，一个bug被隐藏的时间越长，修复这个bug的代价就越大。在《快速软件开发》一书中已引用了大量的研究数据指出：最后才修改一个bug的代价是在bug产生时修改它的代价的10倍。在现代软件开发过程中，不管是xp还是rup
都是十分重视单元测试，已经把单元测试作为贯穿整个开发周期的一项重要的开发活动。单元测试如此重要，那么怎样写好单元测试用例呢?这就需要了解
Junit及其相关的测试工具了。
1. Junit简介：
1.1 内容摘要
Junit是由 Erich Gamma 和 Kent Beck 编写的一个回归测试框架(regression
testing framework)，供Java开发人员编写单元测试之用。Junit测试是程序员测试，即所谓白盒测试。下面我们以一个简单的例子来介绍如何使用
Junit4同Junit3编写测试用例：
先写个简单的被测试类：
public Class XXXX{
public String hello(){
return &hello&;
对于这个类的用junit3编写测试用例：
import junit.framework.TestC
public Class XXXXTest extends TestCase{
public void testHello(){
asssertEqual(new XXXX().Hello(),&hello&);
用junit4编写测试用例：
import static org.junit.framework.assertE
import org.junit.T
public Class XXXXTest{
public void helloTest(){
asssertEqual(new XXXX().Hello(),&hello&);
从上面例子我们对Junit3和Junit4有了一个初步的印象，下面我们重点介绍Junit4与Junit3的主要区别。
1.2 Junit4与Junit3的主要区别
1.2.1 Junit4引入了java 5.0的注释技术：
这两个版本最大的区别在JUnit3.x中测试必须继承 TestCase，并且每个方法名必须以test开头。比如:testMethod1()而在JUnit4.x中不必继承TestCase，采用了注解的方式。只要在测试的方法上加上注解@Test即可，从而不必再遵循以前的一些显式约定和反射定位测试;在JUnit4.x中如果继承了TestCase，注解就不起作用了。并且有很重要的一点就是在JUnit4.x中继承了TestCase后，在OutLine视图中测试单个方法时，结果整个类都run
了。还有一点就是，在3.x中需要实现setUp和tearDown方法，而在4.x中无需这样，可以自定义需要在测试前和测试后的方法，在方法前加上
@before，@after就可以了。所以在JUnit4.x不必继承TestCase用注解即可对单个方法进行测试。
1.2.2 JUnit4引入了一个JUnit3中没有的新特性――类范围的 setUp() 和tearDown()
任何用 @BeforeClass 注释的方法都将在该类中的测试方法运行之前刚好运行一次，而任何用 @AfterClass
注释的方法都将在该类中的所有测试都运行之后刚好运行一次。
1.2.3 异常测试：
异常测试是Junit4中的最大改进。Junit3的异常测试是在抛出异常的代码中放入try块，然后在try块的末尾加入一个fail()语句。
例如该方法测试一个被零除抛出一个ArithmeticException:
该方法不仅难看，而且试图挑战代码覆盖工具，因为不管测试是否通过还是失败，总有一些代码不被执行。在JUni4中，可以编写抛出异常的代码，并使用注释来声明该异常是预期的：
如果没有异常抛出或者抛出一个不同的异常，那么测试就将失败。
1.2.4 JUnit4添加了两个比较数组的assert() 方法：
public static void assertEquals(Object[] expected,
Object[] actual)
public static void assertEquals(String message, Object[]
expected, Object[] actual)
这两个方法以最直接的方式比较数组：如果数组长度相同，且每个对应的元素相同，则两个数组相等，否则不相等。数组为空的情况也作了考虑。
1.3 JUnit 4 常用的几个annotation 介绍
★ @Before：初始化方法，在任何一个测试执行之前必须执行的代码;
★ @After：释放资源，在任何测试执行之后需要进行的收尾工作;
★ @Test：测试方法，表明这是一个测试方法。对于方法的声明也有如下要求：名字可以随便取，没有任何限制，但是返回值必须为void，而且不能有任何参数。如果违反这些规定，会在运行时抛出一个异常。至于方法内该写些什么，那就要看你需要测试些什么了;在这里可以测试期望异常和超时时间，如
@Test(timeout = 100)，我们给测试函数设定一个执行时间，超过了这个时间(100毫秒)，它们就会被系统强行终止，并且系统还会向你汇报该函数结束的原因是因为超时，这样你就可以发现这些Bug了。
★ @Ignore：忽略的测试方法，标注的含义就是“某些方法尚未完成，暂不参与此次测试”;这样的话测试结果就会提示你有几个测试被忽略，而不是失败。一旦你完成了相应函数，只需要把@Ignore标注删去，就可以进行正常的测试。
★ @BeforeClass：针对所有测试，只执行一次，且必须为
★ @AfterClass：针对所有测试，只执行一次，且必须为
所以一个Junit 4 的单元测试用例执行顺序为：@BeforeClass C& @Before
C& @Test C& @After C& @AfterC每一个测试方法的调用顺序为：@Before
C& @Test C& @After。
如下面例子：
import static org.junit.Assert.*; import org.junit.Aimport
org.junit.AfterCimport org.junit.Bimport
org.junit.BeforeCimport org.junit.Iimport
org.junit.T public class JUnit4Test {
public void before() {
System.out.println(&@Before&);
public void test() {
System.out.println(&@Test&);
assertEquals(5 + 5, 10);
public void testIgnore() {
System.out.println(&@Ignore&);
@Test(timeout = 50)
public void testTimeout() {
System.out.println(&@Test(timeout = 50)&);
assertEquals(5 + 5, 10);
@Test(expected = ArithmeticException.class)
public void testExpected() {
System.out.println(&@Test(expected = Exception.class)&);
throw new ArithmeticException();
public void after() {
System.out.println(&@After&);
@BeforeClass
public static void beforeClass() {
System.out.println(&@BeforeClass&);
@AfterClass
public static void afterClass() {
System.out.println(&@AfterClass&);
右击测试类，选择Junit运行……
输出结果如下：
@BeforeClass
@Test(timeout = 50)
@Test(expected = Exception.class)
@AfterClass
在eclipse中junit运行结果视图中可以看到testIgnore是被忽略的，没有执行;还有其中有一个方法运行报错。
2. 使用HttpUnit进行Web应用测试：
上面我们介绍Junit是对应用程序代码的片段做测试，那么如何对Web应用进行测试呢?这就需要我们了解HttpUnit了。
2.1 什么是HttpUnit：
HttpUnit是SourceForge下面的一个开源项目，它是基于Junit的一个测试框架，主要关注于测试Web应用，解决使用
Junit框架无法对远程Web内容进行测试的弊端。HttpUnit通过模拟浏览器的行为，处理页面框架(frames)，cookies页面跳转(redirects)等。通过HttpUnit提供的功能，你可以和服务器端进行信息交互，将返回的网页内容作为普通文本、XML
Dom对象或者是作为链接、页面框架、图像、表单、表格等的集合进行处理。HttpUnit还提供了一个模拟Servlet容器，让你可以不需要发布
Servlet，就可以对Servlet的内部代码进行测试。
2.2 如何使用HttpUnit:
到HttpUnit的主页http://httpunit.sourceforge.net下载最新的包文件，解压后将%httpunit_home%/lib/*.
%httpunit_home%/jars/*.jar加入到Eclipse工程的Java build Path变量中。
2.3 如何使用HttpUnit和Junit编写Web应用的测试用例：
在HttpUnit框架中，WebConversation类是最重要的类，它用于模拟浏览器的行为，WebRequest类用于模仿客户请求，通过它可以向服务器发送信息，WebResponse类用于模拟浏览器获取服务器端的响应信息。
下面我们用HttpUnit编写一个测试用例，测试在百度里面搜索“诚毅软件”，搜索结果里面有没有包含“我们努力使事情更简单”的内容。
在Eclipse中运行结果中可见在百度里面搜索“诚毅软件”，搜索结果里面有包含“我们努力使事情更简单”的内容。
3. 使用EclEmma进行覆盖测试
3.1 什么是覆盖测试
上面我们介绍了如何用junit和HttpUnit编写单元测试用例，那如何确定我们编写的单元测试用例能不能完整地测试我们的代码呢?这就需要看看我们的单元测试用例对我们代码的覆盖测试率了。覆盖测试是衡量测试质量的一个重要指标。在对一个软件产品进行了单元测试、组装测试、集成测试以及接受测试等繁多的测试之后，我们能不能就此对软件的质量产生一定的信心呢?这就需要我们对测试的质量进行考察。如果测试仅覆盖了代码的一小部分，那么不管我们写了多少测试用例，我们也不能相信软件质量是有保证的。相反，如果测试覆盖到了软件的绝大部分代码，我们就能对软件的质量有一个合理的信心。
3.2 如何使用EclEmma进行覆盖测试
EclEmm是一个帮助开发人员考察测试覆盖率的优秀的 Eclipse 开源插件， EclEmma为用户提供图形界面以及对集成开发环境的支持，安装
EclEmma 插件的过程和大部分 Eclipse 插件相同，我们既可以通过 Eclipse 标准的 Update
机制来远程安装 EclEmma 插件，也可以从站点http://sourceforge.net/projects/eclemma/下载
zip 文件并解压到 eclipse 所在的目录中。安装完成并重新启动 Eclipse 之后，工具栏上应该出现一个新的按钮。
下面我们用EclEmma运行我们上面Junit的例子，看看测试覆盖率是多少，点击这个新的按钮，运行Junit
可以看到EclEmma 用不同的色彩标示了源代码的测试情况。其中，绿色的行表示该行代码被完整的执行，红色部分表示该行代码根本没有被执行，而黄色的行表明该行代码部分被执行。可见我们的测试用例对逻辑类LogicClass的测试达到了100%。
有时候想一次运行中覆盖所有的代码通常比较困难，如果能把多次测试的覆盖数据综合起来进行察看，那么我们就能更方便地掌握多次测试的测试效果。EclEmma
提供了这样的功能。通过 Coverage 视图的工具按钮来结合多次覆盖测试的结果。在弹出框中点击OK按钮，就可以看到多次测试对代码的测试覆盖率了。
4. 如何使用Ant批量运行junit单元测试用例并生成测试报告
我们编写完单元测试用例以后，我们就可以运行单元测试用例来检查我们的代码有没有bug，以后如果代码发生改变，我们就可以运行单元测试用例来检查我们的修改有没有带进新的bug。但如果每个测试用例都要手工运行那就比较繁琐了，下面我们介绍如何使用ant进行批量测试和生成测试报告。
4.1 什么是ant：
Ant是一个类似make的、用java实现的构建工具，项目的构建、包装和发布过程中几乎每一件事都可以由Ant的任务来处理。Ant凭借出色的易用性、平台无关性以及对项目自动测试和自动部署的支持，已成为众多项目构建过程中不可或缺的独立工具，并已经成为事实上的标准。
4.2 如何使用ant批量运行junit测试用例并生成测试报告：
随着项目的进展和项目的规模在不断的膨胀，为了保证项目的质量，有计划的执行全面的单元测试是非常有必要的。利用Ant集成Junit可以通过配置批量运行所指定的测试用例并生成测试报告，可以让开发人员及时发现代码中所隐藏的bug，及时进行修改，极大的提高工作效率，从某种意义上做到持续集成。
Ant 内置了对 JUnit 的支持，它提供了两个 Task：junit 和 junitreport，分别用于执行
JUnit 单元测试和生成测试结果报告。使用这两个 Task 编写构建脚本，可以很简单的完成批量运行单元测试并生成测试报告的任务。
首先把junit的包加载到ant的编译目录下：打开 Eclipse 的window菜单，选择reference选项界面，选择
Ant -& Runtime 选项，将 Junit 4.* 的 JAR 文件添加到 Classpath
Tab 页中的 Global Entries 设置项里。还有记得检查一下 Ant Home Entries
设置项中的 Ant 版本是否在 1.7.0 之上，如果不是请替换为最新版本的 Ant JAR 文件，Eclipse3.2内置的ant版本是1.65，eclipse3.4内置的ant版本是1.70，所以如果我们使用的junit版本是4以上的，最好用eclipse3.4。
接下来是编写 Ant 构建脚本 build.xml。虽然这个过程稍嫌繁琐，但这是一件一劳永逸的事情。
把此build.xml文件放到工程的根目录下，修改test属性的值为我们要运行的单元测试用例的包路径名，如果为空默认运行工程所有的单元测试，在Eclipse下打开此build.xml文件，在右边的outline视图下右击ant的junit任务，选择Run
As Ant Build，就可以运行此ant文件的junit任务，然后我们就可以在Eclipse的控制台上看到Ant任务的执行信息，任务执行完后，就会在工程的report目录下的“framework-${DSTAMP}-${TSTAMP}”临时文件夹下生成html类型的测试报告。
火龙果软件/UML软件工程组织致力于提高您的软件工程实践能力，我们不断地吸取业界的宝贵经验，向您提供经过数百家企业验证的有效的工程技术实践经验，同时关注最新的理论进展，帮助您“领跑您所在行业的软件世界”。博客分类：
___________________________________________________________________________
Unit Test是由程序员本身来编写的。
以下介绍Junit单元测试框架：官网地址www.junit.org
JUnit是由 Erich Gamma 和 Kent Beck 编写的一个回归测试框架（regression testing framework）。Junit测试是程序员测试，即所谓白盒测试，因为程序员知道被测试的软件如何（How）完成功能和完成什么样（What）的功能。
___________________________________________________________________________
Junit3.x中使用包junit.framework.*
1.&&&&&& 必须继承TestCase类
public class CalculatorTest extends TestCase {
&&& private C
&&& public CalculatorTest() {
&&& public CalculatorTest(String name) {
&&&&&&& super(name);
&&& public void setUp() {
&&&&&&& System.out.println("...........setUp..............");
&&&&&&& cal = new Calculator();
&&& public void testAdd() {
&&&&&&& int result = cal.add(1, 2);
&&&&&&& Assert.assertEquals("计算添加失败", 3, result);
&&&&&&&& }
public void tearDown() {
&&&&&&& System.out.println("........tearDown........");
&&&&&&&& }
2.&&&&&& 测试用例（Test Case）是单元测试的一个非常重要的方面。
3.&&&&&& 单元测试主要是用来判断程序的执行结果与自己期望的结果是否一致。
4.&&&&&& 在Junit3.x中，测试方法规则定义如下：
1)&&&&& public
2)&&&&& void
3)&&&&& 无参数的
4)&&&&& 测试方法名以test开头
5.&&&&&& Test Case之间一定要保持完全的独立性，不允许出现任何的依赖关系。
6.&&&&&& 我们不能依赖于测试方法的执行顺序。
7.&&&&&& 关于setUp与tearDown方法的执行顺序：
2） testAdd
3） tearDown
8.&&&&&& Junit两种类型错误，Failure 和 Error
Failure：指预期结果与实际结果不同，例如当你使用assertEquals或者assertXXX方法断言失败时，或者调用fail方法，就会报出Failure，这时要检查测试方法逻辑设计是否有误。
&&& public void testDevide() {
&&&&&&& System.out.println(".........testDevide()........");
&&&&&&& int expected = 0;
&&&&&&& int actual = 0;
&&&&&&& try {
&&&&&&&&&&& actual = cal.devide(1, 3);
&&&&&&& } catch (Exception e) {
&&&&&&&&&&& Assert.fail("测试失败"); //不应该执行这段.
&&&&&&& Assert.assertEquals(expected, actual);
&&&&&&&& Error：指程序在断言执行之前，程序就因为某种错误而引发异常，导致程序终止，例如测试方法中因抛出某个异常，使得测试方法无法正确执行到断言就结束，这时你要检查测试的方法是否有未考虑到的情况而引起流程突然中断。
&&&&&&&&&&&&&& 也就是说代码中抛出了异常等影响代码正常执行的情况，比如ArrayIndexOfBoundsException、NullPointException，也可能是磁盘已满、网络中断等等外部环境失败所带来的影响。
首先处理Error，然后在处理Failure.
9.&&&&&& 运行测试用例
1)&&&&& IDE中，如Eclipse工具已经内置了Junit，所以可以直接在测试类中鼠标右键Run--Junit Test运行。
2)&&&&& 使用junit.textui.TestRunner类运行测试类.
public static void main(String[] args) {
&&&&&&& junit.textui.TestRunner.run(MyStackTest.class);
&&&&&&& junit.textui.TestRunner.run(new CalculatorTest("testAdd"));
3)&&&&& 使用TestSuite
a)&&&&&&& 一次可以运行多个测试类进行测试
public class TestAll {
&&& public static Test suite() {
&&&&&&& TestSuite suite = new TestSuite();
&&&&&&& suite.addTestSuite(OOOTest.class);
&&&&&&& suite.addTestSuite(XXXTest.class);
&&&&&&& suite.addTestSuite(YYYTest.class);
&&&&&&&
&&& }
&&& public static void main(String[] args) {
&&&&&&& TestRunner.run(suite());
&&& }
}
b)&&&&&&& 通过IDE自动发现suite()方法，必须继承TestCase
public class TestAll extends TestCase {
&&& public static Test suite() {
&&&&&&& TestSuite suite = new TestSuite();
&&&&&&& suite.addTestSuite(OOOTest.class);
&&&&&&& suite.addTestSuite(XXXTest.class);
&&&&&&& suite.addTestSuite(YYYTest.class);
&&&&&&&
&&& }
}
c)&& 组合模式，组合方式多元化
public static Test suite() {
&&&&&&& TestSuite suite = new TestSuite();
&&&&&&& suite.addTest(new XXXTest("testABC"));& // 执行testABC()方法
&&&&&&& suite.addTest(YYYTest.suite()); // suite() 传回TestSuite实例
&&&&&&& suite.addTestSuite(OOOTest.class);//自动查找OOOTest类中testXXX方法
&&&&&&&
&&& }
10.测试之前是什么状态，在测试执行完成后就应该是什么状态，而不应该由于测试执行的原因到导致了状态发生了变化。
___________________________________________________________________________
Junit4.x开始支持Annotation注解技术，在编写测试用例时简化不少动作.
Junit4.x中使用的包org.junit.*
Junit4.x是兼容以前版本
Eclipse中自带了Junit4，版本为junit4.3.1. BC-EC工程中使用的版本为Junit4.4，目前最新版本4.11
1. 无需继承TestCase类，所有被@Test注解所修饰的public，void，无参数的方法都是测试用例，Junit自动查找注解方法并执行测试。
&&& public void testAdd() {
&&&&&&& int result = cal.add(1, 2);
&&&&&&& Assert.assertEquals("计算添加失败", 3, result);
2. 虽然Junit4.x中测试类中的方法名称可以随便取，但是建议跟junit3.x中测试类方法命名约定一致，统一方法名以test开头。
3. 使用@Before注解所修饰的方法同junit3.x中的setUp方法的功能，使用@After注解所修改的方法同junit3.x测试类中的tearDown方法的功能。 @Before和@After可以在多次指定.
&&& public void init() {
&&&&&&& System.out.println("...........setUp..............");
&&&&&&& cal = new Calculator();
&&& public void destroy() {
&&&&&&& System.out.println("........tearDown........");
4. 通过@BeforeClass和@AfterClass注解标注public，static，void，无参数的类方法。在所有测试方法执行之前和之后执行。
@BeforeClass
public static void setUpBeforeClass() {
@AfterClass
public static void tearDownAfterClass() {
5. 使用@Ignore注解所修饰的方法（可以表示尚未编写完该用例或者想禁用该用例），运行器会忽略该方法的测试；当修饰类时，运行器会忽略掉所有测试方法。
&&& @Ignore("尚未完成")
&&& public void testMultiply() {
Eclipse中Junit执行结果中会提示如下：
6. 预期异常：
也可以使用在junit3.x中提到的fail()来测试预期抛出异常的情况。
public void testDevideByZero() {
&&&&&&& Throwable tx =
&&&&&&& try {
&&&&&&&&&&& cal.devide(1, 0);
&&&&&&&&&&& Assert.fail("应该按预期抛出异常，测试失败");
&&&&&&& } catch (Exception e) {
&&&&&&&&&&& tx =
&&&&&&& Assert.assertNotNull(tx.getMessage());
&&&&&&& Assert.assertEquals(ArithmeticException.class, tx.getClass());
&&&&&&& Assert.assertEquals("除数不能为0！", tx.getMessage());
junit4中使用Test中的expected属性达到相同的功能，代码量小很多.
&&& @Test(expected = ArithmeticException.class)
public void testDevideByZero() throws Exception {
&&&&&&& cal.devide(1, 0); // 应该抛出异常
7. 使用@Test(timeout = 2000) 注解预期某些操作应该在指定时间内完成，否则测试失败。&&& 单位是毫秒。
8. 测试运行器：可以使用@RunWith注解使用的runner.
Junit4中内置的运行器有：
a) 附带兼容junit3.x运行器
org.junit.internal.runners.Junit38ClassRunner
b) 参数化运行器，可设定一组参数，每次运行测试时自动在指定位置给予不同的参数。
org.junit.runners.Parameterized
c) Suite运行器，如同Junit3.x中的TestSuite, 用于任意组合测试.
org.junit.runner.Suite
9. 参数化运行器：
a) 使用注解@RunWith(value = Parameterized.class) 指定参数化运行器,
b) 定义好一个方法，返回一组参数数据，使用注解@Parameterized.Parameters
c) 测试类构造方法中为各个参数赋值（构造方法是由Junit调用的）
d) 方法必须是public，static，void，no-arg，返回一个Collection。
e) 方法中每个元素必须是一个一维数组，数组中第一个为预期值，之后参数一，参数二等。
@RunWith(value = Parameterized.class)
public class ParamCalculatorTest {
&&& private C
&&& private int para1;
&&& private int para2;
&&& @Parameterized.Parameters
&&& public static Collection&Integer[]& getParamData() {
&&&&&& Integer[][] data = new Integer[][] { { 5, 3, 2 }, { 3, 1, 2 }, { 2, 1, 1 } };
&&&&&&& return Arrays.asList(data);
&&& @Before
&&& public void init() {
&&&&&&& cal = new Calculator();
public ParamCalculatorTest(int expected, int para1, int para2) {
&&&&&&& this.expected =
&&&&&&& this.para1 = para1;
&&&&&&& this.para2 = para2;
&&& public void testAdd() {
&&&&&&& int result = cal.add(para1, para2);
&&&&&&& Assert.assertEquals(expected, result);
&&& @After
&&& public void destory() {
10.Suite运行器：在Junit4中，如果想同时运行多个测试，需要使用两个注解：
@RunWith(value = Suite.class)
@SuiteClasses
使用以上两个注解会通过Suite运行器来执行测试，在SuiteClasses中指定测试类，也可以继续指定Suite，这样Junit会在去查找里面的测试类并执行。
&&& @RunWith(value = Suite.class)
@SuiteClasses( { CalculatorTest.class, MyStackTest.class })
public class SuiteCalculatorMyStackTest {
stevenjohn
浏览: 960951 次
来自: 深圳
FileInputStream不要关闭啊?
在试用联通的wo邮箱的时候，uid是null的。目前其他邮箱正 ...
理解很有深度，赞一个！
(window.slotbydup=window.slotbydup || []).push({
id: '4773203',
container: s,
size: '200,200',
display: 'inlay-fix'博客分类：
1. 下载JUnit的jar文件，下载地址在
2. 在MyEclipse中新建一个要测试的项目HelloJUnit
3. 添加一个要测试的类HelloJUnit，代码如下，注意需要先建package
package com.
public class HelloJUnit {
public String getMessage(){
return "Hello Junit";
4. 新建一个单元测试项目，命名为HelloJUnitTest，引用在第一步中下载的jar文件，如下下图所示
5. 添加测试类，HelloJUnitTest，需要提前建package
package com.
/*引用测试相关类和方法*/
import org.junit.T
import org.junit.B
import static org.junit.Assert.*;
public class HelloJUnitTest {
private HelloJUnit _
public void beforeTest(){
_target = new HelloJUnit();
public void testGetMessage(){
String expected = "Hello Junit";
String actual = _target.getMessage();
assertEquals(expected,actual);
6. 运行测试，在项目上单击右键，然后选择Run as --& JUnit Test
浏览 23877
浏览: 176216 次
来自: 北京
楼主，js代码放在哪里呢？
我觉得作者总结的比较好，这都是我们在做web开发时需要考虑的， ...
曾经用了很久的360，不过也已经告别它很久了。
太理论了，没多大用处。本人意见。
OK了，我知道了，谢谢！
(window.slotbydup=window.slotbydup || []).push({
id: '4773203',
container: s,
size: '200,200',
display: 'inlay-fix'一、对加法函数进行测试
1.实例化被测单元（方法）：类名 实例名=new 类名（[参数]）
2.调用被测单元，对比预期值和输出值（实际值）；
在没有junit测试工具的情况下，我们要进行如下的测试代码编写过程：
二、利用Junit进行单元测试
&&& Junit是一款专门用于java语言的代码的单元测试工具；是一套基于java的测试框架，目前有两个版本：Junit3，Junit4.Junit中最常用的两个测试方法是：
assertEquals(expect,actual);用于非数组型的数据的比较；assertArrayEquals(expect,actual);用于数组型的数据的比较；
PS:这两个函数的选择是由被测单元的输出数据类型决定的。
1.Junit 3特征
a.测试类都是要继承TestCase类：&&& import junit.framework.TestCase&&& public class TestCalc extends TestCaseb.测试类中的方法的作用是由方法名决定的且测试用例的方法必须以小写的test开头；
&&&& Junit 3有很大优化，没有Junit3那样的约束条件，使用起来很方便，对于Calc测试如下：
3.对于Java中单元测试来说，被测的方法的类型一般是或者可以转化为以下四种类型：
a.被测方法有返回值，且返回值是可预期的。(按照功能，特定的输入一定对应特定的输出)；assertEquals(预期值，输入值);
//上述对于加法函数的测试即属于该类；
b.被测方法有返回值，但是返回值不是固定的，是随机的，但是返回值从数学角度来看，返回值必然是有其特征的;
c.被测方法没有返回值，此时都可以将之转化为输出类型（System.out.println()）;
例：Dog这样的类是没有返回类型的，通常我们可以将之转化为有输出语句的类型；
d.被测方法本身会抛出异常，此时的测试重点已经是对异常信息的检测。
4.Parameter参数化
&&&&& 一般来说，在自动化测试领域，针对同一单元的测试，往往存在多个测试用例，在代码层面来看，多个测试用例的实现，其特征是：逻辑相同，数据不同。此时就需要用到参数化的操作，一定程度上实现代码和数据的分离，junit自身提供了参数化的方式。
通过参数化进行测试：
5.feeder工具
添加feeder插件，新建data文件夹，右击新建文件，命名为isnumber.csv.（以上面isNumber为例）
阅读(...) 评论()