1.定义正常情况下的预期和所需输出以及正确的输入。

• 现在，通过声明一个类来实现测试，命名为任意名称（通常类似于TestAddingModule），并向其添加testAdd方法（如下图所示）：
• 编写一个方法，并在其上方添加@Test注解。
• 在方法中，运行二进制求和和assertEquals(expectedVal,calculatedVal)。
• 通过运行方法来测试它（在Eclipse中，右键单击，选择Run as → JUnit test）。

//for normal addition 
@Test
public void testAdd1Plus1() 
{
    int x  = 1 ; int y = 1;
    assertEquals(2, myClass.add(x,y));
}

• 根据需要添加其他病例。
• 测试二进制和是否在整数溢出时引发意外异常。
• 测试您的方法是否可以优雅地处理Null输入（下面的示例）。

//if you are using 0 as default for null, make sure your class works in that case.
@Test
public void testAdd1Plus1() 
{
    int y = 1;
    assertEquals(0, myClass.add(null,y));
}

我为IntelliJ和Eclipse提供这篇文章。

• • 月食**

要对您的项目进行单元测试，请遵循以下步骤（我使用Eclipse编写此测试）：
1-单击新建-〉Java项目。

2-写下你的项目名称，然后点击完成。

3-右键点击你的项目，然后点击New-〉Class。

4-写下你的类名，然后点击完成。

然后，按如下方式完成课程：

public class Math {
    int a, b;
    Math(int a, int b) {
        this.a = a;
        this.b = b;
    }
    public int add() {
        return a + b;
    }
}

5-点击文件-〉新建-〉JUnit测试用例。

6-选中setUp（）并点击完成。SetUp（）将是初始化测试的地方。

7-点击确定。

8-在这里，我只是简单地将7和10相加。因此，我希望答案是17。按以下方式完成测试类：

import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
public class MathTest {
    Math math;
    @Before
    public void setUp() throws Exception {
        math = new Math(7, 10);
    }
    @Test
    public void testAdd() {
        Assert.assertEquals(17, math.add());
    }
}

9-在包资源管理器中单击测试类，然后单击Run as-〉JUnit Test。

10-这是测试的结果。

• • IntelliJ：**注意截图使用的是IntelliJ IDEA community 2020.1，另外在这些步骤之前需要设置好你的jre，我使用的是JDK 11.0.4。

1- Right-click on the main folder of your project-> new -> directory. You should call this 'test'.

2- Right-click on the test folder and create the proper package. I suggest creating the same packaging names as the original class. Then, you right-click on the test directory -> mark directory as -> test sources root.

3- In the right package in the test directory, you need to create a Java class (I suggest to use Test.java).

4- In the created class, type '@Test'. Then, among the options that IntelliJ gives you, select Add 'JUnitx' to classpath.

5- Write your test method in your test class. The method signature is like:

@Test
public void test<name of original method>(){
...
}

你可以像下面这样做你的Assert：

Assertions.assertTrue(f.flipEquiv(node1_1, node2_1));

这些是我添加的导入：

import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;

这是我写的测试：

您可以检查您的方法如下：

Assertions.assertEquals(<Expected>,<actual>);
Assertions.assertTrue(<actual>);
...

要运行单元测试，请右键单击测试，然后单击Run.

如果您的测试通过，结果将如下所示：

这是一个非常普遍的问题，有很多方法可以回答。
如果您想使用JUnit创建测试，您需要创建您的测试用例类，然后创建单独的测试方法来测试被测类/模块的特定功能（单个测试用例类通常与被测试的单个“生产”类相关联），并且在这些方法内执行各种操作，并将结果与正确的结果进行比较。尤其重要的是要尝试和涵盖尽可能多的角落案件。
在您的特定示例中，您可以测试以下内容：
1.两个正数之间的简单加法。将它们相加，然后验证结果是否符合预期。
1.正数和负数之间的加法（返回带有第一个参数符号的结果）。
1.正数和负数之间的加法（返回带有第二个参数符号的结果）。
1.两个负数之间的加法。
1.一种导致溢出的加法。
要验证结果，您可以使用org.junit.Assert类中的各种assertXXX方法（为方便起见，您可以执行“import static org.junit.Assert. *”）。这些方法测试特定条件，如果没有验证，则测试失败（可选地，使用特定消息）。
示例测试用例类（未定义方法内容）：

import static org.junit.Assert.*;

public class AdditionTests {
    @Test
    public void testSimpleAddition() { ... }

    @Test
    public void testPositiveNegativeAddition() { ... }

    @Test
    public void testNegativePositiveAddition() { ... }

    @Test
    public void testNegativeAddition() { ... }

    @Test
    public void testOverflow() { ... }
}

如果您不习惯编写单元测试，而是通过编写即席测试来测试代码，然后“以可视方式”验证（例如，您编写了一个简单的主方法，它接受使用键盘输入的参数，然后打印出结果--然后您继续输入值并验证自己是否正确），那么你可以开始用上面的格式编写这样的测试，并用正确的assertXXX方法来验证结果，而不是手工进行。这样，你可以比手工测试更容易地重新运行测试。

就像@CoolBeans提到的，看看jUnit。下面是一个简短的tutorial，它也可以帮助您开始学习jUnit 4.x
最后，如果你真的想学习更多关于测试和测试驱动开发（TDD）的知识，我建议你看看Kent Beck的书：Test-Driven Development By Example.

其他答案已经向您展示了如何使用JUnit来设置测试类。JUnit不是唯一的Java测试框架。然而，集中于使用框架的技术细节会分散对应该指导您的操作的最重要概念的注意力，所以我将讨论这些概念。

• 测试（各种各样的东西）将某个东西（被测系统，SUT）的“实际”行为与其“预期”行为进行比较。
• 自动化测试可以用计算机程序来完成，因为比较是由一个不灵活、不智能的计算机程序来完成的，所以预期的行为必须准确无误地知道。
• 一个程序或程序的一部分（类或方法）应该做的是它的“规范”，因此测试软件需要你有一个SUT的规范，这可能是一个显式的描述，也可能是你头脑中的一个隐式的规范。
• 因此，自动化单元测试需要您正在测试的类或方法的精确和明确的规范。
• 但是当你开始写代码的时候你需要这个规范。所以测试的一部分实际上在你写一行SUT之前就开始了。测试驱动开发（TDD）的测试技术把这个想法带到了一个极端，在你写要测试的代码之前你就创建了单元测试代码。
• 单元测试框架使用 assertions 来测试SUT。Assert是一个逻辑表达式（结果类型为boolean的表达式; a predicate），如果SUT行为正确，那么它必须是true。因此，规范必须被表达（或重新表达）为Assert。
• 将规范表达为Assert的一个有用技术是 * 契约式设计 *。这些规范是用 * 后置条件 * 表示的。后置条件是关于从方法或构造函数返回后SUT的公开可见状态的Assert。一些方法具有 * 不变量 * 的后置条件。它们是在方法执行之前和之后为真的 predicate 。一个 * 类 * 也可以说有不变量，它们是类的每个构造函数和方法的后置条件，后置条件（和不变量）只能用公开可见的状态来表达：public和protected字段、由public和protected方法（如getter）返回的值以及（通过引用）传递给方法的对象的公共可见状态。

许多初学者在这里提出问题，询问他们如何测试一些代码，展示代码但不说明代码的规范。正如这个讨论所示，* 任何人 * 都不可能给予这样一个问题的好答案，因为潜在的答案最多只能是 * 猜测 * 规范。而且可能做得不正确。问题的“提问者”显然不理解规范的重要性，因此，在尝试编写一些测试代码之前，我是一个新手，需要理解我在这里描述的基本原理。