Explication détaillée de JUnit dans les tests unitaires Java-javaDidacticiel-php.cn

Cet article présente principalement JUnit, une explication détaillée des tests unitaires Java. L'éditeur pense que c'est plutôt bon, je vais donc le partager avec vous maintenant et le donner comme référence. Suivons l'éditeur et jetons un coup d'œil

Les tests unitaires consistent à écrire du code de test, qui doit garantir avec précision et rapidité l'exactitude des modules de base du programme.

JUnit est un framework de tests unitaires Java installé par défaut dans Eclipse.

JUnit4

JUnit4 identifie les méthodes de test via des annotations. Les principales annotations actuellement prises en charge sont :

@BeforeClass ne sera exécutée qu'une seule fois globalement, et c'est la première à s'exécuter
@Before dans la méthode de test Exécuter avant d'exécuter
@Tester la méthode de test
@Après Autoriser après avoir exécuté la méthode de test
@AfterClass ne sera exécuté qu'une seule fois globalement et est le dernier à s'exécuter
@Ignore Ignorer cette méthode

Ce qui suit est basé sur l'introduction d'Eclipse Application de base de JUnit

Test de base

1 Créez un nouveau projet appelé JUnitTest Nous écrivons. une classe Calculatrice, qui peut être facilement implémentée. Classes Calculatrice pour l'addition, la soustraction, la multiplication, la division, les carrés et les racines carrées, puis teste ces fonctions unitairement.

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;
  }
}

Copier après la connexion

1. Introduisez le package de test unitaire JUnit4 dans ce projet : faites un clic droit sur le projet et cliquez sur "Propriétés", comme indiqué sur la figure.

Dans la fenêtre contextuelle des propriétés, sélectionnez d'abord "Java Build Path" à gauche, puis sélectionnez l'onglet "Bibliothèques" en haut à droite, puis cliquez sur le bouton Bouton "Ajouter une bibliothèque..." à l'extrême droite, comme suit Comme indiqué sur l'image

Sélectionnez ensuite JUnit4 dans la nouvelle boîte de dialogue contextuelle et cliquez sur OK. Comme le montre l'image ci-dessus, le progiciel JUnit4 est inclus dans notre projet.
2. Générer le framework de test JUnit : cliquez avec le bouton droit sur la classe dans l'explorateur de packages d'Eclipse pour faire apparaître le menu et sélectionnez "Nouveau scénario de test JUnit". Comme le montre l'image ci-dessous :

Après avoir cliqué sur « Suivant " , le système listera automatiquement les méthodes contenues dans votre classe, et sélectionnera la méthode que vous souhaitez tester. Dans cet exemple, nous testons uniquement les quatre méthodes « addition, soustraction, multiplication et division ».

Ensuite, le système générera automatiquement une nouvelle classe CalculatorTest, qui contient des cas de test vides. Il vous suffit de modifier légèrement ces cas de test pour les utiliser.
Le code complet de CalculatorTest est le suivant :

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());

  }

}

Copier après la connexion

1. Exécutez le code de test : Après avoir modifié le code ci-dessus, on fait un clic droit sur. la classe CalculatorTest, sélectionnez "Exécuter en tant que test JUnit" pour exécuter notre test, comme indiqué ci-dessous

Les résultats d'exécution sont les suivants :

La couleur rouge de la barre de progression indique qu'une erreur a été trouvée. Les résultats des tests spécifiques sont affichés sur la barre de progression comme "un total de 4 tests ont été effectués, dont 1 test a été ignoré et un". le test a échoué."

Test à durée limitée

Pour les programmes avec une logique complexe et une imbrication de boucles profondes, il est très probable qu'une boucle infinie se produise, donc assurez-vous de prendre quelques précautions. Les tests chronométrés sont une excellente solution. Nous définissons un temps d'exécution pour ces fonctions de test. Passé ce délai, elles seront terminées de force par le système, et le système vous signalera également que la raison pour laquelle la fonction s'est terminée est due à un délai d'attente, afin que vous puissiez trouver ces bugs. . Pour implémenter cette fonction, il vous suffit d'ajouter un paramètre à l'annotation @Test Le code est le suivant :

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

Copier après la connexion

Le paramètre Timeout indique que vous souhaitez définir Le temps est en millisecondes, donc 1000 représente 1 seconde.

测试异常

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

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

Copier après la connexion

如上述代码所示，我们需要使用@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());
    }
   }

Copier après la connexion

为了简化类似的测试，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());
  }
 }

Copier après la connexion

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

代码分析如下：

为这种测试专门生成一个新的类，而不能与其他测试共用同一个类，此例中我们定义了一个SquareTest类。
为这个类指定一个Runner，而不能使用默认的Runner，@RunWith(Parameterized.class)这条语句就是为这个类指定了一个ParameterizedRunner
定义一个待测试的类，并且定义两个变量，一个用于存放参数，一个用于存放期待的结果。
定义测试数据的集合，也就是上述的data()方法，该方法可以任意命名，但是必须使用@Parameters标注进行修饰。
定义构造函数，其功能就是对先前定义的两个参数进行初始化

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!