FPTest/fr

From Lazarus wiki
Jump to navigationJump to search

│ English (en) │ français (fr) │ polski (pl) │

FPTest (Free Pascal Testing Framework) est un framework de test d'unité. C'est une branche (fork) du projet DUnit2 créé par feu Peter McNab, mais adapté spécialement pour l'utilisation avec le compilateur Free Pascal.

La plupart des articles listés ci-dessous sont relatifs au projet DUnit2 original (et maintenant le projet FPTest) et comment il diffère du projet DUnit. L'information sur la migration depuis fpcunit est aussi présentée.

Caractéristiques

Objectifs de conception utilisés lors du développement du projet, pas nécessairement dans un ordre particulier :

  • Introduire SetUpOnce et TearDownOnce par TestCase et TestSuite.
  • Améliore la vitesse d'exécutiojn des tests
  • Introduit les projets multiples et ouvre la voie à l'exécution de projet de test dans des threads séparés.
  • Améliore la facilité d'utilisation de FPTest (en partie en ajoutant plus d'exemples dans la documentation).
  • Garantit que les Constructeurs et Destructeurs de TTestCase s'exécutent une seule fois, pas pour chaque méthode de test contenue.
  • Fournir un moyen non global var pour partager des données de configuration de haut niveau entre les unités de test.
  • Des résultats de test plus précis et des retours améliorés.
  • Fournit un décompte visuel des fuites de mémoire détectées et des tests sans Check().
  • Fournit un décompte facultatif pour identifier quels appels Check() ont échoué.
  • Nettoyage du code, en supprimant dans FPTest le code "légataire" (legacy), tel que le code spécifique Delphi Win32 et .Net.
  • Test Runner en mode texte pour ceux qui aiment les consoles ou pour la suite de tests sans assistance qui s'exécute sur les serveurs.
  • Une nouvelle IHM du Test Runner pour fpGUI ou les projet basés sur la LCL.
  • Un décorateur de test encore plus avancé qui tourne actuellement (celui de FPCUnit est totalement délabré).
  • Les tests enregistrés peuvent être bien mieux organisés, en construisant une hiérarchie de tests, les rendant plkus faciles à gérer (activer, désactiver, sauter les tests etc.)

Etat actuel

  • Le nouveau code reste compatible avec les suites de test existantes ne s'appuyant pas sur le code DUnit modifié par l'utilisateur.
  • Si vos projets de test FPCUnit utilise les méthodes CheckXXX() et non pas les méthodes AssertXXX(), il sera plutôt facile de basculer de FPCUnit vers le framework de test FPTest.
  • Le nouveau code reste compatible avec les suites de test existantes ne s'appuyant pas sur les fonctions TestFramework de bas niveau (p.ex. TTestResult).
  • Le nouveau code introduit les classes Project et ProjectManager entre l'IHM et les TextTestRunners pour assister la future introduction du test d'unité avec des threads.
  • Le code de SetupOnce et TeardownOnce réduit le désordre de noeud et de nom où les décorateurs aurait été requis avant. !e décorateur de test dans FPCUnit a des défauts de conception, et ne marche pas comme attendu.
  • Le nouveau code de décoration de test est plus facile à comprendre et étendre.
  • La profondeur d'appel à l'exécution par TestCase a été réduite dans un effort pour améliorer l'efficacité du test. (le chemin d'exécution est plus facile à suivre et facilite les futurs changements dans le code).
  • Le chronométrage de la procédure de test est maintenant pris seulement sur la méthode de test et exclut les temps de SetUp et TearDown. L'intention étant de fournir une pkus haute précision du chronométrage pour le profilage de méthode. Le temps global englobe encore tout le code.
  • Toutes les procédures Check existantes sont supportées. Plusieurs nouvelles procédures Check ont été ajoutées pour compléter l'éventail disponible.
  • De nouvelles unités ont été créées pour vérifier que toutes les procédures Check() détectent les conditions passer et échouer.
  • Tous les tests s'exécutent sans fuite de mémoire ou besoin de permettre des fuites.
  • De nouveaux tests d'unités auto-test sont plus compréhensible en incluant des contrôles pour assurer les conditions de configuration sont proprement satisfaites avant d'exécuter les tests requis.
  • Une classe Project gère maintenant l'enregistrement et l'exécution des TestCases groupés (TestSuites) et des TestCases.
  • Les tests comptés peuvent maintenant être invoqués dans les décorateurs de test pour fournir des données de test à 2 dimensions ou plus.
  • Les tests vides non optimisés échouent toujours.
  • Les tests qui n'appellent pas Check() peuvent être globalement armés pour échouer, i.e. depuis l'IHM.
  • Similairement les tests provoquant des fuites de mémoire peuvent être globalement armés pour échouer.
  • Des test individuels peuvent optionnellement surcharger les réglages IHM (i.e. où un composant tierce partie a une fuite connue).
  • Tous les tests qui surchargent les réglages IHM peuvent optionnellement être identifiés après l'exécution du test par des couleurs de noeud additionnelles.
  • Un décompte des échecs des tests surchargés est inclus dans l'affichage du status d'exécution.
  • Les tests surchargés qui auraient autrement échoué génèrent un décompte d'avertissements séparé dans l'IHM et la sortie texte mise à jour.
  • Les noms de méthodes de test sont découplées du processus d'exécution, permettant aux informations post-compilation d'être affichées au niveau IHM.
  • Générateur de rapport XML ajouté, complétant à la fois GUITestRunner et TextTestRunner.
  • Ajoutée la capacité de GUITestRunner et TextTestRunner ensemble, de sauter (exclure) des tests individuels séparée de l'activation/désactivation de test.
  • Des boutons d'outil à GUITestRunner pour faciliter le contrôle et montrer à l'exécution quelles options ont été sélectionnées.

Pour faciliter les tests précoces sans reconstruire complètement GUITestsRunner et TextTestRunner, une unité proxy intermédiaire et un remplacement des TTestResults ont été intercalés entre l'interface graphique et le nouveau framework de test. Bien que l'objectif initial était éventuellement de repenser complètement l'interface graphique, les classes "Proxy" fonctionnent très bien et peuvent ne pas nécessiter de travail supplémentaire.

Obtenir le code source

Le code source est librement accessible depuis GitHub en utilisant la commande suivante : 

git clone git://github.com/graemeg/fptest.git

ou 

git clone https://github.com/graemeg/fptest.git

Si vous n'avez pas installé Git, vous pouvez aussi récupérer une archive tarball du code source, en utilisant l'URL suivante. 

https://github.com/graemeg/fptest/tarball/master

Le projet FPTest est en développement actif, ainsi le code et la documentation sont constamment améliorés. Pour cette raison, je vous recommande hautement de récupérer le code source via Git au lieu de l'archive tarball.

Documentation

La documentation eut être trouvée dans le répertoire docs en fichiers HTML.

Exemple de test

Voici un échantillon de projet de test en console. 

program project1;

{$mode objfpc}{$H+}

uses
 Classes,
 TextTestRunner,
 sample_tests;

begin
 // Register all tests
 sample_tests.RegisterTests;

 RunRegisteredTests;
end.

et l'unité contenant les tests actuels ... 

unit sample_tests;

{$mode objfpc}{$H+}

interface

uses
 TestFramework;  // required for TTestCase and CheckXXX() references

type
 TTestCaseFirst = class(TTestCase)
 published
   procedure TestWarning;
   procedure TestOne;
   procedure TestNoError;
   procedure TestThree;
   procedure TestFour;
 end;

procedure RegisterTests;

implementation

uses
  SysUtils;

{ here we register all our test classes }
procedure RegisterTests;
begin
  TestFramework.RegisterTest(TTestCaseFirst.Suite);
end;

{ TTestCaseFirst }

procedure TTestCaseFirst.TestWarning;
begin
  // Do nothing here - should cause a Warning
end;

procedure TTestCaseFirst.TestOne;
begin
  Check(1 + 1 = 3, 'Catastrophic arithmetic failure!');
end;

procedure TTestCaseFirst.TestNoError;
begin
  Check(1 + 1 = 2, 'Catastrophic arithmetic failure!');
end;

procedure TTestCaseFirst.TestThree;
var
  s: string;
begin
  s := 'hello';
  CheckEquals('Hello', s, 'Failed CheckEquals');
end;

procedure TTestCaseFirst.TestFour;
var
  x, y: integer;
begin
  x := 10;
  y := 0;
  Check(x / y = 0, 'Failed on 1');
end;

end.

Captures d'écran

Voici une captuire d'écran d'une sortie du Test Runner en mode texte.

échantillon de sortie de la console Test Runner en mode texte.

Voici une capture d'écran du Test Runner avec IHM (utilisant le Toolkit fpGUI) pour exécuter la suite de tests tiOPF.

Une capture d'écran de l'IHM Test Runner utilisant le toolkit fpGUI.

Comment le comparer à FPCUnit?

J'ai (Graeme Geldenhuys) été un utilisateur de longue date de FPCUnit. J'ai contribué à l'extension du projet FPCUnit. Mais FPCUnit a quelques défauts de conception qui le rendent plus utiles pour les projets plus petits et des suites de tests moins compliquées. Les décorateurs de test de FPCUnit, Setup/Teardown etc sont sévèrement délabrés. Le framework de test surmonte tous ces problèmes, ajoute de nouvelles fonctionnalités, il est plus facile de gérer vos tests, et les exécute plus rapidement que des projets équivalents FPCUnit ou Dunit.

La bonne nouvelle est vous n'êtes pas forcés de choisir entre les frameworks de test. Il y plusieurs années, j'ai inclus une interface de compatibilité DUnit/FPTest à FPCUnit. Ce qui vous donne un bon chemin de mise à jour de FPCUnit vers FPTest. Donc si vous concevez votre suite de test en utilisant des appels CheckXXX() (au lieu des appels AssertXXX()), vous pourrez plus tard basculer facilement vers le framework FPTest sans avoir besoin de changer votre code de test.

Voir aussi

Retrieved from "https://wiki.freepascal.org/index.php?title=FPTest/fr&oldid=132171"