| // |
| // Licensed to the Apache Software Foundation (ASF) under one |
| // or more contributor license agreements. See the NOTICE file |
| // distributed with this work for additional information |
| // regarding copyright ownership. The ASF licenses this file |
| // to you under the Apache License, Version 2.0 (the |
| // "License"); you may not use this file except in compliance |
| // with the License. You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, |
| // software distributed under the License is distributed on an |
| // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| // KIND, either express or implied. See the License for the |
| // specific language governing permissions and limitations |
| // under the License. |
| // |
| |
| = 在 NetBeans IDE 中编写 JUnit 测试 |
| :jbake-type: tutorial |
| :jbake-tags: tutorials |
| :jbake-status: published |
| :icons: font |
| :syntax: true |
| :source-highlighter: pygments |
| :toc: left |
| :toc-title: |
| :description: 在 NetBeans IDE 中编写 JUnit 测试 - Apache NetBeans |
| :keywords: Apache NetBeans, Tutorials, 在 NetBeans IDE 中编写 JUnit 测试 |
| |
| 本教程介绍在 NetBeans IDE 中编写和运行 JUnit 测试的基础知识。测试应用程序是开发周期中不可缺少的一部分，并且编写和维护测试单元有利于确保源代码中的方法能正常运行。IDE 集成了对 JUnit 单元测试框架的支持，它允许您快速和轻松地创建 JUnit 测试和测试套件。 |
| |
| 在本教程中，您将为 Java 类库项目创建简单的 JUnit 3 和 JUnit 4 单元测试及测试套件。教程的第 1 部分演示如何在 JUnit 3 中创建测试。第 2 部分演示如何使用 JUnit 标注在 JUnit 4 中创建相同的测试。这两部分创建的测试是相同的，因此没必要同时完成这两部分的内容，但是查看两个版本的测试编写方法可以帮助您了解 JUnit 4 中引入的一些变化。 |
| |
| 有关使用 JUnit 的更多信息，请参见 link:http://www.junit.org[+www.junit.org+]。 |
| |
| |
| image::images/netbeans-stamp-80-74-73.png[title="此页上的内容适用于 NetBeans IDE 7.2、7.3、7.4 和 8.0"] |
| |
| |
| *要学习本教程，您需要具备以下软件和资源。* |
| |
| |=== |
| |软件或资源 |要求的版本 |
| |
| |link:https://netbeans.org/downloads/index.html[+NetBeans IDE+] |7.2, 7.3, 7.4, 8.0 |
| |
| |link:http://www.oracle.com/technetwork/java/javase/downloads/index.html[+Java 开发工具包 (JDK)+] |版本 7 或 8 |
| |
| |JUnitSampleSol 项目 |link:https://netbeans.org/projects/samples/downloads/download/Samples/Java/JUnitSampleSol.zip[+下载+] |
| |=== |
| |
| 要执行本教程中的步骤，您需要从更新中心安装 JUnit 插件。如果在安装 IDE 时未安装 JUnit 插件，可以在插件管理器中安装此插件。 |
| |
| |
| == 创建项目 |
| |
| 要完成本教程，您首先需要创建一个名称为 JUnit-Sample 的 Java 类库项目。创建项目后，您需要将样例项目 JUnitSampleSol 中的两个类复制到项目 JUnit-Sample 中。 |
| |
| |
| === 创建 Java 类库项目 |
| |
| 1. 从主菜单中选择 "File"（文件）> "New Project"（新建项目）。 |
| 2. 从 "Java" 类别中选择 "Java Class Library"（Java 类库）并单击 "Next"（下一步）。 |
| 3. 键入 *JUnit-Sample* 作为项目名称并设置项目位置。 |
| 4. 取消选中 "Use Dedicated Folder"（使用专用文件夹）选项（如果该选项处于选中状态）。 |
| |
| 在本教程中，我们将项目库复制到一个专门的文件夹中，因为需要与其他用户或项目共享库。 |
| |
| 单击 "Finish"（完成）。 |
| |
| 首次创建 JUnit 测试时，IDE 将提示您选择一个版本，然后依次添加 "Test Libraries"（测试库）节点和 "JUnit" 库。 |
| |
| |
| === 下载解决方案项目 |
| |
| 您可以采用下列方法下载本教程中使用的样例项目 JUnitSampleSol。 |
| |
| * 下载link:https://netbeans.org/projects/samples/downloads/download/Samples/Java/JUnitSampleSol.zip[+已完成项目的 zip 档案文件+]。 |
| * 通过执行以下步骤从 NetBeans 样例检出项目源代码： |
| 1. 从主菜单中选择 "Team"（团队开发）> "Subversion" > "Checkout"（检出）。 |
| 2. 在 "Checkout"（检出）对话框中，输入以下资源库 URL： |
| ``https://svn.netbeans.org/svn/samples~samples-source-code`` |
| 单击 "Next"（下一步）。 |
| |
| [start=3] |
| . 在 "Folders to Checkout"（要检出的文件夹）面板中，单击 "Browse"（浏览），以打开 "Browse Repository Folders"（浏览资源库文件夹）对话框。 |
| |
| [start=4] |
| . 展开根节点，然后选择 *samples/java/JUnitSampleSol*。单击 "OK"（确定）。 |
| |
| [start=5] |
| . 指定用于存储源代码的 "Local Folder"（本地文件夹）。单击 "Finish"（完成）。 |
| |
| 单击 "Finish"（完成），此时 IDE 会将本地文件夹初始化为 Subversion 资源库，并检出项目源代码。 |
| |
| |
| [start=6] |
| . 在完成检出操作后将会显示一个对话框，在该对话框中单击 "Open Project"（打开项目）。 |
| |
| 有关安装 Subversion 的更多信息，请参见 link:../ide/subversion.html[+NetBeans IDE 中的 Subversion 指南+]中有关link:../ide/subversion.html#settingUp[+设置 Subversion+] 的部分。 |
| |
| *注：*如果在安装 IDE 时未安装 JUnit 插件，则在打开 NetBeans 项目时将提示您安装 JUnit 插件以解析对 JUnit 库的引用。 |
| |
| |
| === 创建 Java 类 |
| |
| 在本练习中，您需要将样例项目 JUnitSampleSol 中的文件 ``Utils.java`` 和 ``Vectors.java`` 复制到您创建的类库项目中。 |
| |
| 1. 在 "Projects"（项目）窗口中，右键单击 *JUnit-Sample* 项目的 "Source Packages"（源包）节点，然后从弹出式菜单中选择 "New"（新建）> "Java Package"（Java 包）。 |
| 2. 键入 *sample* 作为包名。单击 "Finish"（完成）。 |
| 3. 在 "Projects"（项目）窗口中，打开 *JUnitSampleSol* 项目（如果尚未打开），然后展开 "Source Packages"（源包）节点。 |
| image::images/projects-window.png[title=""Projects"（项目）窗口中的 JUnit-Sample 和 JUnitSampleSol 项目"] |
| |
| [start=4] |
| . 复制 JUnitSampleSol 项目中的 ``Utils.java`` 和 ``Vectors.java`` 类，然后将其粘贴到 JUnit-Sample 的 ``sample`` 源包中。 |
| |
| 如果查看这些类的源代码，则可以看到 ``Utils.java`` 包含三个方法（ ``computeFactorial`` 、 ``concatWords`` 和 ``normalizeWord`` ），而 ``Vectors.java`` 包含两个方法（ ``equal`` 和 ``scalarMultiplication`` ）。接下来，为各类创建测试类并为这些方法编写一些测试用例。 |
| |
| *注：*您可以关闭 JUnitSampleSol 项目，因为不再需要它。JUnitSampleSol 项目包含本文档所述的所有测试。 |
| |
| |
| == 编写 JUnit 3 单元测试 |
| |
| 在本节中，您将为 ``Vectors.java`` 和 ``Utils.java`` 类创建基本的 JUnit 3 单元测试。您将使用 IDE 根据您项目中的类来创建框架测试类。然后，您将修改生成的测试方法并添加新测试方法。 |
| |
| 第一次使用 IDE 在项目中创建测试时，IDE 将提示您选择一个 JUnit 版本。您选择的版本将成为默认的 JUnit 版本，并且 IDE 将为该版本生成所有后续测试和测试套件。 |
| |
| |
| === 为 ``Vectors.java`` 创建测试类 |
| |
| 在本练习中，您将为 ``Vectors.java`` 创建一个 JUnit 测试框架。您还将选择 JUnit 作为测试框架，并选择 JUnit 3 作为版本。 |
| |
| *注：*如果您使用的是 NetBeans IDE 7.1 或更早版本，则不需要指定测试框架，因为默认情况下将指定 JUnit。在 NetBeans IDE 7.2 中，您可以选择指定 JUnit 或 TestNG 作为测试框架。 |
| |
| 1. 右键单击 ``Vectors.java`` 并选择 "Tools"（工具）> "Create Tests"（创建测试）。 |
| 2. 在 "Create Tests"（创建测试）对话框中，将测试类的名称修改为 *VectorsJUnit3Test*。 |
| |
| 更改测试类的名称之后，您将看到一个关于修改名称的警告。默认名称基于要测试的类名，并在该名称后面附加单词 Test。举例来说，对于 ``MyClass.java`` 类，测试类的默认名称为 ``MyClassTest.java`` 。通常，最好是保留默认名称，但是在教程中您将更改该名称，因为您还将在相同的包中创建 JUnit 4 测试，并且测试类的名称必须是惟一的。 |
| |
| |
| [start=3] |
| . 在 "Framework"（框架）下拉列表中选择 "JUnit"。 |
| |
| [start=4] |
| . 取消选中 "Test Initializer"（测试初始化函数）和 "Test Finalizer"（测试终结方法）。单击 "OK"（确定）。 |
| image::images/junit3-vectors-createtests.png[title="选择 "JUnit version"（JUnit 版本）对话框"] |
| |
| [start=5] |
| . 在 "Select JUnit Version"（选择 JUnit 版本）对话框中，选择 "JUnit 3.x"。 |
| image::images/junit3-select-version.png[title="选择 "JUnit version"（JUnit 版本）对话框"] |
| |
| 选择 "JUnit 3.x" 时，IDE 会将 JUnit 3 库添加到项目中。 |
| |
| 单击 "Select"（选择）后，IDE 将在 "Projects"（项目）窗口 "Test Packages"（测试包）节点下方的 ``sample`` 包中生成 ``VectorsJUnit3Test.java`` 测试类。 |
| |
| image::images/projects-window2.png[title=""Projects"（项目）窗口中 JUnit-Sample 项目的结构"] |
| |
| 项目需要一个目录供测试包创建测试。测试包目录的默认位置为项目的根目录，但是根据项目的不同，您可以在项目的 "Properties"（属性）对话框中为目录指定不同的位置。 |
| |
| 在编辑器中查看生成的测试类 ``VectorsJUnit3Test.java`` ，您可以看到 IDE 为 ``equal`` 和 ``scalarMultiplication`` 方法生成了以下具备测试方法的测试类。 |
| |
| |
| [source,java] |
| ---- |
| |
| public class VectorsJUnit3Test extends TestCase { |
| /** |
| * Test of equal method, of class Vectors. |
| */ |
| public void testEqual() { |
| System.out.println("equal"); |
| int[] a = null; |
| int[] b = null; |
| boolean expResult = false; |
| boolean result = Vectors.equal(a, b); |
| assertEquals(expResult, result); |
| // TODO review the generated test code and remove the default call to fail. |
| fail("The test case is a prototype."); |
| } |
| |
| /** |
| * Test of scalarMultiplication method, of class Vectors. |
| */ |
| public void testScalarMultiplication() { |
| System.out.println("scalarMultiplication"); |
| int[] a = null; |
| int[] b = null; |
| int expResult = 0; |
| int result = Vectors.scalarMultiplication(a, b); |
| assertEquals(expResult, result); |
| // TODO review the generated test code and remove the default call to fail. |
| fail("The test case is a prototype."); |
| } |
| } |
| ---- |
| |
| 各生成测试的方法主体是作为指导单独提供的，因此需要将它们修改为实际的测试用例。如果您不需要生成的代码，可以在 "Create Tests"（创建测试）对话框中取消选中 "Default Method Bodies"（默认方法主体）。 |
| |
| IDE 生成测试方法的名称时，各方法名称将前面附加一个 ``test`` ，因为 JUnit 3 使用命名惯例和反射来标识测试。要标识测试方法，各测试方法需要遵循 ``test_<NAME>_`` 这一语法。 |
| |
| *注：*在 JUnit 4 中，不再需要使用这种测试方法命名语法，因为您可以使用标注来标识测试方法，并且测试类不再需要扩展 ``TestCase`` 。 |
| |
| |
| |
| |
| === 为 ``Vectors.java`` 编写测试方法 |
| |
| 在本练习中，您将修改生成的方法以实现测试功能，并修改默认的输出消息。您不需要修改运行测试的输出消息，但是您可能希望修改输出来帮助标识显示在 "JUnit Test Results"（JUnit 测试结果）输出窗口中的结果。 |
| |
| 1. 在编辑器中打开 ``VectorsJUnit3Test.java`` 。 |
| 2. 修改 ``testScalarMultiplication`` 的测试框架，方法是修改 ``println`` 的值并删除生成的变量。现在，测试方法应如下所示（粗体为更改部分）： |
| |
| [source,java] |
| ---- |
| |
| public void testScalarMultiplication() { |
| System.out.println("** VectorsJUnit3Test: testScalarMultiplication()*"); |
| assertEquals(expResult, result); |
| } |
| ---- |
| |
| [start=3] |
| . 现在，添加一些断言来测试方法。 |
| |
| [source,java] |
| ---- |
| |
| public void testScalarMultiplication() { |
| System.out.println("* VectorsJUnit3Test: testScalarMultiplication()"); |
| *assertEquals( 0, Vectors.scalarMultiplication(new int[] { 0, 0}, new int[] { 0, 0})); |
| assertEquals( 39, Vectors.scalarMultiplication(new int[] { 3, 4}, new int[] { 5, 6})); |
| assertEquals(-39, Vectors.scalarMultiplication(new int[] {-3, 4}, new int[] { 5,-6})); |
| assertEquals( 0, Vectors.scalarMultiplication(new int[] { 5, 9}, new int[] {-9, 5})); |
| assertEquals(100, Vectors.scalarMultiplication(new int[] { 6, 8}, new int[] { 6, 8}));* |
| } |
| ---- |
| |
| 该测试方法使用 JUnit ``assertEquals`` 方法。要使用断言，您需要提供输入变量和预期的结果。在运行被测试的方法时，要通过测试，测试方法必须根据提供的变量成功返回所有预期的结果。您应该添加足够数量的断言来涵盖各种可能的排列。 |
| |
| |
| [start=4] |
| . 修改 ``testEqual`` 的测试框架：删除生成的方法主体并添加以下 ``println`` 。 |
| |
| [source,java] |
| ---- |
| |
| *System.out.println("* VectorsJUnit3Test: testEqual()");* |
| ---- |
| |
| 现在，测试方法应如下所示： |
| |
| |
| [source,java] |
| ---- |
| |
| public void testEqual() { |
| System.out.println("* VectorsJUnit3Test: testEqual()"); |
| } |
| ---- |
| |
| [start=5] |
| . 修改 ``testEqual`` 方法：添加以下断言（显示为粗体）。 |
| |
| [source,java] |
| ---- |
| |
| public void testEqual() { |
| System.out.println("* VectorsJUnit3Test: testEqual()"); |
| *assertTrue(Vectors.equal(new int[] {}, new int[] {})); |
| assertTrue(Vectors.equal(new int[] {0}, new int[] {0})); |
| assertTrue(Vectors.equal(new int[] {0, 0}, new int[] {0, 0})); |
| assertTrue(Vectors.equal(new int[] {0, 0, 0}, new int[] {0, 0, 0})); |
| assertTrue(Vectors.equal(new int[] {5, 6, 7}, new int[] {5, 6, 7})); |
| |
| assertFalse(Vectors.equal(new int[] {}, new int[] {0})); |
| assertFalse(Vectors.equal(new int[] {0}, new int[] {0, 0})); |
| assertFalse(Vectors.equal(new int[] {0, 0}, new int[] {0, 0, 0})); |
| assertFalse(Vectors.equal(new int[] {0, 0, 0}, new int[] {0, 0})); |
| assertFalse(Vectors.equal(new int[] {0, 0}, new int[] {0})); |
| assertFalse(Vectors.equal(new int[] {0}, new int[] {})); |
| |
| assertFalse(Vectors.equal(new int[] {0, 0, 0}, new int[] {0, 0, 1})); |
| assertFalse(Vectors.equal(new int[] {0, 0, 0}, new int[] {0, 1, 0})); |
| assertFalse(Vectors.equal(new int[] {0, 0, 0}, new int[] {1, 0, 0})); |
| assertFalse(Vectors.equal(new int[] {0, 0, 1}, new int[] {0, 0, 3}));* |
| } |
| ---- |
| |
| 此方法使用 JUnit ``assertTrue`` 和 ``assertFalse`` 方法来测试各种可能的结果。要通过此方法的测试， ``assertTrue`` 必须全部为 true，并且 ``assertFalse`` 必须全部为 false。 |
| |
| |
| [start=6] |
| . 保存所做的更改。 |
| |
| 比较：<<Exercise_32,为 ``Vectors.java`` 编写测试方法（JUnit 4）>> |
| |
| |
| |
| |
| === 为 ``Utils.java`` 创建测试类 |
| |
| 现在，您可以为 ``Utils.java`` 创建测试框架。在上一练习中创建了测试之后，IDE 会提示您选择 JUnit 的版本。但这次，并没有提示要求您选择版本。 |
| |
| 1. 右键单击 ``Utils.java`` 并选择 "Tools"（工具）> "Create Tests"（创建测试）。 |
| 2. 在 "Framework"（框架）下拉列表中选择 "JUnit"（如果未选中）。 |
| 3. 在对话框中，选中 "Test Initializer"（测试初始化函数）和 "Test Finalizer"（测试终结方法）（如果未选中）。 |
| 4. 在 "Create Tests"（创建测试）对话框中，将测试类的名称修改为 *UtilsJUnit3Test*。单击 "OK"（确定）。 |
| |
| 单击 "OK"（确定）之后，IDE 将在 "Test Packages"（测试包）> "samples"（样例）目录中创建测试文件 ``UtilsJUnit3Test.java`` 。可以看到，除了为 ``Utils.java`` 中的方法创建 ``testComputeFactorial`` 、 ``testConcatWords`` 和 ``testNormalizeWord`` 测试框架之外，IDE 还创建了测试初始化函数方法 ``setUp`` 和测试终结方法 ``tearDown`` 。 |
| |
| |
| |
| |
| === 为 ``Utils.java`` 编写测试方法 |
| |
| 在本练习中，您将添加一些测试用例来演示一些常用的 JUnit 测试元素。您还将在方法中添加 ``println`` ，因为一些方法默认不打印任何输出。通过在方法中添加 ``println`` ，您可以稍后在 JUnit 测试结果窗口中查看方法是否已经运行以及它们运行的顺序。 |
| |
| |
| ==== 测试初始化函数和终结方法 |
| |
| ``setUp`` 和 ``tearDown`` 方法用于初始化和释放测试条件。您不需要使用 ``setUp`` 和 ``tearDown`` 方法来测试 ``Utils.java`` ，但是此处演示了它们的运行原理。 |
| |
| ``setUp`` 方法是一个测试初始化方法，它在测试类中的各测试用例之前运行。运行测试不需要测试初始化方法，但是，如果您需要在运行测试之前初始化一些变量，则可以使用测试初始化方法。 |
| |
| ``tearDown`` 方法是一个测试终结方法，它在测试类中的各测试用例之后运行。运行测试不需要测试终结方法，但是，您可能需要使用终结方法来清理运行测试用例时所需的任何数据。 |
| |
| 1. 执行以下更改（显示为粗体），在各方法中添加一个 ``println`` 。 |
| |
| [source,java] |
| ---- |
| |
| @Override |
| protected void setUp() throws Exception { |
| super.setUp(); |
| *System.out.println("* UtilsJUnit3Test: setUp() method");* |
| } |
| |
| @Override |
| protected void tearDown() throws Exception { |
| super.tearDown(); |
| *System.out.println("* UtilsJUnit3Test: tearDown() method");* |
| } |
| ---- |
| |
| 运行测试时，各方法的 ``println`` 文本将出现在 "JUnit Test Results"（JUnit 测试结果）输出窗口中。如果您没有添加 ``println`` ，则不会在输出中显示方法已经运行。 |
| |
| |
| ==== 在测试中使用简单的断言 |
| |
| 这个简单的测试用例将测试 ``concatWords`` 方法。您没有使用生成的 ``testConcatWords`` 测试方法，而是使用新的 ``testHelloWorld`` 测试方法，该方法使用单个简单的断言来测试方法是否正确地连接了字符串。测试用例中的 ``assertEquals`` 将使用 ``assertEquals(_EXPECTED_RESULT, ACTUAL_RESULT_)`` 语法来测试预期结果是否等于实际结果。在本例中，如果 ``concatWords`` 方法的输入为 " ``Hello`` "、" ``, `` "、" ``world`` " 和 " ``!`` "，则预期结果应该等于 ``"Hello, world!"`` 。 |
| |
| 1. 删除在 ``UtilsJUnit3Test.java`` 中生成的 ``testConcatWords`` 测试方法。 |
| 2. 添加以下方法来测试 ``concatWords`` 方法。*public void testHelloWorld() { |
| assertEquals("Hello, world!", Utils.concatWords("Hello", ", ", "world", "!")); |
| }* |
| |
| [start=3] |
| . 添加一个 ``println`` 语句，用于在 "JUnit Test Results"（JUnit 测试结果）窗口中显示关于测试的文本。 |
| |
| [source,java] |
| ---- |
| |
| public void testHelloWorld() { |
| *System.out.println("* UtilsJUnit3Test: test method 1 - testHelloWorld()");* |
| assertEquals("Hello, world!", Utils.concatWords("Hello", ", ", "world", "!")); |
| ---- |
| |
| 比较：<<Exercise_342,在测试中使用简单的断言（JUnit 4）>> |
| |
| |
| ==== 在测试中使用超时 |
| |
| 此测试演示如何检查方法的完成是否花费了过长的时间。如果方法花费了过长的时间，则测试线程将中断并导致测试失败。您可以在测试中指定时间限制。 |
| |
| 测试方法将调用 ``Utils.java`` 中的 ``computeFactorial`` 方法。您可以假定 ``computeFactorial`` 方法是正确的，但是在本例中，您希望测试计算是否是在 1000 毫秒之内完成的。 ``computeFactorial`` 线程和测试线程是在相同时间启动的。测试线程将在 1000 毫秒过后停止并抛出一个 ``TimeoutException`` 异常错误，除非 ``computeFactorial`` 线程先于它完成。您将添加一条消息，这样在抛出 ``TimeoutException`` 时会显示该消息。 |
| |
| 1. 删除生成的测试方法 ``testComputeFactorial`` 。 |
| 2. 添加 ``testWithTimeout`` 方法，该方法用于计算随机生成数的阶乘。*public void testWithTimeout() throws InterruptedException, TimeoutException { |
| final int factorialOf = 1 + (int) (30000 * Math.random()); |
| System.out.println("computing " + factorialOf + '!'); |
| |
| Thread testThread = new Thread() { |
| public void run() { |
| System.out.println(factorialOf + "! = " + Utils.computeFactorial(factorialOf)); |
| } |
| }; |
| }* |
| |
| [start=3] |
| . 修复导入，以导入 ``java.util.concurrent.TimeoutException`` 。 |
| |
| [start=4] |
| . 在方法中添加以下代码（显示为粗体），其作用是当测试任务的执行时间过长时中断线程并显示一条消息。 |
| |
| [source,java] |
| ---- |
| |
| Thread testThread = new Thread() { |
| public void run() { |
| System.out.println(factorialOf + "! = " + Utils.computeFactorial(factorialOf)); |
| } |
| }; |
| |
| *testThread.start(); |
| Thread.sleep(1000); |
| testThread.interrupt(); |
| |
| if (testThread.isInterrupted()) { |
| throw new TimeoutException("the test took too long to complete"); |
| }* |
| } |
| ---- |
| |
| 在抛出超时之前，您可以通过修改 ``Thread.sleep`` 代码行来更改毫秒数。 |
| |
| |
| [start=5] |
| . 添加以下 ``println`` （显示为粗体），用于在 "JUnit Test Results"（JUnit 测试结果）窗口中输出关于测试的文本。 |
| |
| [source,java] |
| ---- |
| |
| public void testWithTimeout() throws InterruptedException, TimeoutException { |
| *System.out.println("* UtilsJUnit3Test: test method 2 - testWithTimeout()");* |
| final int factorialOf = 1 + (int) (30000 * Math.random()); |
| System.out.println("computing " + factorialOf + '!'); |
| |
| ---- |
| |
| 比较：<<Exercise_343,在测试中使用超时（JUnit 4）>> |
| |
| |
| ==== 针对预期异常错误的测试 |
| |
| 此测试演示如何针对预期异常错误进行测试。如果未抛出指定的预期异常错误，则会导致方法失败。在本例中，您将测试当输入变量为负数时（-5）， ``computeFactorial`` 方法是否会抛出 ``IllegalArgumentException`` 。 |
| |
| 1. 添加以下 ``testExpectedException`` 方法，它将以输入 -5 调用 ``computeFactorial`` 方法。*public void testExpectedException() { |
| try { |
| final int factorialOf = -5; |
| System.out.println(factorialOf + "! = " + Utils.computeFactorial(factorialOf)); |
| fail("IllegalArgumentException was expected"); |
| } catch (IllegalArgumentException ex) { |
| } |
| }* |
| |
| [start=2] |
| . 添加以下 ``println`` （显示为粗体），用于在 "JUnit Test Results"（JUnit 测试结果）窗口中输出关于测试的文本。 |
| |
| [source,java] |
| ---- |
| |
| public void testExpectedException() { |
| *System.out.println("* UtilsJUnit3Test: test method 3 - testExpectedException()");* |
| try { |
| ---- |
| |
| 比较：<<Exercise_344,针对预期异常错误的测试（JUnit 4）>> |
| |
| |
| ==== 禁用测试 |
| |
| 此测试演示如何临时禁用测试方法。在 JUnit 3 中，如果某个方法名称没有以 ``test`` 开头，则它不会被识别为测试方法。在这种情况下，将 ``DISABLED_`` 放在测试方法名称之前即可禁用它。 |
| |
| 1. 删除生成的测试方法 ``testNormalizeWord`` 。 |
| 2. 在测试类中添加以下测试方法。*public void testTemporarilyDisabled() throws Exception { |
| System.out.println("* UtilsJUnit3Test: test method 4 - checkExpectedException()"); |
| assertEquals("Malm\u00f6", Utils.normalizeWord("Malmo\u0308")); |
| }* |
| |
| 测试方法 ``testTemporarilyDisabled`` 将在您运行测试类时运行。 |
| |
| |
| [start=3] |
| . 将 ``DISABLED_`` （显示为粗体）置于测试方法的名称之前。 |
| |
| [source,java] |
| ---- |
| |
| public void *DISABLED_*testTemporarilyDisabled() throws Exception { |
| System.out.println("* UtilsJUnit3Test: test method 4 - checkExpectedException()"); |
| assertEquals("Malm\u00f6", Utils.normalizeWord("Malmo\u0308")); |
| } |
| ---- |
| |
| 比较：<<Exercise_345,禁用测试（JUnit 4）>> |
| |
| 现在，您已经编写了测试。接下来，您可以运行测试并在 "JUnit Test Results"（JUnit 测试结果）窗口中查看测试输出。 |
| |
| |
| |
| |
| === 运行测试 |
| |
| 运行 JUnit 测试之后，结果将显示在 IDE 的 "Test Results"（测试结果）窗口中。您可以单独运行 JUnit 测试类，或者也可以从主菜单中选择 "Run"（运行）> "Test _PROJECT_NAME_"（测试 PROJECT_NAME）来运行项目的所有测试。如果您选择 "Run"（运行）> "Test"（测试），则 IDE 将运行 "Test Packages"（测试包）文件夹中的所有测试类。要运行单独的测试类，右键单击 "Test Packages"（测试包）节点下的测试类并选择 "Run File"（运行文件）。 |
| |
| 1. 在主菜单中选择 "Run"（运行）> "Set Main Project"（设置为主项目），然后选择 "JUnit-Sample" 项目。 |
| 2. 从主菜单中选择 "Run"（运行）> "Test Project (JUnit-Sample)"（测试项目 (JUnit-Sample)）。 |
| 3. 选择 "Window"（窗口）> "IDE Tools"（IDE 工具）> "Test Results"（测试结果）以打开 "Test Results"（测试结果）窗口。 |
| |
| 运行测试之后，您将在 "JUnit Test Results"（JUnit 测试结果）窗口中看到以下结果之一。 |
| |
| [.feature] |
| -- |
| image:images/junit3-test-pass-sm.png[role="left", link="images/junit3-test-pass.png"] |
| -- |
| |
| 在此图像中（单击图像查看大图），您可以看到项目通过了所有测试。左侧窗格显示各测试方法的结果，右侧窗格显示测试输出。如果您查看输出，您可以看到测试运行的顺序。添加到各测试方法中的 ``println`` 在输出窗口中输出测试的名称。您还可以看到，在 ``UtilJUnit3Test`` 中， ``setUp`` 方法在各测试方法之前运行，而 ``tearDown`` 方法在各方法之后运行。 |
| |
| [.feature] |
| -- |
| image:images/junit3-test-fail-sm.png[role="left", link="images/junit3-test-fail.png"] |
| -- |
| |
| 在此图像中（单击图像查看大图），您可以看到项目未通过其中一个测试。 ``testTimeout`` 方法花费了过长的运行时间，并且测试线程被中断，导致测试失败。它花了超过 1000 毫秒来计算出随机生成数（22991）的阶乘。 |
| |
| 创建单元测试类后，下一步将创建测试套件。请参见<<Exercise_41,创建 JUnit 3 测试套件>>，了解如何以组的方式运行特定的测试，从而避免单独运行各个测试。 |
| |
| |
| == 编写 JUnit 4 测试 |
| |
| 在本练习中，您将为 ``Vectors.java`` 和 ``Utils.java`` 创建 JUnit 4 单元测试。JUnit 4 测试用例与 JUnit 3 测试用例相同，但是您会发现其编写测试的语法更加简单。 |
| |
| 您将使用 IDE 的向导根据项目中的类来创建测试框架。第一次使用 IDE 创建测试框架时，IDE 会提示您选择 JUnit 版本。 |
| |
| *注：*如果已选择 JUnit 3.x 作为默认测试版本，则需要将默认版本更改为 JUnit 4.x。要更改默认的 JUnit 版本，请展开 "Test Libraries"（测试库）节点，右键单击 "JUnit" 库，然后选择 "Remove"（删除）。现在，您可以使用 "Add Library"（添加库）对话框来明确添加 "JUnit 4" 库，也可以在创建新测试期间系统提示您选择 JUnit 版本时选择版本 4.x。您仍然可以运行 JUnit 3 测试，但是您创建的任何新测试都将使用 JUnit 4。 |
| |
| |
| === 为 ``Vectors.java`` 创建测试类 |
| |
| 在本练习中，您将为 ``Vectors.java`` 创建 JUnit 测试框架。 |
| |
| *注：*如果您使用的是 NetBeans IDE 7.1 或更早版本，则不需要指定测试框架，因为默认情况下将指定 JUnit。在 NetBeans IDE 7.2 中，您可以选择指定 JUnit 或 TestNG 作为测试框架。 |
| |
| 1. 右键单击 ``Vectors.java`` 并选择 "Tools"（工具）> "Create Tests"（创建测试）。 |
| 2. 在 "Create Tests"（创建测试）对话框中，将测试类的名称修改为 *VectorsJUnit4Test*。 |
| |
| 更改测试类的名称之后，您将看到一个关于修改名称的警告。默认名称基于要测试的类名，并在该名称后面附加单词 Test。举例来说，对于 ``MyClass.java`` 类，测试类的默认名称为 ``MyClassTest.java`` 。与 JUnit 3 不同，在 JUnit 4 中，测试不需要以单词 Test 结尾。通常，最好是保留默认名称，但由于在本教程中您将在相同的包中创建所有 JUnit 测试，因此测试类的名称必须是惟一的。 |
| |
| |
| [start=3] |
| . 在 "Framework"（框架）下拉列表中选择 "JUnit"。 |
| |
| [start=4] |
| . 取消选中 "Test Initializer"（测试初始化函数）和 "Test Finalizer"（测试终结方法）。单击 "OK"（确定）。 |
| image::images/junit4-vectors-createtests.png[title="JUnit 4 "Create Tests"（创建测试）对话框"] |
| |
| [start=5] |
| . 在 "Select JUnit Version"（选择 JUnit 版本）对话框中，选择 "JUnit 4.x"。单击 "Select"（选择）。 |
| image::images/junit4-select-version.png[title="选择 "JUnit version"（JUnit 版本）对话框"] |
| |
| 单击 "OK"（确定）后，IDE 将在 "Projects"（项目）窗口 "Test Packages"（测试包）节点下方的 ``sample`` 包中创建 ``VectorsJUnit4Test.java`` 测试类。 |
| |
| image::images/projects-window3.png[title="包含 JUnit 3 和 JUnit 4 测试类的 JUnit-Sample 项目的结构"] |
| |
| *注：*项目需要一个目录供测试包创建测试。测试包目录的默认位置为项目的根目录，但是根据项目的类型不同，您可以在项目的 "Properties"（属性）对话框中为目录指定不同的位置。 |
| |
| 在编辑器中查看 ``VectorsJUnit3Test.java`` ，您可以看到 IDE 生成了测试方法 ``testEqual`` 和 ``testScalarMultiplication`` 。在 ``VectorsJUnit4Test.java`` 中，每个测试方法都使用 ``@Test`` 进行标注。IDE 根据 ``Vectors.java`` 中的方法的名称为测试方法生成了名称，但是，不需要将 ``test`` 置于测试方法的名称之前。各生成测试方法的默认主体是作为指导单独提供的，因此需要将它们修改为实际的测试用例。 |
| |
| 如果您不需要生成的方法主体，可以在 "Create Tests"（创建测试）对话框中取消选中 "Default Method Bodies"（默认方法主体）”。 |
| |
| IDE 还生成了以下测试类初始化函数和终结方法： |
| |
| |
| [source,java] |
| ---- |
| |
| @BeforeClass |
| public static void setUpClass() throws Exception { |
| } |
| |
| @AfterClass |
| public static void tearDownClass() throws Exception { |
| } |
| ---- |
| |
| 创建 JUnit 4 测试类时，IDE 会生成默认的类初始化函数和终结方法。标注 ``@BeforeClass`` 和 ``@AfterClass`` 用于标记应在测试类之前及之后运行的方法。您可以删除这些方法，因为您在 ``Vectors.java`` 测试时不需要它们。 |
| |
| 您可以通过在 "Options"（选项）窗口中配置 "JUnit" 选项来配置默认生成的方法。 |
| |
| *注：*对于 JUnit 4 测试，请注意默认情况下 IDE 为 ``org.junit.Assert.*`` 添加静态导入声明。 |
| |
| |
| |
| |
| === 为 ``Vectors.java`` 编写测试方法 |
| |
| 在本练习中，您将修改生成的各测试方法：使用 JUnit ``assert`` 方法来测试方法，并更改测试方法的名称。在 JUnit 4 中，您在命名测试方法时拥有了更好的灵活性，因为测试方法是由 ``@Test`` 标注指示的，并且不需要将单词 ``test`` 置于测试方法之前。 |
| |
| 1. 在编辑器中打开 ``VectorsJUnit4Test.java`` 。 |
| 2. 修改 ``testScalarMultiplication`` 的测试框架，方法是修改方法名称、修改 ``println`` 的值并删除生成的变量。现在，测试方法应如下所示（粗体为更改部分）： |
| |
| [source,java] |
| ---- |
| |
| @Test |
| public void *ScalarMultiplicationCheck*() { |
| System.out.println("** VectorsJUnit4Test: ScalarMultiplicationCheck()*"); |
| assertEquals(expResult, result); |
| } |
| ---- |
| |
| *注：*在编写测试时，不需要更改打印的输出。在本练习中，其作用是能够更加轻松地识别输出窗口中的测试结果。 |
| |
| |
| [start=3] |
| . 现在，添加一些断言来测试方法。 |
| |
| [source,java] |
| ---- |
| |
| @Test |
| public void ScalarMultiplicationCheck() { |
| System.out.println("* VectorsJUnit4Test: ScalarMultiplicationCheck()"); |
| *assertEquals( 0, Vectors.scalarMultiplication(new int[] { 0, 0}, new int[] { 0, 0})); |
| assertEquals( 39, Vectors.scalarMultiplication(new int[] { 3, 4}, new int[] { 5, 6})); |
| assertEquals(-39, Vectors.scalarMultiplication(new int[] {-3, 4}, new int[] { 5,-6})); |
| assertEquals( 0, Vectors.scalarMultiplication(new int[] { 5, 9}, new int[] {-9, 5})); |
| assertEquals(100, Vectors.scalarMultiplication(new int[] { 6, 8}, new int[] { 6, 8}));* |
| } |
| ---- |
| |
| 在此测试方法中，您使用了 JUnit ``assertEquals`` 方法。要使用断言，您需要提供输入变量和预期的结果。在运行被测试的方法时，要通过测试，测试方法必须根据提供的变量成功返回所有预期的结果。您应该添加足够数量的断言来涵盖各种可能的排列。 |
| |
| |
| [start=4] |
| . 将 ``testEqual`` 测试方法的名称更改为 ``equalsCheck`` 。 |
| |
| [start=5] |
| . 删除 ``equalsCheck`` 测试方法的已生成方法主体。 |
| |
| [start=6] |
| . 将以下 ``println`` 添加到 ``equalsCheck`` 测试方法中。*System.out.println("* VectorsJUnit4Test: equalsCheck()");* |
| |
| 现在，测试方法应如下所示： |
| |
| |
| [source,java] |
| ---- |
| |
| @Test |
| public void equalsCheck() { |
| System.out.println("* VectorsJUnit4Test: equalsCheck()"); |
| } |
| ---- |
| |
| [start=7] |
| . 修改 ``equalsCheck`` 方法：添加以下断言（显示为粗体）。 |
| |
| [source,java] |
| ---- |
| |
| @Test |
| public void equalsCheck() { |
| System.out.println("* VectorsJUnit4Test: equalsCheck()"); |
| *assertTrue(Vectors.equal(new int[] {}, new int[] {})); |
| assertTrue(Vectors.equal(new int[] {0}, new int[] {0})); |
| assertTrue(Vectors.equal(new int[] {0, 0}, new int[] {0, 0})); |
| assertTrue(Vectors.equal(new int[] {0, 0, 0}, new int[] {0, 0, 0})); |
| assertTrue(Vectors.equal(new int[] {5, 6, 7}, new int[] {5, 6, 7})); |
| |
| assertFalse(Vectors.equal(new int[] {}, new int[] {0})); |
| assertFalse(Vectors.equal(new int[] {0}, new int[] {0, 0})); |
| assertFalse(Vectors.equal(new int[] {0, 0}, new int[] {0, 0, 0})); |
| assertFalse(Vectors.equal(new int[] {0, 0, 0}, new int[] {0, 0})); |
| assertFalse(Vectors.equal(new int[] {0, 0}, new int[] {0})); |
| assertFalse(Vectors.equal(new int[] {0}, new int[] {})); |
| |
| assertFalse(Vectors.equal(new int[] {0, 0, 0}, new int[] {0, 0, 1})); |
| assertFalse(Vectors.equal(new int[] {0, 0, 0}, new int[] {0, 1, 0})); |
| assertFalse(Vectors.equal(new int[] {0, 0, 0}, new int[] {1, 0, 0})); |
| assertFalse(Vectors.equal(new int[] {0, 0, 1}, new int[] {0, 0, 3}));* |
| } |
| ---- |
| |
| 此方法使用 JUnit ``assertTrue`` 和 ``assertFalse`` 方法来测试各种可能的结果。要通过此方法的测试， ``assertTrue`` 必须全部为 true，并且 ``assertFalse`` 必须全部为 false。 |
| |
| 比较：<<Exercise_22,为 ``Vectors.java`` 编写测试方法（JUnit 3）>> |
| |
| |
| |
| |
| === 为 ``Utils.java`` 创建测试类 |
| |
| 现在，您将为 ``Utils.java`` 创建 JUnit 测试方法。在上一练习中创建了测试类之后，IDE 会提示您选择 JUnit 的版本。这次，IDE 并未提示您选择版本，因为您已经选择了 JUnit 版本，并且该版本中已经创建了所有后续 JUnit 测试。 |
| |
| *注：*如果您选择 JUnit 4 作为版本，那么仍然可以编写和运行 JUnit 3 测试，但是 IDE 将使用 JUnit 4 模板来生成测试框架。 |
| |
| 1. 右键单击 ``Utils.java`` 并选择 "Tools"（工具）> "Create Tests"（创建测试）。 |
| 2. 在 "Framework"（框架）下拉列表中选择 "JUnit"（如果未选中）。 |
| 3. 在对话框中，选中 "Test Initializer"（测试初始化函数）和 "Test Finalizer"（测试终结方法）（如果未选中）。 |
| 4. 在 "Create Tests"（创建测试）对话框中，将测试类的名称修改为 *UtilsJUnit4Test*。单击 "OK"（确定）。 |
| |
| 单击 "OK"（确定）后，IDE 将在 "Test Packages"（测试包）> "sample"（样例）目录中创建测试文件 ``UtilsJUnit4Test.java`` 。可以看到，IDE 为 ``Utils.java`` 中的方法生成了 ``testComputeFactorial`` 、 ``testConcatWords`` 和 ``testNormalizeWord`` 测试方法。IDE 还为测试和测试类生成了初始化函数和终结方法。 |
| |
| |
| |
| |
| === 为 ``Utils.java`` 编写测试方法 |
| |
| 在本练习中，您将添加一些测试用例来演示一些常用的 JUnit 测试元素。您还将在方法中添加一个 ``println`` ，因为一些方法不会在 "JUnit Test Results"（JUnit 测试结果）窗口中打印任何输出，以表示方法已运行或通过测试。通过在方法中添加 ``println`` ，您可以了解方法是否已经运行以及它们运行的顺序。 |
| |
| |
| ==== 测试初始化函数和终结方法 |
| |
| 为 ``Utils.java`` 创建测试类之后，IDE 将生成标注初始化函数和终结方法。您可以为方法选择任何名称，因为没有既定的命名惯例。 |
| |
| *注：*您不需要使用初始化函数和终结方法来测试 ``Utils.java`` ，但是本教程演示了它们的运行原理。 |
| |
| 在 JUnit 4 中，您可以使用标注来标记以下类型的初始化函数和终结方法。 |
| |
| * *测试类初始化程序。* ``@BeforeClass`` 标注将方法标记为测试类初始化方法。测试类初始化方法只能运行一次，并且在测试类中的任何其他方法之前运行。举例来说，您不必在测试初始化函数中创建数据库连接并在各测试方法之前创建新连接，您可以在运行测试之前使用测试类初始化函数打开连接。然后，您可以使用测试类终结方法来关闭连接。 |
| * *测试类终结方法。* ``@AfterClass`` 标注将方法标记为测试类终结方法。测试类终结方法只能运行一次，并且在测试类中的任何其他方法完成之后运行。 |
| * *测试初始化程序。* ``@Before`` 标注将方法标记为测试初始化方法。测试初始化方法在测试类中的各测试用例之前运行。运行测试不需要测试初始化方法，但是，如果您需要在运行测试之前初始化一些变量，则可以使用测试初始化方法。 |
| * *测试终结方法。* ``@After`` 标注将方法标记为测试终结方法。测试终结方法在测试类中的各测试用例之后运行。运行测试不需要测试终结方法，但是，您可能需要使用终结方法来清理运行测试用例时所需的任何数据。 |
| |
| 在 ``UtilsJUnit4Test.java`` 中进行如下更改（以粗体显示）。 |
| |
| |
| [source,java] |
| ---- |
| |
| @BeforeClass |
| public static void setUpClass() throws Exception { |
| *System.out.println("* UtilsJUnit4Test: @BeforeClass method");* |
| } |
| |
| @AfterClass |
| public static void tearDownClass() throws Exception { |
| *System.out.println("* UtilsJUnit4Test: @AfterClass method");* |
| } |
| |
| @Before |
| public void setUp() { |
| *System.out.println("* UtilsJUnit4Test: @Before method");* |
| } |
| |
| @After |
| public void tearDown() { |
| *System.out.println("* UtilsJUnit4Test: @After method");* |
| } |
| ---- |
| |
| 比较：<<Exercise_241,测试初始化函数和终结方法（JUnit 3）>> |
| |
| 运行测试类时，您添加的 ``println`` 文本将显示在 "JUnit Test Results"（JUnit 测试结果）窗口的输出窗格中。如果您没有添加 ``println`` ，则不会在输出中显示初始化函数和终结方法已经运行。 |
| |
| |
| ==== 在测试中使用简单的断言 |
| |
| 这个简单的测试用例将测试 ``concatWords`` 方法。您没有使用生成的 ``testConcatWords`` 测试方法，而是使用新的 ``helloWorldCheck`` 测试方法，该方法使用单个简单的断言来测试方法是否正确地连接了字符串。测试用例中的 ``assertEquals`` 将使用 ``assertEquals(_EXPECTED_RESULT, ACTUAL_RESULT_)`` 语法来测试预期结果是否等于实际结果。在本例中，如果 ``concatWords`` 方法的输入为 " ``Hello`` "、" ``, `` "、" ``world`` " 和 " ``!`` "，则预期结果应该等于 ``"Hello, world!"`` 。 |
| |
| 1. 删除生成的测试方法 ``testConcatWords`` 。 |
| 2. 添加以下 ``helloWorldCheck`` 方法来测试 ``Utils.concatWords`` 。*@Test |
| public void helloWorldCheck() { |
| assertEquals("Hello, world!", Utils.concatWords("Hello", ", ", "world", "!")); |
| }* |
| |
| [start=3] |
| . 添加一个 ``println`` 语句，用于在 "JUnit Test Results"（JUnit 测试结果）窗口中显示关于测试的文本。 |
| |
| [source,java] |
| ---- |
| |
| @Test |
| public void helloWorldCheck() { |
| *System.out.println("* UtilsJUnit4Test: test method 1 - helloWorldCheck()");* |
| assertEquals("Hello, world!", Utils.concatWords("Hello", ", ", "world", "!")); |
| ---- |
| |
| 比较：<<Exercise_242,在测试中使用简单的断言（JUnit 3）>> |
| |
| |
| ==== 在测试中使用超时 |
| |
| 此测试演示如何检查方法的完成是否花费了过长的时间。如果方法花费了过长的时间，则测试线程将中断并导致测试失败。您可以在测试中指定时间限制。 |
| |
| 测试方法将调用 ``Utils.java`` 中的 ``computeFactorial`` 方法。您可以假定 ``computeFactorial`` 方法是正确的，但是在本例中，您希望测试计算是否是在 1000 毫秒之内完成的。其作用是在 1000 毫秒之好中断测试线程。如果线程被中断，则测试方法将抛出一个 ``TimeoutException`` 。 |
| |
| 1. 删除生成的测试方法 ``testComputeFactorial`` 。 |
| 2. 添加 ``testWithTimeout`` 方法，该方法用于计算随机生成数的阶乘。*@Test |
| public void testWithTimeout() { |
| final int factorialOf = 1 + (int) (30000 * Math.random()); |
| System.out.println("computing " + factorialOf + '!'); |
| System.out.println(factorialOf + "! = " + Utils.computeFactorial(factorialOf)); |
| }* |
| |
| [start=3] |
| . 添加以下代码（显示为粗体），用于设置超时并在方法执行时间过长时中断线程。 |
| |
| [source,java] |
| ---- |
| |
| @Test*(timeout=1000)* |
| public void testWithTimeout() { |
| final int factorialOf = 1 + (int) (30000 * Math.random()); |
| ---- |
| |
| 可以看到，超时被设置为 1000 毫秒。 |
| |
| |
| [start=4] |
| . 添加以下 ``println`` （显示为粗体），用于在 "JUnit Test Results"（JUnit 测试结果）窗口中输出关于测试的文本。 |
| |
| [source,java] |
| ---- |
| |
| @Test(timeout=1000) |
| public void testWithTimeout() { |
| *System.out.println("* UtilsJUnit4Test: test method 2 - testWithTimeout()");* |
| final int factorialOf = 1 + (int) (30000 * Math.random()); |
| System.out.println("computing " + factorialOf + '!'); |
| |
| ---- |
| |
| 比较：<<Exercise_243,在测试中使用超时（JUnit 3）>> |
| |
| |
| ==== 针对预期异常错误的测试 |
| |
| 此测试演示如何针对预期异常错误进行测试。如果未抛出指定的预期异常错误，则会导致方法失败。在本例中，您将测试当输入变量为负数时（-5）， ``computeFactorial`` 方法是否会抛出 ``IllegalArgumentException`` 。 |
| |
| 1. 添加以下 ``testExpectedException`` 方法，它将以输入 -5 调用 ``computeFactorial`` 方法。*@Test |
| public void checkExpectedException() { |
| final int factorialOf = -5; |
| System.out.println(factorialOf + "! = " + Utils.computeFactorial(factorialOf)); |
| }* |
| |
| [start=2] |
| . 在 ``@Test`` 标注中添加以下属性（显示为粗体），指定测试应该抛出 ``IllegalArgumentException`` 。 |
| |
| [source,java] |
| ---- |
| |
| @Test*(expected=IllegalArgumentException.class)* |
| public void checkExpectedException() { |
| final int factorialOf = -5; |
| System.out.println(factorialOf + "! = " + Utils.computeFactorial(factorialOf)); |
| } |
| ---- |
| |
| [start=3] |
| . 添加以下 ``println`` （显示为粗体），用于在 "JUnit Test Results"（JUnit 测试结果）窗口中输出关于测试的文本。 |
| |
| [source,java] |
| ---- |
| |
| @Test (expected=IllegalArgumentException.class) |
| public void checkExpectedException() { |
| *System.out.println("* UtilsJUnit4Test: test method 3 - checkExpectedException()");* |
| final int factorialOf = -5; |
| System.out.println(factorialOf + "! = " + Utils.computeFactorial(factorialOf)); |
| } |
| ---- |
| |
| 比较：<<Exercise_244,针对预期异常错误的测试（JUnit 3）>> |
| |
| |
| ==== 禁用测试 |
| |
| 此测试演示如何临时禁用测试方法。在 JUnit 4 中，您只需通过添加 ``@Ignore`` 标注来禁用测试。 |
| |
| 1. 删除生成的测试方法 ``testNormalizeWord`` 。 |
| 2. 在测试类中添加以下测试方法。*@Test |
| public void temporarilyDisabledTest() throws Exception { |
| System.out.println("* UtilsJUnit4Test: test method 4 - checkExpectedException()"); |
| assertEquals("Malm\u00f6", Utils.normalizeWord("Malmo\u0308")); |
| }* |
| |
| 测试方法 ``temporarilyDisabledTest`` 将在您运行测试类时运行。 |
| |
| |
| [start=3] |
| . 在 ``@Test`` 上方添加 ``@Ignore`` 标注（显示为粗体）来禁用测试。*@Ignore* |
| |
| [source,java] |
| ---- |
| |
| @Test |
| public void temporarilyDisabledTest() throws Exception { |
| System.out.println("* UtilsJUnit4Test: test method 4 - checkExpectedException()"); |
| assertEquals("Malm\u00f6", Utils.normalizeWord("Malmo\u0308")); |
| } |
| ---- |
| |
| [start=4] |
| . 修复导入，以导入 ``org.junit.Ignore`` 。 |
| |
| 比较：<<Exercise_245,禁用测试（JUnit 3）>> |
| |
| 现在，您已经编写了测试。接下来，您可以运行测试并在 "JUnit Test Results"（JUnit 测试结果）窗口中查看测试输出。 |
| |
| |
| |
| |
| === 运行测试 |
| |
| 您可以对整个应用程序或单独的文件运行 JUnit 测试，并在 IDE 中查看结果。要运行项目的所有单元测试，最简单的方法是从主菜单中选择 "Run"（运行）> "Test _<PROJECT_NAME>_"（测试 <PROJECT_NAME>）。如果您选择此方法，则 IDE 将运行 "Test Packages"（测试包）中的所有测试类。要运行单独的测试类，右键单击 "Test Packages"（测试包）节点下的测试类并选择 "Run File"（运行文件）。 |
| |
| 1. 在 "Projects"（项目）窗口中，右键单击 ``UtilsJUnit4Test.java`` 。 |
| 2. 选择 "Test File"（测试文件）。 |
| 3. 选择 "Window"（窗口）> "IDE Tools"（IDE 工具）> "Test Results"（测试结果）以打开 "Test Results"（测试结果）窗口。 |
| |
| 在运行 ``UtilsJUnit4Test.java`` 时，IDE 仅运行测试类中的测试。如果类通过了所有测试，那么您将在 "JUnit Test Results"（JUnit 测试结果）窗口中看到与下图相似的结果。 |
| |
| [.feature] |
| -- |
| image:images/junit4-utilstest-pass-sm.png[role="left", link="images/junit4-utilstest-pass.png"] |
| -- |
| |
| 在该图中（单击图像查看大图），您可以看到 IDE 对 ``Utils.java`` 运行了 JUnit 测试，并且类通过了所有测试。左侧窗格显示各测试方法的结果，右侧窗格显示测试输出。如果您查看输出，您可以看到测试运行的顺序。您向每个测试方法添加的 ``println`` 已将测试的名称输出到 "Test Results"（测试结果）窗口和 "Output"（输出）窗口中。 |
| |
| 从 ``UtilsJUnit4Test`` 中可以看到，使用 ``@BeforeClass`` 进行标注的测试类初始化方法运行于任何其他方法之前，并且只运行一次。使用 ``@AfterClass`` 进行标注的测试类终结方法在类中的所有其他方法之后运行。使用 ``@Before`` 进行标注的测试初始化方法在各测试方法之前运行。 |
| |
| 使用 "Test Results"（测试结果）窗口左侧的控件，可以方便地再次运行测试。您可以使用过滤器在显示所有测试结果和仅显示失败的测试之间进行切换。使用相应的箭头，可以跳至下一个或上一个失败的测试。 |
| |
| 在 "Test Results"（测试结果）窗口中右键单击某个测试结果时，将会出现一个弹出式菜单，您可以选择转至测试的源、再次运行测试或调试测试。 |
| |
| 创建单元测试之后的下一步是创建测试套件。请参见<<Exercise_42,创建 JUnit 4 测试套件>>，了解如何以组的方式运行特定的测试，从而避免单独运行各个测试。 |
| |
| |
| == 创建测试套件 |
| |
| 为项目创建测试之后，您最后将得到许多测试类。虽然您可以单独运行测试类，也可以运行项目中的所有测试，但在许多情况下，您希望运行测试的子集或按特定的顺序运行测试。您可以通过创建一个或多个测试套件来实现此目的。举例来说，您可以创建测试套件来测试代码的具体方面或具体的条件。 |
| |
| 从根本上讲，测试套件是一个类，其中包含对指定测试用例（例如，特定测试类、测试类中的测试方法以及其他测试套件）进行调用的方法。测试套件可以作为测试类的一部分包括在其中，但最佳实践建议单独创建测试套件类。 |
| |
| 您可以手动为项目创建 JUnit 3 和 JUnit 4 测试套件，也可以通过 IDE 来生成套件。使用 IDE 生成测试套件之后，默认情况下，IDE 将生成代码来调用与测试套件相同的包中的所有测试类。创建测试套件之后，您可以对类进行修改，指定希望作为该套件一部分运行的测试。 |
| |
| |
| === 创建 JUnit 3 测试套件 |
| |
| 如果您选择 JUnit 3 作为测试的版本，则 IDE 可以根据测试包中的测试类来生成 JUnit 3 测试套件。在 JUnit 3 中，您可以指定要包含在测试套件中的测试类，方法是创建一个 ``TestSuite`` 实例并调用各测试的 ``addTest`` 方法。 |
| |
| 1. 在 "Projects"（项目）窗口中，右键单击 *JUnit-Sample* 项目节点，然后选择 "New"（新建）> "Other"（其他），以打开新建文件向导。 |
| 2. 在 "Unit Tests"（单元测试）类别中选择 "Test Suite"（测试套件）。单击 "Next"（下一步）。 |
| 3. 键入 *JUnit3TestSuite* 作为类名。 |
| 4. 选择 ``sample`` 包，在测试包文件夹的 sample 文件夹中创建测试套件。 |
| 5. 取消选中 "Test Initializer"（测试初始化函数）和 "Test Finalizer"（测试终结方法）。单击 "Finish"（完成）。 |
| image::images/junit-testsuite-wizard.png[title="JUnit 测试套件向导"] |
| |
| 单击 "Finish"（完成），此时 IDE 将在 ``sample`` 包中创建测试套件类，并在编辑器中打开类。该测试套件中包含以下代码。 |
| |
| |
| [source,java] |
| ---- |
| |
| public class JUnit3TestSuite extends TestCase { |
| public JUnit3TestSuite(String testName) { |
| super(testName); |
| } |
| |
| public static Test suite() { |
| TestSuite suite = new TestSuite("JUnit3TestSuite"); |
| return suite; |
| } |
| } |
| ---- |
| |
| [start=6] |
| . 修改 ``suite()`` 方法，以添加要作为套件的一部分运行的测试类。 |
| |
| [source,java] |
| ---- |
| |
| public JUnit3TestSuite(String testName) { |
| super(testName); |
| } |
| |
| public static Test suite() { |
| TestSuite suite = new TestSuite("JUnit3TestSuite"); |
| *suite.addTest(new TestSuite(sample.VectorsJUnit3Test.class)); |
| suite.addTest(new TestSuite(sample.UtilsJUnit3Test.class));* |
| return suite; |
| } |
| ---- |
| |
| [start=7] |
| . 保存所做的更改。 |
| |
| |
| |
| === 创建 JUnit 4 测试套件 |
| |
| 如果您选择 JUnit 4 作为测试的版本，则 IDE 可以生成 JUnit 4 测试套件。JUnit 4 是向后兼容的，因此您可以运行包含 JUnit 4 和 JUnit 3 测试的 JUnit 4 测试套件。在 JUnit 4 测试套件中，您可以以 ``@Suite`` 标注的值的形式指定要包括的测试类。 |
| |
| *注：*要让 JUnit 3 作为 JUnit 4 的一部分来运行，需要 JUnit 4.4 或更高版本。 |
| |
| 1. 在 "Projects"（项目）窗口中右键单击项目节点，然后选择 "New"（新建）> "Other"（其他）以打开新建文件向导。 |
| 2. 在 "Unit Tests"（单元测试）类别中选择 "Test Suite"（测试套件）。单击 "Next"（下一步）。 |
| 3. 键入 *JUnit4TestSuite* 作为文件名称。 |
| 4. 选择 ``sample`` 包，在测试包文件夹的 sample 文件夹中创建测试套件。 |
| 5. 取消选中 "Test Initializer"（测试初始化函数）和 "Test Finalizer"（测试终结方法）。单击 "Finish"（完成）。 |
| |
| 单击 "Finish"（完成），此时 IDE 将在 ``sample`` 包中创建测试套件类，并在编辑器中打开类。该测试套件中包含如下所示的代码。 |
| |
| |
| [source,java] |
| ---- |
| |
| @RunWith(Suite.class) |
| @Suite.SuiteClasses(value={UtilsJUnit4Test.class, VectorsJUnit4Test.class}) |
| public class JUnit4TestSuite { |
| } |
| ---- |
| |
| 运行该测试套件时，IDE 将按照其列出顺序来运行测试类。 |
| |
| |
| === 运行测试套件 |
| |
| 运行测试套件与运行任何单独测试类的方法相同。 |
| |
| 1. 在 "Projects"（项目）窗口中展开 "Test Packages"（测试包）节点。 |
| 2. 右键单击测试套件类，然后选择 "Test File"（测试文件）。 |
| |
| 运行测试套件之后，IDE 将按照套件中的测试的列出顺序来运行它们。JUnit 测试结果显示在 "JUnit Test Results"（JUnit 测试结果）窗口中。 |
| |
| [.feature] |
| -- |
| image:images/junit3-suite-results-sm.png[role="left", link="images/junit3-suite-results.png"] |
| -- |
| |
| 在该图中（单击图像查看大图），您可以看到 JUnit 3 测试套件的测试结果。测试套件将以单独测试的形式来运行 ``UtilsJUnit3Test`` 和 ``VectorsJUnit3Test`` 测试类，并在左侧窗格中显示各测试的结果。单独运行测试时，右侧窗格中的输出与左侧相同。 |
| |
| [.feature] |
| -- |
| image:images/junit4-suite-results-sm.png[role="left", link="images/junit4-suite-results.png"] |
| -- |
| |
| 在该图中（单击图像查看大图），您可以看到 JUnit 4 测试套件的测试结果。测试套件将以单独测试的形式来运行 ``UtilsJUnit4Test`` 和 ``VectorsJUnit4Test`` 测试类，并在左侧窗格中显示各测试的结果。单独运行测试时，右侧窗格中的输出与左侧相同。 |
| |
| [.feature] |
| -- |
| image:images/junitmix3and4-suite-results-sm.png[role="left", link="images/junitmix3and4-suite-results.png"] |
| -- |
| |
| 在该图中（单击图像查看大图），您可以看到混合测试套件的测试结果。该测试套件包括 JUnit 4 测试套件和一个 JUnit 3 测试类。测试套件将以单独测试的形式来运行 ``UtilsJUnit3Test.java`` 和 ``JUnit4TestSuite.java`` 测试类，并在左侧窗格中显示各测试的结果。单独运行测试时，右侧窗格中的输出与左侧相同。 |
| |
| |
| == 小结 |
| |
| 本教程是在 NetBeans IDE 中创建 JUnit 单元测试和测试套件的基本介绍。IDE 支持 JUnit 3 和 JUnit 4；本文档介绍了 JUnit 4 中引入的一些更改，这些更改可简化测试的创建和运行过程。 |
| |
| 如本教程中所述，JUnit 4 的主要改进之一就是提供了对标注的支持。在 JUnit 4 中，您现在可以将标注用于以下用途： |
| |
| * 使用 ``@Test`` 标注标识测试，而不使用命名惯例 |
| * 使用 ``@Before`` 和 ``@After`` 标注标识 ``setUp`` 和 ``tearDown`` 方法 |
| * 标识适用于整个测试类的 ``setUp`` 和 ``tearDown`` 方法。带有 ``@BeforeClass`` 标注的方法仅在类中的所有测试方法运行之前运行一次。同样，带有 ``@AfterClass`` 标注的方法仅在所有测试方法运行完之后运行一次。 |
| * 标识预期的异常错误 |
| * 使用 ``@Ignore`` 标注标识应跳过的测试 |
| * 为测试指定超时参数 |
| |
| 有关使用 JUnit 以及 JUnit 4 中引入的其他更改的详细信息，请参见以下资源： |
| |
| * link:http://tech.groups.yahoo.com/group/junit/[+Yahoo Groups 上的 JUnit 小组+] |
| * link:http://www.junit.org[+www.junit.org+] |
| |
| 通常，测试代码能帮助确保对代码中所做的小更改不会中断应用程序。JUnit 等自动化测试工具简化了测试的流程，并且经常性的测试能帮助及时捕获代码错误。 |
| |
| |
| link:https://netbeans.org/about/contact_form.html?to=3&subject=Feedback:%20Writing%20JUnit%20Tests%20in%20NetBeans%20IDE[+发送有关此教程的反馈意见+] |
| |
| |
| |
| == 另请参见 |
| |
| 有关使用 NetBeans IDE 开发 Java 应用程序的更多信息，请参见以下资源： |
| |
| * _使用 NetBeans IDE 开发应用程序_中的link:http://www.oracle.com/pls/topic/lookup?ctx=nb8000&id=NBDAG366[+创建 Java 项目+] |
| * link:../../trails/java-se.html[+基本 IDE 和 Java 编程学习资源+] |
