本文目录
- java的一道作业题,麻烦高手做下先谢了
- java测试引用不明确
- java应用程序（Application）创建类的对象并测试个方法功能
- 一段java代码的不理解，希望高手能具体解释下，下面的代码的意思！个人觉得里面的断言没有起到什么作用
- JAVA单元测试
- 怎么写Java测试代码
java的一道作业题,麻烦高手做下先谢了
真是麻烦，这里居然不能上传附件。说明：1、为了清晰回答你的问题，我共写了五个类。先分别说明一下各自的作用。baidu.zhidao.anser.model.Account不用讲了，这个类自然是代表银行帐户的DomainModel了。baidu.zhidao.answer.util.DatabaseUtil这个类负责获取数据库连接，以及关闭数据库资源(connection, preparedStatement, ResultSet)，一个非常简单的工具类。baidu.zhidao.answer.AccountManager这是个interface，对外部暴露了操作account的方法。可以作为一个facade来使用。baidu.zhidao.answer.AccountManagerImpl这个类实现了AccountManager interface，内部操作数据库采用DatabaseUtil，是对account进行实际操作的实现类。baidu.zhidao.answer.AccountManagerTest这是一个Junit testcase，具体测试了AccountManager的各个方法，可以参照此类查看AccountManager的具体用法。2.需要注意的地方a.我看了你的题目要求，尤其是数据表的schema，猜测你是使用的sql server，也不知对不对？如果对的话，你需要拷贝sql server的jdbc driver，也就是msbase.jar,mssqlserver.jar,msutil.jar这三个jar到你的project library里面。b.为简便期间，我没有把配置数据库参数以配置文件的方式写在外面，而是在DatabaseUtil里面预先设置的，你可能需要根据你的实际环境更改url，user，password。如果你真要改为配置文件方式也很简单，我这里就不多废话了。3、这些仅仅是个toy，如果要用在实际项目中还有很多待改进的地方。不过足以应付你的需要了。局限1：未实现批量增加/删除用户（你的问题里没要求）局限2：事务无法跨越方法，总是在方法内部完成。其实要实现方法跨事务也不难，只需要将connection用ThreadLocal封装即可。(你的问题里也没要求，嘿嘿)局限3：未采用数据库连接池，对每个客户端请求都是新开connection，系统开销大，不能应付过多的客户端同时调用。(未实现的理由同上)局限4：对于数据库操作的异常未做良好的封装，为不影响用户界面的简单调用采用runtimeException抛出。所以在用户界面(web界面或者具体java application界面)中你需要对AccountManager的方法调用显示try/catch并处理异常，以提供给用户格式良好的出错信息。PS:不要怪我未实现上述所说的局限之处，光写代码、说明加贴上来也花了我一个小时左右的时间，这些地方就留待你自己完善吧。4、具体使用你具体使用只要关心AccountManager即可，调用方法如下：//实例化managerAccountManager manager = AccountManagerImpl();//增加或修改帐号manager.saveAccount(account);//通过account id查找Account account = manager.findAccountById(id);//通过account Name模糊查找List accounts = manager.findAccountByName(account);//删除帐号manager.removeAccount(id);具体可查看AccountManagerTest的代码5、代码------------------------------------------------------package baidu.zhidao.answer.model;import java.io.Serializable;import java.math.BigDecimal;public class Account implements Serializable{ private String id; private String name; private BigDecimal balance = new BigDecimal(0); public Account() { } public Account(String id, String name) { this.id = id; this.name = name; } public Account(String id, String name, BigDecimal balance) { this.id = id; this.name = name; this.balance = balance; } public BigDecimal getBalance() { return balance; } public void setBalance(BigDecimal balance) { this.balance = balance; } public String getId() { return id; } public void setId(String id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; }}------------------------------------------------------package baidu.zhidao.answer.util;import java.sql.Connection;import java.sql.DriverManager;import java.sql.PreparedStatement;import java.sql.ResultSet;import java.sql.SQLException;import java.sql.Statement;public class DatabaseUtil{ private static final String DEFAULT_DRIVER = “com.microsoft.jdbc.sqlserver.SQLServerDriver“; private static final String DEFAULT_URL = “jdbc:microsoft:sqlserver://yourDatabaseIp:yourDatabasePort;DatabaseName=yourDatabase“; private static final String DEFAULT_USER = “yourDatabaseUser“; private static final String DEFAULT_PASSWORD = “password“; private DatabaseUtil() { } public static Connection getConnection(String driver, String url, String user, String password) throws Exception { driver = (driver == null || driver.length() == 0) ? DEFAULT_DRIVER : driver; url = (url == null || url.length() == 0) ? DEFAULT_URL : url; user = (user == null || user.length() == 0) ? DEFAULT_USER : user; password = (password == null || password.length() == 0) ? DEFAULT_PASSWORD : password; Class.forName(driver).newInstance(); return DriverManager.getConnection(url, user, password); } public static Connection getConnection() throws Exception { return getConnection(null, null, null, null); } public static void close(Connection conn) { if (conn != null) { try { conn.close(); } catch (SQLException ignore) { ignore.printStackTrace(); } finally { conn = null; } } } public static void close(Statement stmt) { if (stmt != null) { try { stmt.close(); } catch (SQLException ignore) { ignore.printStackTrace(); } finally { stmt = null; } } } public static void close(PreparedStatement pstmt) { if (pstmt != null) { try { pstmt.close(); } catch (SQLException ignore) { ignore.printStackTrace(); } finally { pstmt = null; } } } public static void close(ResultSet rs) { if (rs != null) { try { rs.close(); } catch (SQLException ignore) { ignore.printStackTrace(); } finally { rs = null; } } }}------------------------------------------------------package baidu.zhidao.answer;import java.util.List;import baidu.zhidao.answer.model.Account;public interface AccountManager{ public abstract Account findAccountById(String accountId); public abstract List findAccountByName(String accountName); public abstract void saveAccount(Account account); public abstract void removeAccount(String id); public List findAll();}------------------------------------------------------package baidu.zhidao.answer;import java.sql.Connection;import java.sql.PreparedStatement;import java.sql.ResultSet;import java.sql.SQLException;import java.util.ArrayList;import java.util.List;import baidu.zhidao.answer.model.Account;import baidu.zhidao.answer.util.DatabaseUtil;public class AccountManagerImpl implements AccountManager{ /* * (non-Javadoc) * * @see baidu.zhidao.answer.AccountManager#findAccountById() */ public Account findAccountById(String accountId) { if (accountId == null || accountId.length() == 0) { throw new IllegalArgumentException(“accountId must be specified.“); } String querySql = “SELECT * FROM Account WHERE accountId = ?“; List results = query(querySql, new Object { accountId }); if (results.size() 》 0) { return (Account) results.get(0); } else { return null; } } public List findAccountByName(String accountName) { if (accountName == null || accountName.length() == 0) { throw new IllegalArgumentException(“accountName must be specified.“); } String querySql = “SELECT * FROM Account WHERE accountName LIKE ?“; return query(querySql, new Object { “%“ + accountName + “%“ }); } public List findAll() { return query(“SELECT * FROM Account“); } public void saveAccount(Account account) { //TODO need to implements update method Account alreadyExist = findAccountById(account.getId()); String saveSql; if (alreadyExist != null) { saveSql = “UPDATE Account SET accountName = ?, balance = ? WHERE accountId = ?“; } else { saveSql = “INSERT INTO Account (accountId, accountName, balance) VALUES (?, ?, ?)“; } Object parameters = new Object; if (alreadyExist == null) { parameters = account.getId(); parameters = account.getName(); parameters = account.getBalance(); } else { parameters = account.getName(); parameters = account.getBalance(); parameters = account.getId(); } executeSQL(saveSql, parameters); } public void removeAccount(String id) { if (id == null || id.length() == 0) { throw new IllegalArgumentException(“accountId must be specified.“); } String deleteSql = “DELETE FROM Account WHERE accountId = ?“; executeSQL(deleteSql, new Object { id }); } protected List query(String queryString) { return query(queryString, null); } protected List query(String queryString, Object parameters) { List results = new ArrayList(); Connection conn = null; PreparedStatement psmt = null; ResultSet rs = null; try { conn = DatabaseUtil.getConnection(); psmt = conn.prepareStatement(queryString); if (parameters != null && parameters.length 》 0) { for (int i = 0; i 《 parameters.length; i++) { psmt.setObject(i + 1, parameters); } psmt.execute(); conn.commit(); } catch (Exception e) { try { conn.rollback(); } catch (SQLException e1) { throw new RuntimeException(e1); } throw new RuntimeException(e); } finally { DatabaseUtil.close(rs); DatabaseUtil.close(psmt); DatabaseUtil.close(conn); } }}------------------------------------------------------package baidu.zhidao.answer;import java.math.BigDecimal;import java.util.List;import baidu.zhidao.answer.model.Account;import junit.framework.TestCase;public class AccountManagerTest extends TestCase{ private AccountManager manager = new AccountManagerImpl(); private Account a1 = new Account(“denis“, “Denis Wang“, new BigDecimal(“10“)); private Account a2 = new Account(“denis2“, “Denis Wang2“, new BigDecimal( “11.22“)); private Account a3 = new Account(“denis3“, “Denis Wang3“, new BigDecimal( “14.00“)); private Account a4 = new Account(“denis4“, “Denis Wang4“, new BigDecimal( “15.21“)); protected void setUp() throws Exception { manager.saveAccount(a1); manager.saveAccount(a2); manager.saveAccount(a3); manager.saveAccount(a4); } protected void tearDown() throws Exception { manager.removeAccount(a1.getId()); manager.removeAccount(a2.getId()); manager.removeAccount(a3.getId()); manager.removeAccount(a4.getId()); } public void testFindAccountById() { Account denis = manager.findAccountById(“denis“); assertEquals(a1.getId(), denis.getId()); assertEquals(a1.getName(), denis.getName()); assertTrue(a1.getBalance().compareTo(denis.getBalance()) == 0); } public void testFindAccountByName() { List results = manager.findAccountByName(“Denis“); assertEquals(4, results.size()); } public void testSaveOrUpdateAccount() { // test save new account action manager.saveAccount(new Account(“tempId“, “tempName“, new BigDecimal( “11.22“))); assertEquals(5, manager.findAll().size()); manager.removeAccount(“tempId“); assertEquals(4, manager.findAll().size()); // test update exist account action Account denis2 = manager.findAccountById(“denis2“); denis2.setBalance(denis2.getBalance().add(new BigDecimal(“2“))); manager.saveAccount(denis2); Account denis2LoadAgain = manager.findAccountById(“denis2“); assertEquals(0, denis2.getBalance().compareTo(denis2LoadAgain.getBalance())); assertEquals(4, manager.findAll().size()); } public void testRemoveAccount() { manager.saveAccount(new Account(“tempId“, “tempName“, new BigDecimal( “11.22“))); assertEquals(5, manager.findAll().size()); manager.removeAccount(“tempId“); assertEquals(4, manager.findAll().size()); }}------------------------------------------------------
java测试引用不明确
jvm不知道你要引用的是哪个assertEquals。打个比方：云南省有个人叫王二；上海市有个人也叫王二。他们在一起的时候你请B去帮你叫王二过来，B就不知道你想叫的是谁。所以，你就要告诉B是叫云南的还是上海的这道题的解决方法就是：将参数类型写死。是double型还是Object的。
java应用程序（Application）创建类的对象并测试个方法功能
MyEclipse中创建Junit 的步骤如下：1、选择一个存放测试类的package，右键--》new--》Other--》Java--》JUnit--》JUnit Test Case--》填写完测试类的名字，选择所要使用的JUnit 的版本【注：JUnit 4支持@解释表示符，建议使用】，可根据情况，选择是否自动生成：setUpBeforeClass()【注：静态方法，在测试类执的测试方法执行前被系统调用，只被调用一次】,tearDownAfterClass()【注：静态方法，在测试类的所有测试方法执行完毕后被系统调用，只被调用一次】,setUp()【注：非静态方法，在每个测试方法执行前，被系统调用，有多少个测试方法，就被调用多少次】,tearDown()【注：非静态方法，在每个测试方法执行完毕后，被系统调用，有多少个测试方法，就被调用多少次】这些方法。 然后，点“finish” ，这样就创建了一个 Junit Case。2、根据实际情况，写测试函数。下面是一个简单的例子：import static org.junit.Assert.*;import org.junit.After;import org.junit.AfterClass;import org.junit.Before;import org.junit.BeforeClass;import org.junit.Test;public class Tc {@BeforeClasspublic static void setUpBeforeClass() throws Exception {}@AfterClasspublic static void tearDownAfterClass() throws Exception {}@Beforepublic void setUp() throws Exception {}@Afterpublic void tearDown() throws Exception {}// @Test : 表示这是一个测试用例，只有标识了改符号的函数才会被执行测试@Testpublic void testAdd(){ String str=“abc“; assertEquals(“abc“,str);// 结果判断，assertEquals 是org.junit.Assert自带的静态函数。}}3、右键，run as-》Junit Test ，运行完毕，可以看到测试结果：状态条为绿色，表示测试通过，为红色，表示未通过。
一段java代码的不理解，希望高手能具体解释下，下面的代码的意思！个人觉得里面的断言没有起到什么作用
public void testsetLog() throws Exception {LogManagerImpl LMI=Util_con.createLMI(); //创建日志管理器对象LMI.setLog(4, “admin“, “admin“, “320400000000“);//设置日志内容，具体内部看实现方式 boolean flag = false;//声明一个标记，初始值为假 if(flag){ //通过此处可以知道你的日志是不是处理成功 System.out.println(“添加日志成功！“); //输出语句，提示你日志操作成功 }else{System.out.println(“添加日志失败！“);}//这条会打印出来 Assert.assertEquals(“添加日志成功！“,“添加日志成功！“);//直接比较两个相同内容的String对于楼上的解释完全正确，补充一点你的追问，设置 boolean flag = false初始为假，是为了方便知道你的记录是不是成功，如果成功，日志类会返回一个真。如果处理失败或出现异常都会返回假 再补充一个 刚刚你提问说为什么初始flag要设置为false 因为一般习惯都是先默认为false 然后通过一系列if判断看是否能符合要求，符合则修改为false 最后return flag 避免了直接设置为真 然后忘记做处理 然后就直接通过了的错误情况出现，因为它默认是false的；我觉得这段代码应该就是一个单元测试的小例子 只是示范一下assert而已 具体代码意思上面几位已经讲得很清楚了；楼主不用太去在意，代码意思很简单 不要想多了
JAVA单元测试
首先我们需要先下载相应的 JUnit 相关的 JAR 包，下载的过程可以去 JUnit 的官方网站，也可以直接通过 Maven 资源仓库来完成。 使用简单的 @Test 注解实现我们的测试方法的编写和执行 准备工作做好之后，接下来我们就可以开始尝试编写壹个简单的测试代码了。首先，我们编写了壹个 Calculator 类，并提供五个方法分别完成加减乘除以及求平方的运算。代码如下： package net.oschina.bairrfhoinn.main; public class Calculator { public void add(int n){ result += n; } public void substract(int n){ result -= n; } public void multiply(int n){ result *= n; } public void divide(int n){ result /= n; } public void square(int n){ result = n * n; } public int getReuslt(){ return result; } public void clear(){ result = 0; } private static int result; } 在测试类中用到了JUnit4框架，自然要把相应地Package包含进来。最主要地一个Package就是org.junit.*。把它包含进来之后，绝大部分功能就有了。还有一句话也非常地重要“import static org.junit.Assert.*;”，我们在测试的时候使用的壹系列assertEquals()方法就来自这个包。大家注意壹下，这是壹个静态包含（static），是JDK5中新增添的壹个功能。也就是说，assertEquals是Assert类中的壹系列的静态方法，壹般的使用方式是Assert. assertEquals()，但是使用了静态包含后，前面的类名就可以省略了，使用起来更加的方便。 另外要注意的是，我们的测试类是壹个独立的类，没有任何父类。测试类的名字也可以任意命名，没有任何局限性。所以我们不能通过类的声明来判断它是不是一个测试类，它与普通类的区别在于它内部的方法的声明，我们接着会讲到。在测试类中，并不是每壹个方法都是用于测试的，所以我们必须使用“注解”来明确表明哪些是测试方法。“注解”也是JDK5的壹个新特性，用在此处非常恰当。我们可以看到，在某些方法的前有@Before、@Test、@Ignore等字样，这些就是注解，以壹个“@”作为开头。这些注解都是JUnit4自定义的，熟练掌握这些注解的含义，对于编写恰当的测试类非常重要。 接下来我们创建壹个测试类 CalculatorTest.java，代码如下： package net.oschina.bairrfhoinn.test; import static org.junit.Assert.*; import org.junit.Test; import net.oschina.bairrfhoinn.main.Calculator; public class CalculatorTest { private static Calculator calculator = new Calculator(); @Test public void testAdd(){ calculator.add(7); calculator.add(8); assertEquals(15, calculator.getReuslt()); } } 首先，我们要在方法的前面使用@Test标注，以表明这是壹个测试方法。对于方法的声明也有如下要求：名字可以随便取，没有任何限制，但是返回值必须为void，而且不能有任何参数。如果违反这些规定，会在运行时抛出壹个异常。至于方法内该写些什么，那就要看你需要测试些什么了。比如上述代码中，我们想测试壹下add()方法的功能是否正确，就在测试方法中调用几次add函数，初始值为0，先加7，再加8，我们期待的结果应该是15。如果最终实际结果也是15，则说明add()方法是正确的，反之说明它是错的。assertEquals(15, calculator.getResult());就是用来判断期待结果和实际结果是否相等，其中第壹个参数填写期待结果，第二个参数填写实际结果，也就是通过计算得到的结果。这样写好之后，JUnit 会自动进行测试并把测试结果反馈给用户。 如果想运行它，可以在 eclipse 的资源管理器中选择该类文件，然后点击右键，选择 Run As-》JUnit Test 即可看到运行结果。 使用@Test 的属性 Ignore 指定测试时跳过这个方法 如果在写程序前做了很好的规划，那么哪些方法是什么功能都应该实现并且确定下来。因此，即使该方法尚未完成，他的具体功能也是确定的，这也就意味着你可以为他编写测试用例。但是，如果你已经把该方法的测试用例写完，但该方法尚未完成，那么测试的时候无疑是“失败”。这种失败和真正的失败是有区别的，因此 JUnit 提供了壹种方法来区别他们，那就是在这种测试函数的前面加上 @Ignore 标注，这个标注的含义就是“某些方法尚未完成，暂不参与此次测试”。这样的话测试结果就会提示你有几个测试被忽略，而不是失败。壹旦你完成了相应函数，只需要把@Ignore标注删去，就可以进行正常的测试。 比如说上面的测试类 Calculator.java 中，假设我们的 Calculator 类的 multiply() 方法没有实现，我们可以在测试类 CalculatorTest 中先写如下测试代码： package net.oschina.bairrfhoinn.test; import static org.junit.Assert.*; import org.junit.Ignore; import org.junit.Test; import net.oschina.bairrfhoinn.main.Calculator; public class CalculatorTest { private static Calculator calculator = new Calculator(); ... //此处代码省略 @Ignore(“method square() not implemented, please test this later...“) @Test public void testSquare(){ calculator.square(3); assertEquals(9, calculator.getReuslt()); } } 我们再运行壹次测试，会看到如下结果，从图中可以很明显的看出，方法testSquare() 上的 @Ignore 注解已经生效了，运行时直接跳过了它，而方法testAdd()仍然正常的运行并通过了测试。 使用注解 @Before 和 @After 来完成前置工作和后置工作 前置工作通常是指我们的测试方法在运行之前需要做的壹些准备工作，如数据库的连接、文件的加载、输入数据的准备等需要在运行测试方法之前做的事情，都属于前置工作；类似的，后置工作则是指测试方法在运行之后的壹些要做的事情，如释放数据库连接、输入输出流的关闭等；比如我们上面的测试，由于只声明了壹个 Calculator 对象，他的初始值是0，但是测试完加法操作后，他的值就不是0了；接下来测试减法操作，就必然要考虑上次加法操作的结果。这绝对是壹个很糟糕的设计！我们非常希望每壹个测试方法都是独立的，相互之间没有任何耦合度。因此，我们就很有必要在执行每壹个测试方法之前，对Calculator对象进行壹个“复原”操作，以消除其他测试造成的影响。因此，“在任何壹个测试方法执行之前必须执行的代码”就是壹个前置工作，我们用注解 @Before 来标注它，如下例子所示： package net.oschina.bairrfhoinn.test; ... import org.junit.After; import org.junit.Before; import org.junit.Ignore; import org.junit.Test; public class CalculatorTest { ...//这里省略部分代码 @Before public void setUp() throws Exception { calculator.clear(); } @After public void tearDown() throws Exception { System.out.println(“will do sth here...“); } ...//这里省略部分代码 } 另外要说的是，注解 @Before 是定义在 org.junit.Before 这个类中的，因此使用时需要将其引入我们的代码中。这样做了之后，每次我们运行测试方法时，JUnit 都会先运行 setUp() 方法将 result 的值清零。不过要注意的是，这里不再需要 @Test 注解，因为这并不是壹个 test，只是壹个前置工作。同理，如果“在任何测试执行之后需要进行的收尾工作，我们应该使用 @After 来标注，方法与它类似。由于本例比较简单，不需要用到此功能，所以我们只是简单了给它添加了壹个 tearDown() 方法并在收尾时打印壹句话到控制台，并且使用 @After 来注解这个方法。 使用@BeforeClass 和 @AfterClass 来完成只需要执行壹次的前置工作和后置工作 上面我们提到了两个注解 @Before 和 @After ，我们来看看他们是否适合完成如下功能：有壹个类负责对大文件（超过500 MB）进行读写，他的每壹个方法都是对文件进行操作。换句话说，在调用每壹个方法之前，我们都要打开壹个大文件并读入文件内容，这绝对是壹个非常耗费时的操作。如果我们使用 @Before 和 @After ，那么每次测试都要读取壹次文件，效率及其低下。所以我们希望的是，在所有测试壹开始读壹次文件，所有测试结束之后释放文件，而不是每次测试都读文件。JUnit的作者显然也考虑到了这个问题，它给出了@BeforeClass 和 @AfterClass 两个注解来帮我们实现这个功能。从名字上就可以看出，用这两个注解标注的函数，只在测试用例初始化时执行 @BeforeClass 方法，当所有测试执行完毕之后，执行 @AfterClass 进行收尾工作。在这里要注意壹下，每个测试类只能有壹个方法被标注为 @BeforeClass 或 @AfterClass，而且该方法必须是 public static 类型的。 使用@Test 的属性 timeout 来完成限时测试，以检测代码中的死循环 现在假设我们的 Calculator 类中的 square() 方法是个死循环，那应该怎么办呢，比如说像下面这样： public void square(int n){ for(;;){} } 如果测试的时候遇到死循环，你的脸上绝对不会露出笑容的。因此，对于那些逻辑很复杂，循环嵌套比较深的、有可能出现死循环的程序，因此壹定要采取壹些预防措施。限时测试是壹个很好的解决方案。我们给这些测试函数设定壹个预期的执行时间，超过了这壹时间，他们就会被系统强行终止，并且系统还会向你汇报该函数结束的原因是因为超时，这样你就可以发现这些 Bug 了。要实现这壹功能，只需要给 @Test 标注加壹个参数timeout即可，代码如下： @Test(timeout=2000L) public void testSquare() { calculator.square(3); assertEquals(9, calculator.getReuslt()); } timeout参数表明了你预计该方法运行的时长，单位为毫秒，因此2000就代表2秒。现在我们让这个测试方法运行壹下，看看失败时是什么效果。 使用@Test 的属性expected来监控测试方法中可能会抛出的某些异常 JAVA中的异常处理也是壹个重点，因此你经常会编写壹些需要抛出异常的函数。如果你觉得壹个函数应该抛出异常，但是它没抛出，这算不算 Bug 呢？这当然是Bug，JUnit 也考虑到了这壹点，并且可以帮助我们找到这种 Bug。例如，我们写的计算器类有除法功能，如果除数是壹个0，那么必然要抛出“除0异常”。因此，我们很有必要对这些进行测试。代码如下： @Test(expected=java.lang.ArithmeticException.class) public void testDivide(){ calculator.divide(0); } 如上述代码所示，我们需要使用@Test注解中的expected属性，将我们要检验的异常（这里是 java.lang.ArithmeticException）传递给他，这样 JUnit 框架就能自动帮我们检测是否抛出了我们指定的异常。 指定 JUnit 运行测试用例时的 Runner 大家有没有想过这个问题，当你把测试代码提交给JUnit框架后，框架是如何来运行你的代码的呢？答案就是Runner。在JUnit中有很多个Runner，他们负责调用你的测试代码，每壹个Runner都有其各自的特殊功能，你要根据需要选择不同的Runner来运行你的测试代码。可能你会觉得奇怪，前面我们写了那么多测试，并没有明确指定壹个Runner啊？这是因为JUnit中有壹个默认的Runner，如果你没有指定，那么系统会自动使用默认Runner来运行你的代码。换句话说，下面两段代码含义是完全壹样的： import org.junit.runner.RunWith; import org.junit.runners.JUnit4; @RunWith(JUnit4.class) public class CalculatorTest { ...//省略此处代码 } //用了系统默认的JUnit4.class，运行效果完全壹样 public class CalculatorTest { ...//省略此处代码 }
怎么写Java测试代码
可以用main函数和JUnit来写测试代码。main是最早使用的，但是现在更流行的测试工具是JUnit。 JUnit是一个Java语言的单元测试框架。它由Kent Beck和Erich Gamma建立，逐渐成为源于Kent Beck的sUnit的xUnit家族中最为成功的一个。 JUnit有它自己的JUnit扩展生态圈。多数Java的开发环境都已经集成了JUnit作为单元测试的工具。 下面是一些具体的编写测试代码的技巧或较好的实践方法： 1. 不要用TestCase的构造函数初始化Fixture，而要用setUp()和tearDown()方法。 2. 不要依赖或假定测试运行的顺序，因为JUnit利用Vector保存测试方法。所以不同的平台会按不同的顺序从Vector中取出测试方法。 3. 避免编写有副作用的TestCase。例如：如果随后的测试依赖于某些特定的交易数据，就不要提交交易数据。简单的回滚就可以了。 4. 当继承一个测试类时，记得调用父类的setUp()和tearDown()方法。 5. 将测试代码和工作代码放在一起，一边同步编译和更新。（使用Ant中有支持junit的task.） 6. 测试类和测试方法应该有一致的命名方案。如在工作类名前加上test从而形成测试类名。 7. 确保测试与时间无关，不要依赖使用过期的数据进行测试。导致在随后的维护过程中很难重现测试。 8. 如果你编写的软件面向国际市场，编写测试时要考虑国际化的因素。不要仅用母语的Locale进行测试。 9. 尽可能地利用JUnit提供地assert/fail方法以及异常处理的方法，可以使代码更为简洁。 10.测试要尽可能地小，执行速度快。 11.不要硬性规定数据文件的路径。 12.利用Junit 的自动异常处理书写简洁的测试代码 事实上在Junit 中使用try-catch 来捕获异常是没有必要的，Junit 会自动捕获异常。那些没有被捕获的异常就被当成错误处理。 13. 充分利用Junit 的assert/fail 方法 assertSame()用来测试两个引用是否指向同一个对象 assertEquals()用来测试两个对象是否相等 14. 确保测试代码与时间无关 15. 使用文档生成器做测试文档。
