Analyse de la technologie de test de boîte noire et de test de boîte blanche de la fonction de test de code PHP

Analyse de la technologie de test de boîte noire et de test de boîte blanche de la fonction de test de code PHP

Introduction :
Les tests sont une partie très importante lors du développement et de la maintenance d'applications PHP. Grâce aux tests, nous pouvons vérifier l'exactitude, la stabilité et la sécurité du code, améliorant ainsi la qualité de l'application. Cet article se concentrera sur la fonction de test de code PHP, en se concentrant sur deux techniques de test couramment utilisées, les tests en boîte noire et les tests en boîte blanche, et fournira quelques exemples de code pour approfondir la compréhension.

1. Test de boîte noire
Le test de boîte noire est une méthode de test fonctionnel. Il traite le programme testé comme une boîte noire et ne se soucie que des entrées et des sorties, sans se soucier des détails d'implémentation internes du programme. Trois techniques couramment utilisées pour les tests en boîte noire comprennent la division en classes d'équivalence, l'analyse des valeurs limites et la spéculation sur les erreurs.

1. Division de classe d'équivalence
   La division de classe d'équivalence est une méthode de conception de cas de test. Elle divise toutes les valeurs possibles de la valeur d'entrée en plusieurs classes d'équivalence, puis sélectionne un cas de test dans chaque classe d'équivalence. Dans les tests de code PHP, la division des classes d'équivalence peut réduire efficacement le nombre de cas de test et couvrir toutes les valeurs d'entrée possibles.

Exemple 1 :

/**
 * 判断输入年份是否为闰年（能被4整除但不能被100整除，或者能被400整除）
 *
 * @param int $year
 * @return bool
 */
function isLeapYear($year)
{
    if (($year % 4 == 0 && $year % 100 != 0) || $year % 400 == 0) {
        return true;
    } else {
        return false;
    }
}

// 测试用例
assert(isLeapYear(2000) === true);  // 基本等价类：2000为能被400整除的年份，属于闰年
assert(isLeapYear(1900) === false);  // 基本等价类：1900为能被100整除但不能被400整除的年份，不属于闰年
assert(isLeapYear(2020) === true);  // 附加等价类：2020为能被4整除但不能被100整除的年份，属于闰年
assert(isLeapYear(2021) === false);  // 附加等价类：2021为既不能被4整除也不能被100整除的年份，不属于闰年

2. Analyse des valeurs limites
   L'analyse des valeurs limites est une méthode de conception de cas de test qui se concentre sur les cas limites d'entrée et de sortie. Les cas de test sélectionnent généralement des valeurs limites minimales et maximales pour les tests, ainsi que des situations proches des valeurs limites. Dans les tests de code PHP, l'analyse des valeurs limites peut détecter efficacement les anomalies d'entrée ou de sortie.

Exemple 2 :

/**
 * 判断输入的数值是否在范围内
 *
 * @param int $number
 * @return bool
 */
function isInRange($number)
{
    if ($number >= 10 && $number <= 100) {
        return true;
    } else {
        return false;
    }
}

// 测试用例
assert(isInRange(5) === false);  // 边界情况：最小边界值，不在范围内
assert(isInRange(10) === true);  // 边界情况：最小边界值，正好在范围内
assert(isInRange(50) === true);  // 正常情况：在范围内
assert(isInRange(100) === true);  // 边界情况：最大边界值，正好在范围内
assert(isInRange(200) === false);  // 边界情况：最大边界值，不在范围内

3. Spéculation d'erreur
   La spéculation d'erreur est une méthode de test basée sur l'expérience et l'intuition. Elle conçoit des cas de test correspondants en devinant les situations d'erreur possibles. Dans les tests de code PHP, la spéculation sur les erreurs peut nous aider à trouver des erreurs et des anomalies potentielles.

Exemple 3 :

/**
 * 判断输入的字符串是否为有效的邮箱地址
 *
 * @param string $email
 * @return bool
 */
function isValidEmail($email)
{
    if (filter_var($email, FILTER_VALIDATE_EMAIL)) {
        return true;
    } else {
        return false;
    }
}

// 测试用例
assert(isValidEmail('abc@domain.com') === true);  // 正常情况：有效的邮箱地址
assert(isValidEmail('abc@domain.') === false);  // 异常情况：无效的邮箱地址，缺少顶级域名
assert(isValidEmail('abc@@domain.com') === false);  // 异常情况：无效的邮箱地址，多个@符号
assert(isValidEmail('abc@domain') === false);  // 异常情况：无效的邮箱地址，缺少顶级域名

2. Tests en boîte blanche
Les tests en boîte blanche sont une méthode de test structurel qui se concentre sur les détails de mise en œuvre à l'intérieur du programme. En comprenant la structure et la logique du programme, concevez des cas de test appropriés pour vérifier l'exécution de chaque branche et chemin. Il existe trois techniques couramment utilisées pour les tests en boîte blanche : la couverture des déclarations, la couverture des décisions et la couverture des conditions.

1. Couverture des déclarations
   La couverture des déclarations est une technique de test couramment utilisée dans les tests en boîte blanche, qui garantit que chaque instruction est exécutée au moins une fois. La couverture des instructions peut nous aider à trouver des erreurs logiques et des erreurs de code potentielles.

Exemple 4 :

/**
 * 计算两个数的和
 *
 * @param int $a
 * @param int $b
 * @return int
 */
function sum($a, $b)
{
    if ($a > $b) {
        return $a + $b;
    } else {
        return $b;
    }
}

// 测试用例
assert(sum(3, 5) === 8);  // 正常情况：$a > $b
assert(sum(5, 3) === 8);  // 正常情况：$a < $b
assert(sum(5, 5) === 5);  // 边界情况：$a = $b

2. Couverture de décision
   La couverture de décision est une technique de test plus détaillée dans les tests en boîte blanche qui garantit que chaque condition de décision prend deux valeurs possibles (vrai et faux). La couverture des décisions peut nous aider à trouver des erreurs logiques dans les énoncés de jugement.

Exemple 5 :

/**
 * 判断输入的数值是否为正数
 *
 * @param int $number
 * @return bool
 */
function isPositive($number)
{
    if ($number > 0) {
        return true;
    } else {
        return false;
    }
}

// 测试用例
assert(isPositive(5) === true);  // 正常情况：正数
assert(isPositive(0) === false);  // 边界情况：零不是正数
assert(isPositive(-5) === false);  // 正常情况：负数不是正数

3. Couverture conditionnelle
   La couverture conditionnelle est une technique de test plus détaillée dans les tests en boîte blanche, qui garantit que chaque condition logique prend deux valeurs possibles. La couverture conditionnelle peut nous aider à trouver des erreurs logiques et des différences conditionnelles.

Exemple 6 :

/**
 * 判断输入的两个数值是否相等
 *
 * @param int $a
 * @param int $b
 * @return bool
 */
function isEqual($a, $b)
{
    if ($a == $b || $a - $b < 1e-6) {
        return true;
    } else {
        return false;
    }
}

// 测试用例
assert(isEqual(5, 5) === true);  // 正常情况：两个数值相等
assert(isEqual(5, 4.999999) === true);  // 正常情况：两个数值相差很小
assert(isEqual(5, 4) === false);  // 正常情况：两个数值不相等

Conclusion :
Grâce à l'introduction de cet article, nous avons découvert les techniques de test en boîte noire et de test en boîte blanche couramment utilisées dans les tests de code PHP. Les tests en boîte noire se concentrent sur les entrées et les sorties et conçoivent des cas de test via la division des classes d'équivalence, l'analyse des valeurs limites et la spéculation sur les erreurs. Les tests en boîte blanche se concentrent sur la structure interne et conçoivent des cas de test via la couverture des déclarations, la couverture des décisions et la couverture des conditions. En employant des techniques de test appropriées, nous sommes en mesure de tester le code PHP de manière plus complète et d'améliorer la qualité et la stabilité de nos applications.

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!