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.
- 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 :
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
function isLeapYear( $year )
{
if (( $year % 4 == 0 && $year % 100 != 0) || $year % 400 == 0) {
return true;
} else {
return false;
}
}
assert(isLeapYear(2000) === true);
assert(isLeapYear(1900) === false);
assert(isLeapYear(2020) === true);
assert(isLeapYear(2021) === false);
|
Copier après la connexion
- 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 :
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
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);
|
Copier après la connexion
- 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 :
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
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);
|
Copier après la connexion
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.
- 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 :
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
function sum( $a , $b )
{
if ( $a > $b ) {
return $a + $b ;
} else {
return $b ;
}
}
assert(sum(3, 5) === 8);
assert(sum(5, 3) === 8);
assert(sum(5, 5) === 5);
|
Copier après la connexion
- 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 :
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
function isPositive( $number )
{
if ( $number > 0) {
return true;
} else {
return false;
}
}
assert(isPositive(5) === true);
assert(isPositive(0) === false);
assert(isPositive(-5) === false);
|
Copier après la connexion
- 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 :
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
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);
|
Copier après la connexion
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!