Junit使用教程（四）

最新推荐文章于 2024-07-22 15:34:40 发布
最新推荐文章于 2024-07-22 15:34:40 发布
阅读量322 收藏
点赞数
分类专栏： 软件测试 文章标签： 测试 Junit

一、会用Spring测试套件的好处

在开发基于Spring的应用时，如果你还直接使用Junit进行单元测试，那你就错过了Spring为我们所提供的饕餮大餐了。使用Junit直接进行单元测试有以下四大不足：

1）导致多次Spring容器初始化问题

根据JUnit测试方法的调用流程，每执行一个测试方法都会创建一个测试用例的实例并调用setUp()方法。由于一般情况下，我们在setUp()方法中初始化Spring容器，这意味着如果测试用例有多少个测试方法，Spring容器就会被重复初始化多次。虽然初始化Spring容器的速度并不会太慢，但由于可能会在Spring容器初始化时执行加载Hibernate映射文件等耗时的操作，如果每执行一个测试方法都必须重复初始化Spring容器，则对测试性能的影响是不容忽视的；

使用Spring测试套件，Spring容器只会初始化一次

2）需要使用硬编码方式手工获取Bean

在测试用例类中我们需要通过ctx.getBean()方法从Spirng容器中获取需要测试的目标Bean，并且还要进行强制类型转换的造型操作。这种乏味的操作迷漫在测试用例的代码中，让人觉得烦琐不堪；

使用Spring测试套件，测试用例类中的属性会被自动填充Spring容器的对应Bean，无须在手工设置Bean！

3）数据库现场容易遭受破坏

测试方法对数据库的更改操作会持久化到数据库中。虽然是针对开发数据库进行操作，但如果数据操作的影响是持久的，可能会影响到后面的测试行为。举个例子，用户在测试方法中插入一条ID为1的User记录，第一次运行不会有问题，第二次运行时，就会因为主键冲突而导致测试用例失败。所以应该既能够完成功能逻辑检查，又能够在测试完成后恢复现场，不会留下“后遗症”；

使用Spring测试套件，Spring会在你验证后，自动回滚对数据库的操作，保证数据库的现场不被破坏，因此重复测试不会发生问题！

4）不方便对数据操作正确性进行检查

假如我们向登录日志表插入了一条成功登录日志，可是我们却没有对t_login_log表中是否确实添加了一条记录进行检查。一般情况下，我们可能是打开数据库，肉眼观察是否插入了相应的记录，但这严重违背了自动测试的原则。试想在测试包括成千上万个数据操作行为的程序时，如何用肉眼进行检查？

只要你继承Spring的测试套件的用例类，你就可以通过jdbcTemplate（或Dao等）在同一事务中访问数据库，查询数据的变化，验证操作的正确性！

Spring提供了一套扩展于Junit测试用例的测试套件，使用这套测试套件完全解决了以上四个问题，让我们测试Spring的应用更加方便。这个测试套件主要由org.springframework.test包下的若干类组成，使用简单快捷，方便上手。

二、使用方法

1）基本用法

[java] view plain copy
print ?
  1. package com.test;  
  2.   
  3. import javax.annotation.Resource;  
  4.   
  5. import org.junit.Test;  
  6. import org.junit.runner.RunWith;  
  7. import org.springframework.test.context.ContextConfiguration;  
  8. import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;  
  9.   
  10. @RunWith(SpringJUnit4ClassRunner.class)  
  11. @ContextConfiguration(locations = { "classpath:config/applicationContext-*.xml", "classpath:services/ext/service-*.xml" })  
  12. public class UserServiceTest {  
  13.   
  14.     @Resource  
  15.     private IUserService userService;  
  16.   
  17.     @Test  
  18.     public void testAddOpinion1() {  
  19.         userService.downloadCount(1);  
  20.         System.out.println(1);  
  21.     }  
  22.   
  23.     @Test  
  24.     public void testAddOpinion2() {  
  25.         userService.downloadCount(2);  
  26.         System.out.println(2);  
  27.     }  
  28. }  
package com.test;

import javax.annotation.Resource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = { "classpath:config/applicationContext-*.xml", "classpath:services/ext/service-*.xml" })
public class UserServiceTest {

	@Resource
	private IUserService userService;

	@Test
	public void testAddOpinion1() {
		userService.downloadCount(1);
		System.out.println(1);
	}

	@Test
	public void testAddOpinion2() {
		userService.downloadCount(2);
		System.out.println(2);
	}
}

@RunWith(SpringJUnit4ClassRunner.class) 用于配置spring中测试的环境

@ContextConfiguration(locations = { "classpath:config/applicationContext-*.xml", "classpath:services/ext/service-*.xml" })用于指定配置文件所在的位置

@Resource注入Spring容器Bean对象，注意与@Autowired区别

2）事务用法

[java] view plain copy
print ?
  1. package com.test;  
  2.   
  3. import javax.annotation.Resource;  
  4.   
  5. import org.junit.Test;  
  6. import org.junit.runner.RunWith;  
  7. import org.springframework.test.annotation.Rollback;  
  8. import org.springframework.test.context.ContextConfiguration;  
  9. import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;  
  10. import org.springframework.test.context.transaction.TransactionConfiguration;  
  11. import org.springframework.transaction.annotation.Transactional;  
  12.   
  13. @RunWith(SpringJUnit4ClassRunner.class)  
  14. @ContextConfiguration(locations = { "classpath:config/applicationContext-*.xml", "classpath:services/ext/service-*.xml" })  
  15. @Transactional  
  16. @TransactionConfiguration(transactionManager = "transactionManager")  
  17. //@TransactionConfiguration(transactionManager = "transactionManager", defaultRollback = true)  
  18. public class UserServiceTest {  
  19.   
  20.     @Resource  
  21.     private IUserService userService;  
  22.   
  23.     @Test  
  24. //  @Transactional  
  25.     public void testAddOpinion1() {  
  26.         userService.downloadCount(1);  
  27.         System.out.println(1);  
  28.     }  
  29.   
  30.     @Test  
  31.     @Rollback(false)  
  32.     public void testAddOpinion2() {  
  33.         userService.downloadCount(2);  
  34.         System.out.println(2);  
  35.     }  
  36. }  
package com.test;

import javax.annotation.Resource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.annotation.Rollback;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.transaction.TransactionConfiguration;
import org.springframework.transaction.annotation.Transactional;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = { "classpath:config/applicationContext-*.xml", "classpath:services/ext/service-*.xml" })
@Transactional
@TransactionConfiguration(transactionManager = "transactionManager")
//@TransactionConfiguration(transactionManager = "transactionManager", defaultRollback = true)
public class UserServiceTest {

	@Resource
	private IUserService userService;

	@Test
//	@Transactional
	public void testAddOpinion1() {
		userService.downloadCount(1);
		System.out.println(1);
	}

	@Test
	@Rollback(false)
	public void testAddOpinion2() {
		userService.downloadCount(2);
		System.out.println(2);
	}
}

@TransactionConfiguration(transactionManager="transactionManager")读取Spring配置文件中名为transactionManager的事务配置，defaultRollback为事务回滚默认设置。该注解是可选的，可使用@Transactional与@Rollback配合完成事务管理。当然也可以使用@Transactional与@TransactionConfiguration配合。

@Transactional开启事务。可放到类或方法上，类上作用于所有方法。

@Rollback事务回滚配置。只能放到方法上。

3）继承AbstractTransactionalJUnit4SpringContextTests

[java] view plain copy
print ?
  1. package com.test;  
  2.   
  3. import javax.annotation.Resource;  
  4.   
  5. import org.junit.Test;  
  6. import org.springframework.test.context.ContextConfiguration;  
  7. import org.springframework.test.context.junit4.AbstractTransactionalJUnit4SpringContextTests;  
  8. import org.springframework.test.context.transaction.TransactionConfiguration;  
  9.   
  10. @ContextConfiguration(locations = { "classpath:config/applicationContext-*.xml", "classpath:services/ext/service-*.xml" })  
  11. @TransactionConfiguration(transactionManager = "transactionManager", defaultRollback = false)  
  12. public class UserServiceTest extends AbstractTransactionalJUnit4SpringContextTests {  
  13.   
  14.     @Resource  
  15.     private IUserService userService;  
  16.   
  17.     @Test  
  18.     public void testAddOpinion1() {  
  19.         userService.downloadCount(1);  
  20.         System.out.println(1);  
  21.     }  
  22.   
  23.     @Test  
  24.     public void testAddOpinion2() {  
  25.         userService.downloadCount(2);  
  26.         System.out.println(2);  
  27.     }  
  28. }  
package com.test;

import javax.annotation.Resource;

import org.junit.Test;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.AbstractTransactionalJUnit4SpringContextTests;
import org.springframework.test.context.transaction.TransactionConfiguration;

@ContextConfiguration(locations = { "classpath:config/applicationContext-*.xml", "classpath:services/ext/service-*.xml" })
@TransactionConfiguration(transactionManager = "transactionManager", defaultRollback = false)
public class UserServiceTest extends AbstractTransactionalJUnit4SpringContextTests {

	@Resource
	private IUserService userService;

	@Test
	public void testAddOpinion1() {
		userService.downloadCount(1);
		System.out.println(1);
	}

	@Test
	public void testAddOpinion2() {
		userService.downloadCount(2);
		System.out.println(2);
	}
}

AbstractTransactionalJUnit4SpringContextTests:这个类为我们解决了在web.xml中配置OpenSessionInview所解决的session生命周期延长的问题，所以要继承这个类。该类已经在类级别预先配置了好了事物支持，因此不必再配置@Transactional和@RunWith

4）继承

[java] view plain copy
print ?
  1. package com.test;  
  2.   
  3. import org.springframework.test.context.ContextConfiguration;  
  4. import org.springframework.test.context.junit4.AbstractTransactionalJUnit4SpringContextTests;  
  5. import org.springframework.test.context.transaction.TransactionConfiguration;  
  6.   
  7. @ContextConfiguration(locations = { "classpath:config/applicationContext-*.xml", "classpath:services/ext/service-*.xml" })  
  8. @TransactionConfiguration(transactionManager = "transactionManager")  
  9. public class BaseTestCase extends AbstractTransactionalJUnit4SpringContextTests {  
  10.   
  11. }  
package com.test;

import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.AbstractTransactionalJUnit4SpringContextTests;
import org.springframework.test.context.transaction.TransactionConfiguration;

@ContextConfiguration(locations = { "classpath:config/applicationContext-*.xml", "classpath:services/ext/service-*.xml" })
@TransactionConfiguration(transactionManager = "transactionManager")
public class BaseTestCase extends AbstractTransactionalJUnit4SpringContextTests {

}
[java] view plain copy
print ?
  1. package com.test;  
  2.   
  3. import javax.annotation.Resource;  
  4.   
  5. import org.junit.Test;  
  6. import org.springframework.test.annotation.Rollback;  
  7.   
  8. public class UserServiceTest extends BaseTestCase {  
  9.   
  10.     @Resource  
  11.     private IUserService userService;  
  12.   
  13.     @Test  
  14.     public void testAddOpinion1() {  
  15.         userService.downloadCount(1);  
  16.         System.out.println(1);  
  17.     }  
  18.   
  19.     @Test  
  20.     @Rollback(false)  
  21.     public void testAddOpinion2() {  
  22.         userService.downloadCount(2);  
  23.         System.out.println(2);  
  24.     }  
  25. }  
package com.test;

import javax.annotation.Resource;

import org.junit.Test;
import org.springframework.test.annotation.Rollback;

public class UserServiceTest extends BaseTestCase {

	@Resource
	private IUserService userService;

	@Test
	public void testAddOpinion1() {
		userService.downloadCount(1);
		System.out.println(1);
	}

	@Test
	@Rollback(false)
	public void testAddOpinion2() {
		userService.downloadCount(2);
		System.out.println(2);
	}
}

5）综合

[java] view plain copy
print ?
  1. @RunWith(SpringJUnit4ClassRunner.class)  
  2. @ContextConfiguration  
  3. @TransactionConfiguration  
  4. @Transactional  
  5. public class PersonDaoTransactionUnitTest extends AbstractTransactionalJUnit4SpringContextTests {  
  6.   
  7.     final Logger logger = LoggerFactory.getLogger(PersonDaoTransactionUnitTest.class);  
  8.   
  9.     protected static int SIZE = 2;  
  10.     protected static Integer ID = new Integer(1);  
  11.     protected static String FIRST_NAME = "Joe";  
  12.     protected static String LAST_NAME = "Smith";  
  13.     protected static String CHANGED_LAST_NAME = "Jackson";  
  14.   
  15.     @Autowired  
  16.     protected PersonDao personDao = null;  
  17.   
  18.     /** 
  19.      * Tests that the size and first record match what is expected before the transaction. 
  20.      */  
  21.     @BeforeTransaction  
  22.     public void beforeTransaction() {  
  23.         testPerson(true, LAST_NAME);  
  24.     }  
  25.   
  26.     /** 
  27.      * Tests person table and changes the first records last name. 
  28.      */  
  29.     @Test  
  30.     public void testHibernateTemplate() throws SQLException {  
  31.         assertNotNull("Person DAO is null.", personDao);  
  32.   
  33.         Collection<Person> lPersons = personDao.findPersons();  
  34.   
  35.         assertNotNull("Person list is null.", lPersons);  
  36.         assertEquals("Number of persons should be " + SIZE + ".", SIZE, lPersons.size());  
  37.   
  38.         for (Person person : lPersons) {  
  39.             assertNotNull("Person is null.", person);  
  40.   
  41.             if (ID.equals(person.getId())) {  
  42.                 assertEquals("Person first name should be " + FIRST_NAME + ".", FIRST_NAME, person.getFirstName());  
  43.                 assertEquals("Person last name should be " + LAST_NAME + ".", LAST_NAME, person.getLastName());  
  44.   
  45.                 person.setLastName(CHANGED_LAST_NAME);  
  46.   
  47.                 personDao.save(person);  
  48.             }  
  49.         }  
  50.     }  
  51.   
  52.     /** 
  53.      * Tests that the size and first record match what is expected after the transaction. 
  54.      */  
  55.     @AfterTransaction  
  56.     public void afterTransaction() {  
  57.         testPerson(false, LAST_NAME);  
  58.     }  
  59.   
  60.     /** 
  61.      * Tests person table. 
  62.      */  
  63.     protected void testPerson(boolean beforeTransaction, String matchLastName) {  
  64.         List<Map<String, Object>> lPersonMaps = simpleJdbcTemplate.queryForList("SELECT * FROM PERSON");  
  65.   
  66.         assertNotNull("Person list is null.", lPersonMaps);  
  67.         assertEquals("Number of persons should be " + SIZE + ".", SIZE, lPersonMaps.size());  
  68.   
  69.         Map<String, Object> hPerson = lPersonMaps.get(0);  
  70.   
  71.         logger.debug((beforeTransaction ? "Before" : "After") + " transaction.  " + hPerson.toString());  
  72.   
  73.         Integer id = (Integer) hPerson.get("ID");  
  74.         String firstName = (String) hPerson.get("FIRST_NAME");  
  75.         String lastName = (String) hPerson.get("LAST_NAME");  
  76.   
  77.         if (ID.equals(id)) {  
  78.             assertEquals("Person first name should be " + FIRST_NAME + ".", FIRST_NAME, firstName);  
  79.             assertEquals("Person last name should be " + matchLastName + ".", matchLastName, lastName);  
  80.         }  
  81.     }  
  82.   
  83. }  
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration
@TransactionConfiguration
@Transactional
public class PersonDaoTransactionUnitTest extends AbstractTransactionalJUnit4SpringContextTests {

	final Logger logger = LoggerFactory.getLogger(PersonDaoTransactionUnitTest.class);

	protected static int SIZE = 2;
	protected static Integer ID = new Integer(1);
	protected static String FIRST_NAME = "Joe";
	protected static String LAST_NAME = "Smith";
	protected static String CHANGED_LAST_NAME = "Jackson";

	@Autowired
	protected PersonDao personDao = null;

	/**
	 * Tests that the size and first record match what is expected before the transaction.
	 */
	@BeforeTransaction
	public void beforeTransaction() {
		testPerson(true, LAST_NAME);
	}

	/**
	 * Tests person table and changes the first records last name.
	 */
	@Test
	public void testHibernateTemplate() throws SQLException {
		assertNotNull("Person DAO is null.", personDao);

		Collection<Person> lPersons = personDao.findPersons();

		assertNotNull("Person list is null.", lPersons);
		assertEquals("Number of persons should be " + SIZE + ".", SIZE, lPersons.size());

		for (Person person : lPersons) {
			assertNotNull("Person is null.", person);

			if (ID.equals(person.getId())) {
				assertEquals("Person first name should be " + FIRST_NAME + ".", FIRST_NAME, person.getFirstName());
				assertEquals("Person last name should be " + LAST_NAME + ".", LAST_NAME, person.getLastName());

				person.setLastName(CHANGED_LAST_NAME);

				personDao.save(person);
			}
		}
	}

	/**
	 * Tests that the size and first record match what is expected after the transaction.
	 */
	@AfterTransaction
	public void afterTransaction() {
		testPerson(false, LAST_NAME);
	}

	/**
	 * Tests person table.
	 */
	protected void testPerson(boolean beforeTransaction, String matchLastName) {
		List<Map<String, Object>> lPersonMaps = simpleJdbcTemplate.queryForList("SELECT * FROM PERSON");

		assertNotNull("Person list is null.", lPersonMaps);
		assertEquals("Number of persons should be " + SIZE + ".", SIZE, lPersonMaps.size());

		Map<String, Object> hPerson = lPersonMaps.get(0);

		logger.debug((beforeTransaction ? "Before" : "After") + " transaction.  " + hPerson.toString());

		Integer id = (Integer) hPerson.get("ID");
		String firstName = (String) hPerson.get("FIRST_NAME");
		String lastName = (String) hPerson.get("LAST_NAME");

		if (ID.equals(id)) {
			assertEquals("Person first name should be " + FIRST_NAME + ".", FIRST_NAME, firstName);
			assertEquals("Person last name should be " + matchLastName + ".", matchLastName, lastName);
		}
	}

}

@BeforeTransaction在事务之前执行

@AfterTransaction在事务之后执行

@NotTransactional不开启事务

 

好了，本篇作为Junit补充就说到这里了，希望大家多多分享经验哦。

时光荏苒心依旧
关注
专栏目录
JUnit 5 使用教程 及 JUnit 4/5的差异
penriver的博客
04-30 1072
JDK 8在java中带来了迷人的功能，最值得注意的是lambda表达式 为了适应 Java 8 风格的编码和新的功能特性，所以产生了JUnit 5 本文带你学习如何使用JUnit 5进行单元测试，及JUnit 5 与JUnit 4的区别
超级详细的Junit单元测试教程
热门推荐
奈何的人生
05-31 10万+
如果你只会使用@Test来完成单元测试，那你是时候该深入一下了，其实知识点一点都不少！
Junit4 - 参数初始化
Turtle_Jaye的博客
10-27 2340
今天的测试作业是使用Junit4对代码进行测试 在没有使用参数初始化之前，创了13个test，太冗杂。 下面来说说参数初始化。 以下是代码： public class MyCalendar2 { public int getNumberOfDaysInMonth(int year, int month) { if (month == 1 || month == 3 || month =...
软件测试之单元测试之Junit测试使用前准备
zhiqingxue的博客
04-18 573
Junit测试只能说是算的上软件测试这门课中首次出现需要实操进行测试的工具了。 可以理解为前面的黑盒测试，白盒测试是为了理解一种测试思想，根据测试思想能够进行设计测试样例，到了Junit单元测试这里，就成了利用工具进行具体的测试了。 1.环境问题 首先必不可少的就是环境问题了，junit4在eclipse老版本上兼容性很高，相对也几乎没什么bug，一般出现的问题也可以从百度上找到。这里建议可以电脑上下载一个新版本的eclipse，使用Junit5，在虚拟机里保留下载一个旧版本的eclipse，使用Junit
使用Junit初始化spring容器测试
csdnjquery163com的博客
09-26 2391
一、demo @RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration(locations = { &amp;amp;amp;amp;quot;classpath:spring/applicationContext.xml&amp;amp;amp;amp;quot;, “classpath*:spring/wtx-db.xml”})** public abstract class TestBase { privat..
Junit4的使用及实例
qyl445的专栏
05-14 803
最近复习了下Junit4的使用，发现自己都忘完了，不过挺简单，在这里记录下来，防止以后忘了 首先导入jar包，  我用的是maven创建的web项目所以代码如下 junit junit 4.11 然后创建test case  这个在eclipse里面有，如果找不到，可以点other，然后输入junit，就可以找到了。 junit3要继承TestCase这个类
Junit4使用教程详解+源码下载.rar
08-20
本教程将深入讲解JUnit4的使用方法，并附带源码供学习者实践和参考。 一、JUnit4概述 JUnit4是JUnit系列的第四个主要版本，它引入了许多新特性，如注解（Annotations）、参数化测试、测试套件的改进以及更加灵活的...
Junit5基础教程
GongZiYouM的博客
07-07 837
一、概述 单元测试的优点 提升软件质量 促进代码优化 单元测试的基本原则 单元测试要符合AIR原则 A : Automatic （自动化） I : Independent （独立性） R : Repeatable （可重复） 单元测试的代码层面要符合BCDE原则 B: Border 边界值测试，包括循环边界、特殊取值、特殊时间点、数据顺序等 C: Correct 正确的输入,并得到预期的结果 D: Design 与设计文档相结合，来编写单元测试 E : Error 单元测试的目标是证明程序
junit单元测试获取spring容器对象以及spring-test单元测试获取spring容器对象
qq_41078128的博客
05-17 458
spring-test方式获取。
Spring依赖注入，在main方法或junit测试类里获取得Spring容器
xiongxianze的博客
12-08 6568
获取spring实例
Junit4、Junit5单元测试，SpringBoot项目获取类
mapleqn的博客
07-11 267
这是JUnit 4的注解。如果你正在使用Spring Boot，应该使用。注解：这个注解告诉Spring在测试期间加载应用程序的上下文。确保测试类使用了正确的测试运行器：不要使用。属性，指定了主应用程序类。简单易行，用起来用起来。
JUnit-Spring整合JUnit5、JUnit4
最新发布
2301_77193348的博客
07-22 580
Spring整合JUnit使程序创建spring容器
Spring整合Junit的详细配置
Savior.D的博客
07-20 325
Spring整合Junit 原始Junit测试Spring的问题 在测试类中，每个测试方法都有以下两行代码： ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml"); IAccountService is = app.getBean("accountService",IAccountService.class); 这两行代码的作用是获取容器，如果不写的话，直接会提示空指针异常。所以又不能
Junit4单元测试的基本用法(快速入门)
weixin_45552475的博客
07-21 2156
Junit4单元测试的基本用法 环境搭建单元测试添加依赖Caculate 类测试执行顺序Test的两个属性——细讲 单元测试 单元测试可以帮助我们验证程序的逻辑是否正确、可以降低bug修复的成本、更有利于代码重构等等。所以，我们在写代码的时候，尽量保证单元测试的覆盖率。能力好的可以先写测试用例，再写功能代码（测试先行）。 添加依赖 1、在build gradle(Module:app) 的dependencies添加依赖 testImplementation 'junit:junit:4.12'
JUnit4---实践二：拓展之运行指定类的某些测试方法-自动生成该文件
neven7的专栏
02-02 1792
一.背景 之前介绍过： JUnit4---实践一：运行指定类的某些测试方法，当重跑用例较少时，可以手工添加指定的测试方法，但是测试方法较多且在多个不同的类时，手工添加就比较头大，有必要自动生成指定测试方法。 想着有2种方法：1.JUnitCore添加监听器RunListener，获得第一次执行的结果，根据结果聚合出指定的测试方法；2.通过扫结果日志，找到FAILED和ERROR，聚合
使用Spring+Junit4.4进行测试
sebastain的专栏
09-11 2653
http://nottiansyf.iteye.com/blog/345819 使用Junit4.4测试 在类上的配置Annotation @RunWith(SpringJUnit4ClassRunner.class) 用于配置spring中测试的环境 @ContextConfiguration(locations={"classpath:spring/applicationCont
Spring Test 整合 JUnit 4 实例
jazywoo_在路上
12-24 741
1. 参加依附包 　　应用Spring的测试框架须要参加以下依附包： JUnit 4 （官方下载：https://github.com/KentBeck/junit/downloads） Spring Test （Spring框架中的test包） Spring 相干其他依附包（不再赘述了，就是context等包） 2. 创建测试源目次和包 　　在此，推荐创建一个和s
junit4的使用教程
04-16
JUnit4是JUnit的第四个主要版本，它提供了一组注解和断言方法，使得编写和运行单元测试变得更加简单和方便。 使用JUnit4进行单元测试的基本步骤如下： 1. 导入JUnit4库：在项目中添加JUnit4库的依赖，可以通过...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值