Usé Java antes, y podría hacer cualquier cosa con Eclipse. Ahora, debido a que quiero usar Delphi para modificar un software de mensajería instantánea, me pregunto cómo mover el sistema de reconstrucción y prueba unitaria a Delphi. El libro dice que agregar pruebas unitarias al código existente puede profundizar su comprensión del código y servir como base para mejorar el código. Entonces, para construir una plataforma tan ágil, hice un pequeño intento con Delphi2005 y Dunit, y registré los resultados a continuación para compartir con usted.
1. Descargar Delphi2005
Debido a que Borland no vende versiones profesionales en China, dado el alto precio de los arquitectos y las versiones empresariales, solo puede descargar una versión D de Internet para uso personal. Delphi2005 es relativamente grande, y Update1 también requiere CD, por lo que se recomienda usar BT para descargar la versión 2CD. La dirección de la semilla es la siguiente:
http://www.delphhifans.com/softview/821.html
2. Descargue el SP1 de Delphi2005
Se dice que después de aplicar este parche, puede ser más rápido, pero el parche es lento y aún necesita usar un CD. La dirección de descarga es la siguiente:
http://www.delphhifans.com/softview/970.html
3. Descargar Dunit
https://sourceforge.net/projects/dunit/
4. Instale Delphi2005+SP1
Tenga en cuenta que hay un registro en Keygen y al instalar, debe instalar las versiones .NET y Win32 de Delphi al mismo tiempo, pero C# Builder no importa. Porque si solo instala la versión Win32, la función de reconstrucción no estará disponible (este es un error en Delphi2005, que se manifiesta como una ventana de excepción de .NET al refactorizar).
5. Simplifique Delphi2005
Debido a que la versión .NET se instaló al mismo tiempo en el paso anterior, Delphi se hizo muy lento al comenzar. Esto se puede lograr modificando el registro y eliminando algunos paquetes IDE. El método específico es agregar el parámetro -rxxx después del objetivo de acceso directo de Delphi, es decir, bds.exe -rxxx. Este XXX es para que lo especifique, y luego encontrará esos malditos paquetes en HKEY_CURRENT_USER/Software/Borland/xxx (este es el nombre que seleccionó xxx) /3.0/ conocidos paquetes IDE. Tenga en cuenta que no puede eliminarlo demasiado limpiamente como otras moléculas purificadas Win32 en Internet, ya que será inútil para la reconstrucción. Una lista relativamente simple que he obtenido después de experimentar muchas veces es la siguiente.
"$ (Bds) // bin // vclmenudesigner90.bpl" = "(sin título)"
"$ (Bds) // bin // win32debugproide90.bpl" = "(sin título)"
"$ (Bds) // bin // htmide90.bpl" = "paquete de diseñador html"
"$ (Bds) // bin // iteidew3290.bpl" = "entorno de traducción integrada de Borland para win32"
"$ (Bds) // bin // srcmanide90.bpl" = "(sin título)"
"$ (Bds) // bin // todoide90.bpl" = "Borland TODO"
"$ (Bds) // bin // htmlhelp290.bpl" = "borland htmlHelp Viewer"
"$ (Bds) // bin // iDefileFilters90.bpl" = "IDE FileFilters"
"$ (Bds) // bin // startPageide90.bpl" = "paquete de página de inicio de Borland IDE"
"$ (Bds) // bin // refactoride90.bpl" = "paquete de refactorización de núcleo de Borland"
"$ (Bds) // bin // dbkdebugide90.bpl" = "(sin título)"
"$ (Bds) // bin // excepcionDiag90.bpl" = "(sin título)"
"$ (Bds) // bin // desplegable90.bpl" = "gerente de implementación"
"$ (Bds) // bin // plugview90.bpl" = "paquete de vista de árbol encogido"
"$ (Bds) // bin // correproide90.bpl" = "Core IDE Pro Package"
"$ (Bds) // bin // ideTools90.bpl" = "Build Herramients"
"$ (Bds) // bin // unittestide90.bpl" = "(sin título)"
"$ (Bds) // bin // Historyide90.bpl" = "(sin título)"
"$ (Bds) // bin // htmltidy90.bpl" = "html tidy formatter"
"$ (Bds) // bin // htmlfmt90.bpl" = "html formatter interno"
"$ (Bds) // bin // mlcc90.bpl" = "Paquete de finalización del código de idioma de marcado"
"$ (Bds) // bin // delphivclide90.bpl" = "paquete Delphi VCL Designer IDE"
"$ (Bds) // bin // delphicoreproide90.bpl" = "(sin título)"
"$ (Bds) // bin // win32debugide90.bpl" = "(sin título)"
"$ (Bds) // bin // htmlide90.bpl" = "(sin título)"
"$ (Bds) // bin // delphide90.bpl" = "delphi win32 ide personalidad"
"$ (Bds) // bin // mtspro90.bpl" = "(sin título)"
"$ (Bds) // bin // mtsent90.bpl" = "(sin título)"
"$ (Bds) // bin // iteidenet90.bpl" = "entorno de traducción integrada de Borland para .net"
"$ (Bds) // bin // netimportwiz90.bpl" = "(sin título)"
"$ (Bds) // bin // dataxplorer90.bpl" = "(sin título)"
Aunque todavía es un poco lento para comenzar, finalmente puede soportarlo.
6. Compilar e instalar Dunit
Use el método que conoce para compilar Dunit en DCU y colóquelo en el directorio que especificó. Y agregue este directorio a la ruta de la biblioteca de las herramientas de Delphi-> Opciones de entorno-> Opciones Delphi-> Library-Win32.
También compilar dunit.exe
7. Establecer un proyecto
La forma en que recomiendo es separar la interfaz y el fondo al escribir un programa Delphi, específicamente para abrir dos proyectos, un proyecto VCL ordinario y el otro proyecto DLL. No, no, no quiero dejarte compartir código en DLL. Este proyecto DLL contiene archivos que son todos contenido de fondo, así como pruebas en segundo plano. La DLL generada se usa para Dunit, de la cual Dunit puede leer la prueba y ejecutarla. De hecho, el proyecto en la parte GUI contiene todos los archivos.
El proyecto se divide en tres partes: GUI, Core y Testcore. El proyecto uno incluye GUI+Core, y el Proyecto Two incluye Core+TestCore. La salida del Proyecto 1 es el programa Win32Exe. La segunda salida del proyecto es el programa Win32DLL.
Luego puede poner estos dos proyectos en un grupo de proyectos.
8. Escribe pruebas
El Proyecto 1 no es diferente de escribir un programa de DEPHI. Las pruebas están escritas en la Ingeniería No. 2, y yo llamo el nombre de la Ingeniería No. 2 Core. Agregamos una prueba básica al núcleo para verificar si 1+1 es igual a 2.
Crear escenario de prueba
TestBasic unitario;
interfaz
usos
TestFramework;
tipo
Tbasic = clase
público
función add (a, b: entero): entero;
fin;
TtestBasic = class (ttestcase)
Privado
FBASIC: TBASIC;
público
Configuración del procedimiento;
desgarro del procedimiento;
publicado
Procedimiento TestAdd;
fin;
Implementación
función tbasic.add (a, b: entero): integer;
Comenzar
Resultados: = A + B;
fin;
procedimiento ttestbasic.setup;
Comenzar
Fbasic: = tbasic.create;
fin;
procedimiento ttestBasic.Teardown;
Comenzar
FBasic.Free;
fin;
procedimiento ttestbasic.testadd;
Comenzar
Checkequals (2, fbasic.add (1, 1));
fin;
Inicialización
RegisterTest ('', ttestbasic.suite);
fin.
Modificar Core.bdsproj (Kao, qué sufijo extraño)
Cambiar comienza.
exportaciones
RegistredTests Nombre 'prueba';
fin.
Y agregue TestFramework en la sección Usos.
Dunit utiliza esta función de exportación para encontrar la prueba de prueba que registramos en la DLL.
9. Corre Dunit
Agregue Dunit al menú Herramientas, es mucho más conveniente. Es solo que los parámetros son difíciles de completar. No usé la macro interior, solo llené el camino absoluto. Si llena la ruta absoluta como yo, seleccione Dunit en el menú Herramientas y puede ver directamente una lista de pruebas.
Si no está agregando DUNIT al menú Herramientas, debe encontrar la DLL compilada desde el proyecto Core, Core.dll, desde la ventana Selección de archivos del archivo-> Test de carga.
———
Hasta ahora, hay funciones de refactorización y pruebas unitarias. Todo lo que queda es agregar pruebas al código existente y luego refactuarlas lentamente.