Pause café #87. Pourquoi les tests unitaires sont-ils importants pour les développeurs ? 5 façons de copier un tableau en Java

Pourquoi les tests unitaires sont-ils importants pour les développeurs ?

Source : SearchSoftwareQuality Voyons pourquoi les tests unitaires sont importants et précieux, et comment ils facilitent le débogage. Les tests unitaires sont un outil puissant pour améliorer la qualité des logiciels. Les tests unitaires fournissent une vérification fondamentale qu'une application est conforme aux spécifications logicielles et se comporte comme prévu. Lorsqu'ils sont bien faits, les tests unitaires :

• réduire le nombre de défauts et les identifier dès les premiers stades du cycle de vie du développement ;
• améliorer la lisibilité du code ;
• permettre la réutilisation du code ;
• augmenter la vitesse de déploiement.

Voyons pourquoi les tests unitaires sont importants, comment ce type de test est né et quels sont les obstacles à sa mise en œuvre.

Histoire des tests unitaires

Une erreur détectée à un stade précoce permet d'économiser du temps et des efforts. Au cours des 50 premières années de l’histoire de l’informatique, les tests unitaires et le débogage étaient essentiellement la même chose. Mais dans les années 1990, le code était devenu si complexe qu’il était souvent impossible de diviser le système en petites parties pour les faire fonctionner de manière isolée. En 1997, un programmeur nommé Kent Beck a créé JUnit, un plugin d'environnement de développement permettant de tester de petits morceaux de code. Le code de test qui évalue le code source est appelé tests unitaires. Ce type de tests unitaires est devenu un incontournable depuis de nombreuses années. Après que Beck ait créé JUnit, Martin Fowler a écrit un livre, Refactoring, dans lequel il propose des moyens de transformer le code pour le rendre plus isolé et testable. La combinaison de la refactorisation du code et des tests unitaires a conduit au développement piloté par les tests, où la création de tests unitaires est essentielle au processus de programmation. Dans celui-ci, le code doit être testable avant même sa création. Ainsi, le processus de programmation n’est terminé qu’après l’exécution des tests unitaires. Le projet peut alors passer au stade de la recherche au niveau systémique ou humain.

Exemple de test unitaire

Cet exemple démontre l’importance des tests unitaires. Ici, JUnit évalue une fonction simple qui convertit la température de Fahrenheit en Celsius. Formule de conversion : C = (F-32) * 5/9. Quelques lignes seulement, y compris la signature de la fonction et les accolades, peuvent être implémentées dans le code en tant que fonction de bibliothèque. Cependant, la fonction ne montre pas clairement qu'il s'agit de critères. Ces options peuvent inclure l'arrondi vers le haut ou vers le bas, les nombres réels ou les limites supérieure et inférieure. Créons des exemples de tests unitaires pour cette fonction de conversion de température en Perl à l'aide du module Test::More. La première ligne est un commentaire qui indique au programmeur à quoi s'attendre du code restant.

# is (input, expected result, comment)
is( FtoC(32),0,'Freezing point is F32, C 0');
is( FtoC(212),100,'Boiling point is F212, C 100');
is( FtoC(59038),32767, 'Upper limit of C is 32767');
is( FtoC(59039),undefined, 'One past upper limit is error');

Le framework JUnit s'appuie sur des systèmes orientés objet et des objets de test, mais le concept est similaire.

Tests unitaires isolés

L'un des avantages des tests unitaires est qu'ils isolent une fonction, une classe ou une méthode et testent uniquement ce morceau de code. De meilleurs composants individuels assurent la résilience globale du système. De cette façon, vous obtenez un code fiable. Les tests unitaires modifient également la nature du processus de débogage. Pour tenter de corriger un bug, les programmeurs écrivent simplement un test qui échoue, puis le répètent afin qu'il réussisse sans violer les attentes précédentes. Ce processus élimine le cycle manuel de débogage traditionnel via la configuration, la recréation, la pause et le test. Pour modifier le code afin de le rendre adapté aux tests unitaires, les programmeurs doivent modifier leur façon de travailler. Tout morceau de code écrit sans tests unitaires sera probablement considéré comme non testé, au moins en tant que modules individuels.

Adaptation des tests unitaires

Un logiciel hérité est un logiciel qui fonctionne depuis longtemps et qui a probablement été écrit sans tests unitaires. Le code hérité a de la valeur pour l’entreprise. Cela fonctionne de manière stable pendant de nombreuses années. Certains programmes construits sans tests unitaires traitent des transactions valant plusieurs millions de dollars par jour. Mais le code qui n'a pas de tests unitaires se transforme en une grosse boule de saleté au fil du temps car il a été touché par de nombreux programmeurs de maintenance de code au fil des ans. La refactorisation permet aux programmeurs d'apporter progressivement des modifications à un système pour le rendre testable. Toutefois, ces changements prennent du temps. Il y a plusieurs années, j'ai discuté avec mon collègue Bob Reselman de la question de l'utilisation des tests unitaires pour les applications existantes. Reselman a fait valoir que la mise en œuvre de tests unitaires dans des applications créées sans cela est trop coûteuse, voire stupide. Au lieu de cela, il a recommandé à l'organisation de démarrer de nouveaux développements avec des tests unitaires et de laisser de côté les applications existantes. Cela peut être vrai pour COBOL, les générateurs de rapports et d'autres applications, mais je dirais que dans les applications écrites dans des langages modernes (C++, C#, Java et Ruby), il est assez facile d'ajouter rétroactivement des tests unitaires. Au lieu de les écrire pour l’ensemble de l’application, ajoutez simplement des tests unitaires à la modification actuelle et refactorisez-les au fur et à mesure.

Vitesse, qualité et testabilité accrues

Les chefs de projet affirment que la planification implique des compromis entre la qualité, la quantité de travail effectué, les ressources et le temps. Pour ajouter quelque chose à un domaine, vous devez retirer quelque chose à un autre. Des tests unitaires efficaces enfreignent cette règle. C'est pourquoi les tests unitaires sont importants et précieux pour les organisations. De bons tests unitaires produisent du code testable qui améliore la qualité. Ce code aura moins de défauts, ce qui signifie moins de corrections de bugs pour terminer le projet plus rapidement. Lorsque le logiciel rencontre des bogues, les tests unitaires accélèrent le débogage, la correction et l'écriture du code. Et cela se produit de telle manière que la probabilité qu'un défaut se reproduise est considérablement réduite tout en améliorant simultanément la qualité et la rapidité du code. Bien qu'il n'existe pas de solution miracle dans le développement de logiciels, des tests unitaires efficaces peuvent accélérer le développement, les tests et même une partie de l'ingénierie des exigences fonctionnelles.

5 façons de copier un tableau en Java

Source : Dev.to Vous avez donc deux tableaux A et B et vous devez copier les éléments de A vers B. Eh bien, il existe différentes façons de le faire en Java et je vais vous les montrer maintenant.

Première méthode : ForLoop

C’est là que la bonne vieille boucle for nous vient en aide :

int[] A = {1,2,4,4};
int[] B = new int[];

 for (int i = 0; i < A.length; i++){
      B[i] = A[i];
}

Deuxième méthode : .clone()

La méthode de clonage de tableau peut également aider à obtenir le résultat souhaité :

int[] A = {1,2,4,4};
int[] B = A.clone();//the clone method copies the content of A into B;

Troisième méthode : System.arraycopy()

La méthode suivante consiste à utiliser la méthode System.arraycopy() , qui se trouve dans le package java.lang . Avant de passer à son utilisation, parlons de sa signature :

public static void arraycopy(
    Object src, //:source array, in this case A
    int srcPos, //:the start index for copy, typically 0
    Object dest, //:destination object in this case B.
    int destPos, //:the index to place the copied elements
    int length //:the length of the contents to be copied
);

Application:

int[] A = {1,2,4,4};
int[] B = new int[];

System.arraycopy(A, 0, B, 0, A.length);

Quatrième méthode : Arrays.copyOf()

La prochaine option de copie dont nous discuterons est la classe Arrays du package java.utils . Faites attention à sa signature :

public static int[] copyOf(
    int[] original, // :source array in this case A
    int newLength // :the length of the contents to be copied
);

Application:

int[] A = {1,2,4,4};
int[] B = Arrays.copyOf(A, 3);

Cinquième méthode : Arrays.copyOfRange()

Ce sera donc la dernière option que nous examinerons dans cet article. Il provient également de la classe Arrays présente dans le package java.utils . Regardons à nouveau sa signature :

public static int[] copyOfRange​(
    int[] original, // :source array in this case A
    int from,  //:the start index for copy, typically 0
    int to // the end index exclusive
);

Application:

int[] A = {1,2,3,4,5,6,7};
int[] B = Arrays.copyOfRange(A, 0, A.length);