J'ai déjà utilisé Java et je pouvais tout faire avec Eclipse. Maintenant, parce que je souhaite utiliser Delphi pour modifier un logiciel de messagerie instantanée, je me demande comment déplacer le système de reconstruction et de test unitaire à Delphi. Le livre indique que l'ajout de tests unitaires au code existant peut approfondir votre compréhension du code et servir de base pour améliorer le code. Ainsi, afin de construire une telle plate-forme agile, j'ai fait une petite tentative avec Delphi2005 et Dunit, et j'ai enregistré les résultats ci-dessous pour partager avec vous.
1. Télécharger Delphi2005
Étant donné que Borland ne vend pas de versions professionnelles en Chine, étant donné le prix du ciel des architectes et des versions d'entreprise, il ne peut télécharger qu'une version D depuis Internet pour un usage personnel. Delphi2005 est de taille relativement grande, et Update1 nécessite également un CD, il est donc recommandé d'utiliser BT pour télécharger la version 2CD. L'adresse de semence est la suivante:
http://www.delphhifans.com/softview/821.html
2. Téléchargez le SP1 de Delphi2005
On dit qu'après avoir appliqué ce correctif, il peut être plus rapide, mais le patch est lent à installer et vous devez toujours utiliser un CD. L'adresse de téléchargement est la suivante:
http://www.delphhifans.com/softview/970.html
3. Télécharger Dunit
https://sourceforge.net/projects/dunit/
4. Installer Delphi2005 + Sp1
Notez qu'il existe un registre dans Keygen et lors de l'installation, vous devez installer les versions .NET et WIN32 de Delphi en même temps, mais C # Builder n'a pas d'importance. Parce que si vous n'installez que la version Win32, la fonction de reconstruction ne sera pas disponible (il s'agit d'un bug dans Delphi2005, qui se manifeste comme une fenêtre d'exception de .NET lors du refactorisation).
5. Simplifier Delphi2005
Parce que la version .NET a été installée en même temps à l'étape précédente, Delphi est devenu très lent au démarrage. Cela peut être réalisé en modifiant le registre et en supprimant certains packages IDE. La méthode spécifique consiste à ajouter le paramètre -rxxx après la cible de raccourci Delphi, c'est-à-dire bds.exe -rxxx. Ce XXX est pour vous de spécifier, puis vous trouverez ces putains de packages dans hkey_current_user / logiciel / borland / xxx (c'est le nom que vous avez sélectionné xxx) /3.0/ packages IDE connus. Notez que vous ne pouvez pas le supprimer trop proprement comme les autres molécules purifiées Win32 sur Internet, car elle sera inutile pour la reconstruction. Une liste relativement simple que j'ai obtenue après avoir expérimenté plusieurs fois est la suivante
"$ (Bds) // bin // vclMenudeSigner90.bpl" = "(Untitled)"
"$ (Bds) // bin // win32debugproide90.bpl" = "(sans titre)"
"$ (Bds) // bin // htmide90.bpl" = "package de concepteur html"
"$ (Bds) // bin // iteidew3290.bpl" = "Environnement de traduction intégré Borland pour win32"
"$ (Bds) // bin // srcmanide90.bpl" = "(sans titre)"
"$ (Bds) // bin // toDoide90.bpl" = "borland todo"
"$ (Bds) // bin // htmlhelp290.bpl" = "Borland htmlhelp Viewer"
"$ (Bds) // bin // idefileFilters90.bpl" = "ide filefilters"
"$ (Bds) // bin // startPageide90.bpl" = "Borland Start Page IDE Package"
"$ (Bds) // bin // Refactoride90.bpl" = "Borland Core Refactoring Package"
"$ (Bds) // bin // dbkdebugide90.bpl" = "(sans titre)"
"$ (Bds) // bin // exceptiondiag90.bpl" = "(sans titre)"
"$ (Bds) // bin // deployide90.bpl" = "Manager de déploiement"
"$ (Bds) // bin // plugView90.bpl" = "package de vue d'arborescence enfichable"
"$ (Bds) // bin // coreproide90.bpl" = "package Core Ide Pro"
"$ (Bds) // bin // idetools90.bpl" = "build outils"
"$ (Bds) // bin // UNITSTIDE90.BPL" = "(Untitled)"
"$ (Bds) // bin // historyide90.bpl" = "(sans titre)"
"$ (Bds) // bin // htmltidy90.bpl" = "Html Tidy Fordy"
"$ (Bds) // bin // htmlfmt90.bpl" = "Html Internal Foratter"
"$ (Bds) // bin // mlcc90.bpl" = "package de complétion du code de la langue de balisage"
"$ (Bds) // bin // delphivclide90.bpl" = "package de concepteur de Delphi VCL"
"$ (Bds) // bin // delphicoreproide90.bpl" = "(sans titre)"
"$ (Bds) // bin // win32debugide90.bpl" = "(sans titre)"
"$ (Bds) // bin // htmlide90.bpl" = "(sans titre)"
"$ (Bds) // bin // Delphide90.bpl" = "Delphi Win32 IDE Personalité"
"$ (Bds) // bin // mtspro90.bpl" = "(sans titre)"
"$ (Bds) // bin // mtssent90.bpl" = "(sans titre)"
"$ (Bds) // bin // iteidenet90.bpl" = "Environnement de traduction intégré Borland pour .net"
"$ (Bds) // bin // netimportwiz90.bpl" = "(sans titre)"
"$ (Bds) // bin // dataExplorer90.bpl" = "(sans titre)"
Bien qu'il soit encore un peu lent à commencer, il peut enfin le supporter.
6. Compiler et installer Dunit
Utilisez la méthode que vous connaissez pour compiler DUNIT dans DCU et mettez-la dans le répertoire que vous avez spécifié. Et ajouter ce répertoire au chemin de bibliothèque des outils Delphi-> Options d'environnement-> Options Delphi-> Library-win32.
Compiler également Dunit.exe
7. Établir un projet
La façon dont je recommande est de séparer l'interface et l'arrière-plan lors de la rédaction d'un programme Delphi, spécifiquement pour ouvrir deux projets, un projet VCL ordinaire et l'autre projet DLL. Non, non, je ne veux pas vous permettre de partager le code en dll. Ce projet DLL contient des fichiers qui sont tous du contenu d'arrière-plan, ainsi que des tests en arrière-plan. La DLL générée est utilisée pour Dunit, à partir duquel DUNIT peut lire le test et l'exécuter. En fait, le projet dans la partie GUI contient tous les fichiers.
Le projet est divisé en trois parties: GUI, noyau et testcore. Le projet One comprend GUI + Core et le projet deux comprend Core + TestCore. La sortie du projet 1 est le programme Win32EXE. La deuxième sortie du projet est le programme Win32DLL.
Ensuite, vous pouvez mettre ces deux projets dans un groupe de projets.
8. Écrire des tests
Le projet 1 n'est pas différent de l'écriture d'un programme DEPHI. Les tests sont écrits en ingénierie n ° 2, et j'appelle le nom du n ° 2 du n ° 2. Ajoutons un test de base à Core pour vérifier si 1 + 1 est égal à 2.
Créer un test
Unit TestBasic;
interface
usages
TestFramework;
taper
Tbasic = classe
publique
Fonction Add (a, b: entier): entier;
fin;
Ttestbasic = classe (ttestcase)
Privé
Fbasic: tbasic;
publique
Configuration de la procédure;
Déclusion de procédure;
publié
procédure TestAdd;
fin;
Mise en œuvre
fonction tbasic.add (a, b: entier): entier;
Commencer
Résultats: = a + b;
fin;
procédure ttestBasic.setup;
Commencer
Fbasic: = tbasic.create;
fin;
Procédure ttestBasic.Teardown;
Commencer
Fbasic.free;
fin;
Procédure ttestBasic.TestAdd;
Commencer
CheckkeQuals (2, fbasic.add (1, 1));
fin;
Initialisation
RegisterTest ('', ttestBasic.Suite);
fin.
Modifier core.bdsproj (kao, quel suffixe bizarre)
Le changement commence à fin.
exportations
Nom des tests enregistrés «test»;
fin.
Et ajouter TestFramework dans la section UTILISATION.
Dunit utilise cette fonction d'exportation pour trouver le testcase que nous avons enregistré dans la DLL.
9. Exécuter Dunit
Ajoutez Dunit au menu des outils, c'est beaucoup plus pratique. C'est juste que les paramètres sont difficiles à remplir. Je n'ai pas utilisé la macro à l'intérieur, j'ai juste rempli le chemin absolu. Si vous remplissez le chemin absolu comme moi, sélectionnez Dunit dans le menu des outils et vous pouvez voir directement une liste de tests.
Si vous n'ajoutez pas DUNIT au menu des outils, vous devez trouver la DLL compilée à partir du projet CORE, Core.dll, à partir de la fenêtre de sélection de fichiers du fichier-> Test de chargement.
———
Jusqu'à présent, il y a à la fois des fonctions de refactorisation et des tests unitaires. Tout ce qui reste est d'ajouter des tests au code existant, puis de les refactoriser lentement.