Detaillierte Erläuterung von JUnit beim Java-Unit-Testen

Dieser Artikel stellt hauptsächlich JUnit vor, eine detaillierte Erklärung des Java-Unit-Tests. Der Herausgeber findet es ziemlich gut, daher werde ich es jetzt mit Ihnen teilen und als Referenz geben. Folgen wir dem Editor und werfen wir einen Blick darauf

Bei Unit-Tests wird Testcode geschrieben, der genau und schnell die Korrektheit der Grundmodule des Programms sicherstellen soll.

JUnit ist ein Java-Unit-Test-Framework, das standardmäßig in Eclipse installiert ist.

JUnit4

JUnit4 identifiziert Testmethoden durch Annotationen. Die wichtigsten derzeit unterstützten Annotationen sind:

• @BeforeClass wird weltweit nur einmal ausgeführt und ist die erste, die

• @Before ausführt in der Testmethode Vor dem Ausführen ausführen

• @Testtestmethode

• @Nachdem Nach dem Ausführen der Testmethode zulassen

• @AfterClass wird global nur einmal ausgeführt und ist die letzte, die ausgeführt wird

• @Ignore Diese Methode ignorieren

Das Folgende basiert auf der Eclipse-Einführung. Grundlegende Anwendung von JUnit

Basistest

1. Erstellen Sie ein neues Projekt namens JUnitTest Eine Calculator-Klasse, die einfach in Calculator-Klassen für Addition, Subtraktion, Multiplikation, Division, Quadrate und Quadratwurzeln implementiert werden kann und anschließend diese Funktionen in Einheiten testet.

public class Calculator {
  private static int result; // 静态变量，用于存储运行结果
  public void add(int n) {
    result = result + n;
  }
  public void substract(int n) {
    result = result - 1; //Bug: 正确的应该是 result =result-n
  }
  public void multiply(int n) {
  }     // 此方法尚未写好
  public void pide(int n) {
    result = result / n;
  }
  public void square(int n) {
    result = n * n;
  }
  public void squareRoot(int n) {
    for (; ;) ;      //Bug : 死循环
  }
  public void clear() {   // 将结果清零
    result = 0;
  }
  public int getResult(){
    return result;
  }
}

1. Führen Sie das JUnit4-Unit-Testpaket in dieses Projekt ein: Klicken Sie mit der rechten Maustaste auf das Projekt und klicken Sie auf „Eigenschaften“, wie in der Abbildung gezeigt

Wählen Sie im Popup-Eigenschaftenfenster zunächst links „Java Build Path“, dann oben rechts die Registerkarte „Bibliotheken“ aus und klicken Sie dann auf Schaltfläche „Bibliothek hinzufügen…“ ganz rechts, wie folgt: Wie im Bild gezeigt

Wählen Sie dann JUnit4 im neuen Popup-Dialogfeld aus und klicken Sie auf OK. Wie im Bild oben gezeigt, ist das JUnit4-Softwarepaket in unserem Projekt enthalten.
2. JUnit-Testframework generieren: Klicken Sie mit der rechten Maustaste auf die Klasse im Paket-Explorer von Eclipse, um das Menü aufzurufen, und wählen Sie „Neuer JUnit-Testfall“. Wie im Bild unten gezeigt:

Nachdem Sie auf „Weiter“ geklickt haben " , listet das System automatisch die in Ihrer Klasse enthaltenen Methoden auf und wählt die Methode aus, die Sie testen möchten. In diesem Beispiel testen wir nur die vier Methoden „Addition, Subtraktion, Multiplikation und Division“.

Dann generiert das System automatisch eine neue Klasse CalculatorTest, die einige leere Testfälle enthält. Sie müssen diese Testfälle nur geringfügig ändern, um sie verwenden zu können.
Der vollständige CalculatorTest-Code lautet wie folgt:

public class CalculatorTest {  
  private static Calculator calculator = new Calculator();

  @Before
  public void setUp() throws Exception {
    calculator.clear();
  }

  @Test
  public void testAdd() {
    calculator.add(3);
    calculator.add(4);
    assertEquals(7, calculator.getResult());

  }

  @Test
  public void testSubstract() {
    calculator.add(8);
    calculator.substract(3);
    assertEquals(5, calculator.getResult());

  }

  @Ignore("Multiply() Not yet implemented")
  @Test
  public void testMultiply() {
    fail("Not yet implemented");
  }

  @Test
  public void testpide() {
    calculator.add(8);
    calculator.pide(2);
    assertEquals(4, calculator.getResult());

  }

}

1 Führen Sie den Testcode aus: Nachdem Sie den obigen Code geändert haben, klicken Sie mit der rechten Maustaste auf Wählen Sie in der CalculatorTest-Klasse „Als JUnit-Test ausführen“ aus, um unseren Test auszuführen, wie unten gezeigt

Die laufenden Ergebnisse lauten wie folgt:

Die rote Farbe des Fortschrittsbalkens zeigt an, dass ein Fehler gefunden wurde. Die spezifischen Testergebnisse werden auf dem Fortschrittsbalken als „insgesamt wurden 4 Tests durchgeführt, von denen 1 Test ignoriert wurde“ angezeigt Test fehlgeschlagen.“

Zeitlich begrenzter Test

Bei Programmen mit komplexer Logik und tiefer Schleifenverschachtelung ist es sehr wahrscheinlich, dass eine Endlosschleife auftritt Achten Sie darauf, einige Vorsichtsmaßnahmen zu treffen. Zeitgesteuerte Tests sind eine großartige Lösung. Wir legen für diese Testfunktionen eine Ausführungszeit fest. Nach dieser Zeit werden sie vom System zwangsweise beendet. Das System meldet Ihnen außerdem, dass der Grund für das Beenden der Funktion eine Zeitüberschreitung ist, damit Sie diese Fehler finden können . Um diese Funktion zu implementieren, müssen Sie nur einen Parameter zur @Test-Annotation hinzufügen. Der Code lautet wie folgt:

  @Test(timeout = 1000)
  public void squareRoot() {
    calculator.squareRoot(4);
    assertEquals(2, calculator.getResult());
  }

Der Timeout-Parameter gibt dies an Die Zeit wird in Millisekunden angegeben, sodass 1000 1 Sekunde darstellt.

测试异常

JAVA中的异常处理也是一个重点，因此你经常会编写一些需要抛出异常的函数。那么，如果你觉得一个函数应该抛出异常，但是它没抛出，这算不算Bug呢？这当然是Bug，并JUnit也考虑到了这一点，来帮助我们找到这种Bug。例如，我们写的计算器类有除法功能，如果除数是一个0，那么必然要抛出“除0异常”。因此，我们很有必要对这些进行测试。代码如下：

 @Test(expected = ArithmeticException.class)
 public void pideByZero(){
    calculator.pide(0);
  }

如上述代码所示，我们需要使用@Test标注的expected属性，将我们要检验的异常传递给他，这样JUnit框架就能自动帮我们检测是否抛出了我们指定的异常。

参数化测试

我们可能遇到过这样的函数，它的参数有许多特殊值，或者说他的参数分为很多个区域。

例如，测试一下“计算一个数的平方”这个函数，暂且分三类：正数、0、负数。在编写测试的时候，至少要写3个测试，把这3种情况都包含了，这确实是一件很麻烦的事情。测试代码如下：

  public class AdvancedTest { 
    private static Calculator calculator ＝ new Calculator();
    @Before
    public void clearCalculator(){
      calculator.clear();
    }

    @Test
    public void square1() {
      calculator.square(2);
      assertEquals(4, calculator.getResult());
    }   

    @Test  
    public void square2(){
      calculator.square(0);
      assertEquals(0, calculator.getResult());
    }

    @Test  
    public void square3(){
      calculator.square(-3);
      assertEquals(9, calculator.getResult());
    }
   }

为了简化类似的测试，JUnit4提出了“参数化测试”的概念，只写一个测试函数，把这若干种情况作为参数传递进去，一次性的完成测试。代码如下：

  @RunWith(Parameterized.class)
  public class SquareTest{
    private static Calculator calculator = new Calculator();
    private int param;
    private int result;   

  @Parameters  
  public static Collection data() {
    return Arrays.asList(new Object[][]{
        {2, 4},
        {0, 0},
        {-3, 9},
    });
  }

  //构造函数，对变量进行初始化
  public SquareTest(int param, int result){
    this.param = param;
      this.result = result;
  }

  @Test  
  public void square(){
    calculator.square(param);
    assertEquals(result, calculator.getResult());
  }
 }

执行了3次该测试类，依次采用了数据集合中的数据{处理值，预期处理结果}，结果如下：

代码分析如下：

• 为这种测试专门生成一个新的类，而不能与其他测试共用同一个类，此例中我们定义了一个SquareTest类。

• 为这个类指定一个Runner，而不能使用默认的Runner，@RunWith(Parameterized.class)这条语句就是为这个类指定了一个ParameterizedRunner

• 定义一个待测试的类，并且定义两个变量，一个用于存放参数，一个用于存放期待的结果。

• 定义测试数据的集合，也就是上述的data()方法，该方法可以任意命名，但是必须使用@Parameters标注进行修饰。

• 定义构造函数，其功能就是对先前定义的两个参数进行初始化

Das obige ist der detaillierte Inhalt vonDetaillierte Erläuterung von JUnit beim Java-Unit-Testen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!