unit-testing
Test unitaire des boucles (Java)

Introduction

Test en boucle unique

Ce sont des boucles dans lesquelles leur corps de boucle ne contient pas d'autres boucles (la boucle la plus interne en cas d'imbrication).

Pour avoir une couverture en boucle, les testeurs doivent exercer les tests indiqués ci-dessous.

Test 1: Concevoir un test dans lequel le corps de la boucle ne devrait pas être exécuté du tout (c.-à-d. Des itérations nulles)

Test 2: Concevoir un test dans lequel la variable de contrôle de boucle est négative (nombre négatif d’itérations)

Test 3: Concevoir un test dans lequel la boucle ne se répète qu'une seule fois

Test 4: Concevoir un test dans lequel la boucle effectue deux itérations

Test 5: Concevoir un test dans lequel la boucle répète un certain nombre de fois, par exemple m où m <nombre maximal d'itérations possible

Test 6: Concevoir un test dans lequel la boucle effectue une itération inférieure au nombre maximal d'itérations

Test 7: Concevoir un test dans quelle boucle itère le nombre maximum d'itérations

Test 8: Concevoir un test dans lequel la boucle effectue une itération de plus que le nombre maximal d'itérations

Considérons l'exemple de code ci-dessous qui applique toutes les conditions spécifiées.

classe publique SimpleLoopTest {

private int [] numbers = {5, -77,8, -11,4,1, -20,6,2,10};

/** Compute total of  positive numbers in the array 
 *  @param numItems number of items to total.
 */
public int findSum(int numItems)
{
    int total = 0;
    if (numItems <= 10) 
    {
        for (int count=0; count < numItems; count = count + 1)
        {
          if (numbers[count] > 0)
             {
                total = total + numbers[count];
             }
        }                
    }
    return total;
}

}

la classe publique TestPass étend TestCase {

public void testname() throws Exception {
    
    SimpleLoopTest s = new SimpleLoopTest();        
    assertEquals(0, s.findSum(0));    //Test 1
    assertEquals(0, s.findSum(-1));   //Test 2
    assertEquals(5, s.findSum(1));    //Test 3
    assertEquals(5, s.findSum(2));    //Test 4
    assertEquals(17, s.findSum(5));   //Test 5
    assertEquals(26, s.findSum(9));   //Test 6
    assertEquals(36, s.findSum(10));  //Test 7
    assertEquals(0, s.findSum(11));   //Test 8
}

}

Test des boucles imbriquées

Une boucle imbriquée est une boucle dans une boucle.

La boucle externe ne change que lorsque la boucle interne est complètement terminée / interrompue.

Dans ce cas, les cas de test doivent être conçus de telle manière que

Commencez par la boucle la plus profonde. Définissez toutes les boucles externes à leurs valeurs minimales. Effectuez un test de boucle simple sur la boucle la plus interne (Test3 / Test4 / Test5 / Test6 / Test7). Continuer jusqu'à ce que toutes les boucles soient testées

Test des boucles concaténées

Deux boucles sont concaténées s'il est possible d'en atteindre une après avoir quitté l'autre sur le même chemin depuis l'entrée jusqu'à la sortie. Parfois, ces deux boucles sont indépendantes l'une de l'autre. Dans ces cas, nous pouvons appliquer les techniques de conception spécifiées dans le cadre du test en boucle unique.

Mais si les valeurs d'itération d'une boucle sont directement ou indirectement liées aux valeurs d'itération d'une autre boucle et qu'elles peuvent se produire sur le même chemin, nous pouvons les considérer comme des boucles imbriquées.