Photographie/Traitements couleur/Traitement des films inversibles couleurs

Développer en Java/Journalisation
L'exemple ci-dessous montre les différents cas d'utilisation de l'API commons logging :
package org.wikibooks.fr.exemple;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
public class Exemple
 private static final Log log = LogFactory.getLog(Exemple.class);
 public void methode(String param, String param2)
 log.info("appel de methode");
 if (log.isDebugEnabled())
 // Placer cette instruction dans un test permet d'éviter
 // de nombreuses concaténations inutiles et améliorer
 // la vitesse d'exécution du code
 log.debug("param=" + param + ", param2=" + param2);
 try
 // ...
 catch (Exception e)
 // log.error permet de passer une exception ou une erreur
 // pour garder la trace
 log.error("une exception est arrivée", e);

R
R/Les fonctions statistiques de base
R/Quelques exemples
Introduction au test logiciel/Conclusion

Dans la littérature qui touche aux doublures et à leurs utilisations, il y a des inconsistances sur la nomenclature : il ne faudra pas s'étonner de lire des documents qui utilisent des termes différents ou inversent les termes que nous avons utilisé dans le chapitre consacré aux doublures.

Introduction au test logiciel/Doublures de test

Nous avons vu que les tests unitaires pouvaient rapidement devenir difficile à écrire pour diverses raisons. Nous allons voir que dans de nombreux cas, nous pouvons résoudre ces problèmes par l'utilisation de doublures. Il s'agit d'objets qui seront substitués aux objets attendus pour obtenir un comportement qui rend les tests plus facile à écrire.
Pourquoi utiliser une doublure.
Parmi les problèmes qu'on peut rencontrer lors de l'écriture de tests, nous pouvons énumérer :
Dans chacun de ces cas, nous allons voir que l'utilisation de doublures peut résoudre le problème posé.
Présentation des doublures.
S'il fallait faire une analogie pour expliquer les doublures, on pourrait parler des mannequins utilisés lors des essais de choc automobile. Ils jouent le rôle de doublures d'êtres humains pour "vérifier le comportement" de la voiture dans une "situation exceptionnelle : l'accident" (on retrouve le cas n°2). Les doublures reproduisent la structure et la forme des originaux (les mannequins ont le poids, la morphologie de véritables être humains pour que les tests soient fiables) mais la voiture ne s'en rend pas compte, elle réagit comme si elle transportait des humains.
Quand on parle de test logiciel, une doublure est un objet qui va, au moment de l'exécution, remplacer un objet manipulé par du code. Le code manipulateur ne s'en rend pas compte, une bonne doublure trompe le code appelant qui doit agir comme s'il manipulait un objet normal. Écrire des doublures ne requiert aucune compétence technique particulière autre qu'écrire du code dans le langage de l'application testée ou d'apprendre à utiliser de petites bibliothèques. En revanche, la création de doublures efficaces fait appel à la "ruse" du développeur. Il faut maîtriser le langage et savoir jouer avec le polymorphisme et les petites subtilités de chaque langage pour réaliser les doublures les plus simples possibles.
Comme nous allons le voir, il existe plusieurs types de doublures.
Les bouchons (ou « stubs »).
Un bouchon est le type le plus simple de doublure, il s'agit d'une classe, écrite à la main. Son implémentation tient compte du contexte exact pour lequel on a besoin d'une doublure. Quand on écrit un bouchon on considère tout le système comme une boîte blanche, on sait comment il est implémenté on en tient compte pour écrire le bouchon le plus simple possible, avec le minimum de code nécessaire pour qu'il puisse remplir son rôle de doublure.
Un exemple.
Dans l'exemple suivant, nous allons tomber dans le cas n°3. Dans cet exemple, nous sommes chargés de développer la partie messagerie utilisateur d'un logiciel, c'est un autre développeur qui se charge de la partie authentification utilisateur du système. Son travail est de fournir au logiciel une implémentation de l'interface codice_1 que vous devrez utiliser dans votre messagerie.
/** permet de vérifier qu'une personne à bien accès au système */
public interface IdentificationUtilisateur {
 /** vérifie qu'un utilisateur existe et que son mot de passe est le bon
 * @param identifiant l'identifiant de la personne à authentifier
 * @param motDePasse le mot de passe de la personne
 * @return vrai si l'utilisateur existe et que le mot de passe est le bon
 boolean identifier(String identifiant, String motDePasse);
Vous avez fait votre travail et avez développé une classe MessagerieUtilisateur qui gère la messagerie, elle utilise codice_1 pour vérifier les identifiants et mot de passe de l'utilisateur.
public class MessagerieUtilisateur {
 protected IdentificationUtilisateur identification;
 public MessagerieUtilisateur(IdentificationUtilisateur identification) {
 this.identification = identification;