Pruebe:: Cmd es un módulo Perl para pruebas portátiles de órdenes y guiones.

SINOPSIS

use la Prueba:: Cmd;

$test = Prueba:: Cmd-> nuevo (prog => program_or_script_to_test,
intérprete => script_interpreter,
ensarte => identifier_string,
workdir =>,
subdir => dir,
match_sub => $code_ref,
verboso => 1);

$test-> verboso (1);

$test-> prog (program_or_script_to_test);

$test-> basename (@suffixlist);

$test-> intérprete (script_interpreter);

$test-> cuerda (cuerda de identificador);

$test-> workdir (prefijo);

$test-> workpath (subdir, archivo);

$test-> subdir (subdir...);
$test-> subdir ([suscripción, dir]...);

El $test-> escribe (archivo, <<EOF);
contenido de archivo
EOF
El $test-> escribe ([subdir, archivo], <<EOF);
contenido de archivo
EOF

$test-> leído ($contents, archivo);
$test-> leído (@lines, archivo);
$test-> leído ($contents, [subdir, archivo]);
$test-> leído (@lines, [subdir, archivo]);

$test-> escribible (dir);
$test-> escribible (dir, $rwflag);
$test-> escribible (dir, $rwflag, %errors);

$test-> vedado (condición...);

$test-> limpieza (condición);

$test-> ejecutado (prog => program_or_script_to_test,
intérprete => script_interpreter,
chdir => dir, args => argumentos, stdin => <<EOF);
insumo para programar
EOF

$test-> pase (condición);
$test-> pase (condición, &func);

El $test-> falla (condición);
El $test-> falla (condición, &func);
El $test-> falla (condición, &func, $caller);

$test-> no_result (condición);
$test-> no_result (condición, &func);
$test-> no_result (condición, &func, $caller);

$test-> stdout;
$test-> stdout ($run_number);

$test-> stderr;
$test-> stderr ($run_number);

$test-> partido (@lines, @matches);
$test-> partido ($lines, $matches);

$test-> match_exact (@lines, @matches);
$test-> match_exact ($lines, $matches);

$test-> match_regex (@lines, @regexes);
$test-> match_regex ($lines, $regexes);

$test-> diff_exact (@lines, @matches, @output);
$test-> diff_exact ($lines, $matches, @output);

$test-> diff_regex (@lines, @regexes, @output);
$test-> diff_regex ($lines, $regexes, @output);

suscripción func {
mi ($self, $lines, $matches) = _;
# codifique para emparejar el $lines y el $matches
}
$test-> match_sub (&func);
El $test-> match_sub (suscripción {codifican para emparejar el $ _ [1] y $ _ [2]});

$test-> aquí;

La Prueba:: Cmd módulo proporciona un marco bajo a pruebas automatizadas portátiles de órdenes ejecutables y guiones (en cualquier lengua, no sólo Perl), sobre todo manda y guiones que se relacionan con el sistema de archivo.

La Prueba:: Cmd módulo no hace ningunas asunciones sobre lo que constituye una prueba acertada o fracasada. El intento de leer un archivo que doesnt existen, por ejemplo, puede o puede no ser un error, según el software probado.

Por consiguiente, ninguna Prueba:: Cmd métodos (incluso el nuevo () método) salida, muera o lance cualquier otra clase de excepciones (pero todos ellos devuelven indicaciones de error útiles). Las excepciones u otro estado de error deberían ser manejados por una capa más alta: una subclase de Prueba:: Cmd, u otro marco de pruebas, como la prueba o Prueba:: módulos Perl Simples, o por la prueba sí mismo.
(Que dijo, ver la Prueba:: Cmd:: módulo Común si usted quiere un módulo similar que proporciona la excepción manejarse, para usar directamente en sus propias pruebas, o como un ejemplo de como usar la Prueba:: Cmd.)

Además de ejecutar pruebas y evaluar condiciones, la Prueba:: Cmd módulo puede y limpia uno o varios directorios de zona de trabajo temporales, y proporciona métodos a crear archivos y directorios en aquellos directorios de zona de trabajo de datos de inline (es decir aquí-documentos), permitiendo pruebas ser completamente autónomas. Cuando usado junto con otro marco de pruebas, la Prueba:: Cmd módulo puede funcionar como un encuentro (código de inicializador común para pruebas múltiples) para la dirección simple de ejecución de orden y zonas de trabajo temporales.

La Prueba:: Cmd módulo hereda File::Spec métodos (file_name_is_absolute (), catfile (), etc.) para apoyar la escritura prueba portably a través de una variedad de sistemas de archivo y funcionamiento.

Una Prueba:: Cmd objeto de ambiente es creada vía la invocación habitual:

El $test = Prueba:: Cmd-> nuevo ();

Los argumentos a la Prueba:: Cmd:: nuevo método son pares de valor de la clave de búsqueda que pueden ser usados para iniciar el objeto, típicamente invocando el mismo - llamado el método como la clave de búsqueda.

La Suite de prueba de TAHI proporciona un mecanismo a validar una realización IPv6 contra una prueba estandarizada de la conformidad a la especificación IPv6, extensiones y protocolos directamente relacionados.

El Proyecto de TAHI es el esfuerzo conjunto formado con el objetivo de desarrollo y suministro de la tecnología de verificación para IPv6.

El proceso de crecimiento de IPv4 era la historia de encontrar varias clases de obstáculos y conquistar tales obstáculos. Sin embargo, una vez la posición cuando la infraestructura fue establecida, no se permite repetir la misma historia. Esto es una razón por qué la tecnología de verificación es esencial para el despliegue IPv6.

Investigamos y desarrollamos pruebas de conformidad y pruebas de interoperabilidad de IPv6.

Estrechamente trabajamos con el proyecto de KAME y proyecto de USAGI. Ayudamos a actividades de ellos en el lado de calidad ofreciendo la tecnología de verificación que desarrollamos en el TAHI proyectan y mejoran la eficiencia de desarrollo.

Abrimos los resultados y las frutas del proyecto al público gratis. Cualquier revelador preocupado con IPv6 puede utilizar los resultados y las frutas del proyecto de TAHI libremente. Un izquierdo de copia desempeña un papel importante en el progreso del Internet. Creemos que el suministro de la tecnología de verificación gratis contribuye a anticipos de IPv6. Además de los programas, las especificaciones y los criterios de la verificación serán incluidos en el Paquete.

Whats Nuevo en Esta Liberación:

· bugfixes menor en el salto cuentan la validación.

Los OpenGuides:: prueba son métodos de ayudar a probar aplicaciones OpenGuides.

Proporciona métodos de ayudar escribiendo pruebas de OpenGuides. Distribuido e instalado como parte del proyecto de OpenGuides, no querido para instalación independiente. Esta documentación sólo es probablemente útil para reveladores OpenGuides.

SINOPSIS

use OpenGuides;
use OpenGuides:: Prueba;

mi $config = OpenGuides:: Prueba-> make_basic_config;
$config-> default_language ("nl");

mi $guide = OpenGuides-> nuevo (config => $config);

OpenGuides:: Prueba-> write_data (
dirija => $guide,
nodo => "Taberna de Crabtree",
os_x => 523465,
os_y => 177490,
categorías => "Bares",
);

El Multitenedor:: de la prueba es una suite de prueba que tiene el apoyo a programas de multiproceso.

SINOPSIS

use la Prueba:: Multitenedor;

($name, $letter, $number) = procname ([nuevo nombre])
lockcommon ()
@oldvalues = getcommon ()
setcommon (@newvalues)
unlockcommon ()

use la Prueba:: Multitenedor qw (groupwait setgroup dofork stderr bail_on_bad_plan)

groupwait ([$tag])
$oldgroup = setgroup ([$newgroup])
dofork (fork_specification)

Este módulo de prueba debe apoyar suites de prueba de creación para programas y módulos que se ejecutan como procesos múltiples y hacen la entrada-salida sobre todo obstructora.

Pruebe los apodos de Multitenedor:: la bifurcación de modo que ella pueda alistar a cada niño para coordinar la producción. La producción de cada tenedor de niño es desviada al padre. Cada tenedor produce la producción de prueba normal - posiblemente utilización de módulos de prueba normales como la Prueba:: Simple. La producción es coleccionada y vuelta a escribir por el proceso paternal.

Cada tenedor de niño tiene la designación de número y una carta. Los tenedores son creados por dofork (). Dofork toma un specifiction en la forma: ([a-z] (d *)) +. O sea, una o varias minúsculas, cada uno opcionalmente followd por un número. El número dice cuantos niños bifurcarse para aquella carta (falta un). Los specifier ab2c3 medios tienen un un niño (numeró 1); dos niños b (numeró 1, 2); y tres niños c (numeró 1, 2, 3).

Para ayudar en la escritura de pruebas, la Prueba:: Multitenedor pasará datos entre los procesos hijos. Los datos son el escritor de prueba definido.

Pruebe:: TestCoverage es el módulo Perl para probar si su prueba cubre todas las subrutinas públicas del paquete.

SINOPSIS

use la Prueba:: TestCoverage;

test_coverage (Mi Módulo::);

mi $obj = Mi Módulo::-> nuevo ();
$obj-> foo ();
$obj-> barra ();

# la prueba estará okey, supuso que Mi Módulo:: tenga las subrutinas nuevas, foo y barra
ok_test_coverage (Mi Módulo::);

reset_test_coverage (Mi Módulo::);
reset_all_test_coverage ();

test_coverage (Mi Módulo::);

mi $obj = Mi Método::-> nuevo ();
$obj-> foo ();

# la prueba estará no okey, porque la barra no es invocada
ok_test_coverage (Mi Módulo::);

reset_test_coverage (Mi Módulo::);
reset_all_test_coverage ();

test_coverage (Mi Módulo::);
test_coverage_except (Mi Módulo:: barra);

mi $obj = Mi Método::-> nuevo ();
$obj-> foo ();

# la prueba estará okey, porque la barra es excluida de la prueba
ok_test_coverage (Mi Módulo::);

Si un módulo es escrito, la tapa de prueba sólo unas subrutinas del módulo. Este módulo pretende apoyar al autor en la escritura de pruebas "completas". Si una de las subrutinas "públicas" es perdida en el testscript, la prueba ok_test_coverage fallará.

las subrutinas "privadas" son definidas como subrutinas que los nombres comienzan con _ como _private_sub {...} "y el público" es la parte de enfrente.

Pruebe:: CPANpm es un módulo Perl para probar una interacción de distribuciones con CPAN antes de subir.

SINOPSIS

use la Prueba:: CPANpm;
use la Prueba:: Más qw (no_plan);

cpan_depends_ok (
[Interfaz común de pasarela, el Módulo:: Construye, Cumbre:: Wabbit],
consiguió las dependencias correctas
);

cpan_depends_ok_force_missing (
[Algún Módulo:::: Construye la Subclase:: el interfaz común de pasarela, Módulo los:: Construyen, Cumbre:: Wabbit],
[Algún Módulo:::: Construye la Subclase::],
consiguió dependencias aunque nuestro Módulo:: Construya la subclase falla
);

Pruebe:: CPANpm engaña CPAN.pm en el pensamiento que esto ha descargado y ha desempaquetado su paquete, luego lo hace intentar generar un Makefile o Construir el guión. Después de que este proceso completa, pregunta a su módulo CPAN que dependencias que piensa existen.

Si usted sólo quiere asegurarse que su distribución es embalada en un camino que está bien para CPAN, considerar la prueba de utilización:: Distribución en cambio. El tiempo principal que la Prueba:: CPANpm es útil es cuando usted depende de módulos dentro de su Makefile. Los GRÁFICOS o Construyen. El guión de GRÁFICOS y usted quieren asegurarse que usted degrada elegantemente si aquellos módulos no están disponibles.

Pruebe:: MockDBI es la interface DBI fingida del módulo Perl para pruebas.

SINOPSIS

use la Prueba:: MockDBI;
O

use la Prueba:: MockDBI qw (:all);

Pruebe:: MockDBI:: set_dbi_test_type (42);
si (Prueba:: MockDBI:: get_dbi_test_type () == 42) {
...

$mock_dbi = get_instance Prueba:: MockDBI;

$mock_dbi-> bad_method (
$method_name,
$dbi_testing_type,
$matching_sql);

$mock_dbi-> bad_param (
$dbi_testing_type,
$param_number,
$param_value);

$mock_dbi-> set_retval_array (
$dbi_testing_type,
$matching_sql,
@retval || CODEREF);
$mock_dbi-> set_retval_array (MOCKDBI_WILDCARD...

$mock_dbi-> set_retval_scalar (
$dbi_testing_type,
$matching_sql,
$retval || CODEREF);
$mock_dbi-> set_retval_scalar (MOCKDBI_WILDCARD...

$mock_dbi-> set_rows (
$dbi_testing_type,
$matching_sql,
$rows || CODEREF);
$mock_dbi-> set_rows (MOCKDBI_WILDCARD...

Pruebe:: MockDBI proporciona un modo de probar interfaces DBI creando reglas para cambiar el comportamiento DBIs, luego examinando la producción estándar de emparejar modelos.

Probando usando la Prueba:: el MockDBI es habilitado poniendo el DBI que prueba el tipo a un valor distinto a cero. Esto puede ser hecho usando un primer argumento de programa de "- dbitest [=TYPE]", o usando la prueba de método de clase:: MockDBI:: set_dbi_test_type (). (El suministro de un primer argumento de "- dbitest [=TYPE]" a menudo trabaja bien durante pruebas.) el TIPO es un número entero simple (/^d+ $/). Suministrando "- dbitest [=TYPE]" cuando un primer argumento trabaja aun si ningún otro procesamiento de línea del orden es hecho, cuando la Prueba:: MockDBI hace su propio procesamiento de línea del orden para comprobar esto primero "- dbitest [=TYPE]" argumento.

Usted querrá añadir "- dbitest [=TYPE]" durante un bloque COMENZAR antes "de la prueba de uso:: MockDBI", de modo que DBI fingido sea iniciado tan pronto como sea posible.

EL TIPO es opcional, cuando un primer argumento de "- dbitest" pondrá el DBI que prueba el tipo a 1 (un). Las pruebas de DBI también son inhibidas por "- dbitest=0" (aunque esto pueda no ser generalmente útil). La prueba de método de clase:: MockDBI:: set_dbi_test_type () también puede ser usada para poner o cambiar el DBI que prueba el tipo.

Pruebe:: Struct es una extensión Perl para probar de equivelence estructural.

SINOPSIS

use la Prueba:: Struct;

deep_eq ($hairy_struct, $expected, prueba estructural Peluda);
es ($x, $y); ¡# y todo lo demás la Prueba:: el Más tiene que ofrecer!

Pruebe:: Struct está usado para hacer comparaciones profundamente estructurales de dos objetos. El módulo contiene sólo un subrotuine que es querido para estar usado cuando una mezcla - en con otra más prueba genérica:: Constructor sacó módulos como Prueba:: Más o Prueba:: Simple. El código normalmente usa el Escalar:: Util para inspeccionar los datos, pero esto también usará las herramientas de comparación ajustadas de la multa adicional de Datos:: Vertedero:: Flámula si ellos están disponibles.
deep_eq ($got, $expected, $name)

Hace una comparación de nivel profunda de dos objetos. Esto cruza las dos estructuras en la paralela que comprueba tantos atributos como esto puede para diferencias. Si los objetos se diferencian esto va la producción un mensaje diagnóstico que contiene una lista de las diferencias que esto encontró antes de que esto terminara la comparación. Algunos tipos de la falta de armonía previenen la comparación adicional entonces la lista puede no ser exhaustiva.

La intención de esta rutina consiste en que pasará la prueba sólo si el $got es funcionalmente idéntico al $expected. Sin embargo, en el tiempo corriente hay algunos tipos de datos que no se maneja correctamente, como el CÓDIGO refs.

Pruebe:: STDmaker es un módulo Perl para generar guiones de prueba, guiones de demostración de una taquigrafía de descripción de prueba.

SINOPSIS

#######
# Procesal (subrutina) interface
#
use la Prueba:: STDmake qw (find_t_roots get_data perl_command);

@t_path = find_t_paths ()
$date = get_date ();
$myperl = perl_command ();

#####
# Interface de clase
#
use Prueba:: STDmaker

$std = nueva Prueba:: STDmaker (@options); # de File::Maker

$success = $std-> check_db ($std_pm);
@t_path = $std-> find_t_paths ()
$date = $std-> get_date ();
$myperl = $std-> perl_command ();

$std-> tmake (@targets, %options);
$std-> tmake (@targets);
$std-> tmake (%options);

######
# Métodos (Privados) internos
#
El $success = $std-> construye ($std_driver_class);
El $success = $std-> genera ();
$success = $std-> letra ($file_out);

La Prueba:: STDmaker módulo de programa proporciona las capacidades siguientes:
Automatice la programación relacionada de Perl tenía que crear un guión de prueba que causa la reducción del tiempo y costar.

Traduzca una Descripción de prueba de Software de taquigrafía (STD) archivo en un guión de prueba de Perl que finalmente hace el uso del módulo de Prueba.

Traduzca el fichero de datos STD de mano de la clase en un guión de demostración Perl que demuestra los aspectos del módulo en la prueba.

Proporcione en la VAINA de una información de archivo STD requerida por una Descripción de prueba de Software del Gobierno Militar/federal (STD) el documento que puede ser fácilmente el índice y tuvo acceso por el software de prueba automatizado. Organización internacional para la normalización, los Militares británicos requieren la mayor parte de la misma información, agencias estadounidenses, como el FAA. La diferencia es que organización internacional para la normalización, los Militares británicos no dictan el formato de detalle. Las agencias estadounidenses, como el FAA adaptarán generalmente abajo formatos requeridos de DOD.

Así, hay una muy amplia variación en el formato de la misma información entre actividades comericial certificadas de la organización internacional para la normalización y militares además de EE.UU. Una vez que la información está en una VAINA, los traductores diferentes pueden formatear casi exactamente como dictado por el usuario final, si es DOD estadounidense, la organización internacional para la normalización certificó actividad commericial, Militares británicos o quienquiera. Siendo capaz de proporcionar el más exigente, que es DOD por lo general estadounidense, las capacidades están allí para todo los demás.

La Prueba:: STDmaker paquete libera al diseñador y revelador de la carga de llenar plantillas de plato de caldera de procesador de textos (si partido de desempate, Palabra, o vi), contando oks, proporcionando ejemplos de documentación, remontando pruebas para probar requirments, asegurándose que está en el corporativo apropiado, organización internacional para la normalización o formato militar, y otro tal sumamente llevar mucho tiempo, aburrido, tareas de apoyo de desarrollo. En cambio los diseñadores y los reveladores sólo tienen que rellenar una forma usando una taquigrafía de descripción de prueba. La Prueba:: STDmaker lo tomará desde allí y automáticamente y rápidamente generará los guiones de prueba deseados, guiones de demostración, y probará documentos de descripción.

Mire la economía. Esto no tiene económicamente el sentido de tener el talento caro hacen este trabajo. En no tiene hasta económicamente el sentido de tomar un de 16 años brillante, en el salario mimimum y tenerle a mano cuentan oks. Perl puede contar a aquellos oks mucho mucho más barato y es tan fácilmente a automatizado con Perl. Y algo como esto era usted lo hacen año en y año, guardar es enorme. A un director del proyecto u oficial de contrato, esto es lo que la programación y ordenadores es todos sobre, ahorrando el dinero y aumentando la productividad, no se oponen programar orientado orientado, gotos u otras tales cosas.

La Prueba:: STDmaker paquete de clase automatiza la generación de Descripciones de prueba de Software (STD) Vieja Documentación Clara (VAINA), guiones de prueba, guiones de demostraciones y la ejecución de los guiones de prueba generados y guiones de demostración. Esto insertará automáticamente la producción del guión de demostración en la VAINA-headx la sección de Demostración del archivo probado.

Pruebe:: TempDatabase es un módulo Perl para creación de base de datos temporal y destrucción.

SINOPSIS

use la Prueba:: TempDatabase;

mi $td = Prueba:: TempDatabase-> crea (dbname => temp_db);
mi $dbh = $td-> apodo;

... algunas pruebas...
# Pruebe:: TempDatabase base de datos de gotas

Este módulo automatiza la creación y la caída de bases de datos de prueba.

USO

Cree la prueba de utilización de base de datos de prueba:: TempDatabase-> crean. Use el apodo para conseguir un apodo a la base de datos. La base de datos será automágicamente dejada caer cuando la Prueba:: TempDatabase caso sale del alcance.

$class-> become_postgres_user

Ejecutándose como la raíz, esta función se hace el usuario diferente. Esto decide el nombre de usuario sondando TEST_TEMP_DB_USER, variables de ambiente de SUDO_USER. Si estas variables son vacías, el usuario "postgres" por defecto está usado.
crear

Crea la base de datos temporal. Será dejado caer cuando el caso que resulta saldrá del alcance.

Los argumentos son pasados en como unos pares de valor de la clave de búsqueda. Las claves de búsqueda disponibles son:
dbname: el nombre de la base de datos temporal.

resto: el resto de la cuerda de conexión de base de datos. Esto puede ser usado para conectar a un servidor diferente, etc.

nombre de usuario, contraseña: que se explica por sí mismo.

El interfaz común de pasarela:: prueba es un marco de prueba de regresión de interfaz común de pasarela.

SINOPSIS

# En un poco de prueba de regresión t/script.t, por ejemplo
use el interfaz común de pasarela:: Prueba; # exporta okey ()

mi $ct = interfaz común de pasarela:: Prueba-> nuevo (
-base_url => "http://some.server:1234/cgi-bin",
-cgi_dir => "/path/to/cgi-bin",
);

mi $page = $ct-> SE PONE ("http://some.server:1234/cgi-bin/script?arg=1");
okey 1, $page-> content_type = ~ m|text/htmlb |;

mi $form = $page-> formas-> [0];
okey 2, $form-> acción eq "/cgi-bin/some_target";

mi $menu = $form-> menu_by_name ("meses");
okey 3, $menu-> is_selected ("Enero");
¡okey 4! $menu-> is_selected ("marzo");
okey 5, $menu-> múltiple;

mi $send = $form-> submit_by_name ("send_form");
okey 6, $send definido;

#
# Ahora relaciónese con el interfaz común de pasarela
#

$menu-> escogido ("marzo"); # "hacen clic" en la etiqueta de marzo
mi $answer = $send-> prensa; # "hacen clic" en el botón enviar
okey 7, $answer-> is_ok; # y se aseguran nosotros dont consiguen un error de HTTP

El interfaz común de pasarela:: módulo de prueba proporciona un marco de prueba de regresión de interfaz común de pasarela que permite que usted para ejecutar su interfaz común de pasarela programe fuera de línea, es decir fuera de un servidor web, y relacionarse con ellos programaticalmente, sin la necesidad de teclear datos y clic de un navegador de web.

Si youre utilización del módulo de interfaz común de pasarela, usted puede ser familiar con su modo de pruebas fuera de línea. Sin embargo, este modo es apropiado para cosas simples, y no hay ningún apoyo a conducir una sesión llena con un guión stateful. El interfaz común de pasarela:: prueba llena este hueco proporcionando la infraestructura necesaria para ejecutar guiones de interfaz común de pasarela, luego analizar la producción para construir objetos que pueden ser preguntados, y en que usted puede relacionarse para "jugar" con los artefactos de control de guiones, finalmente presentando datos atrás. Etcétera...
Note que los guiones de interfaz común de pasarela usted puede probar con el interfaz común de pasarela:: la prueba no tienen que ser puestos en práctica en Perl en absoluto. Por lo que este marco está preocupado, los guiones de interfaz común de pasarela son executables que son ejecutados en un ambiente PARECIDO A UN INTERFAZ COMÚN de PASARELA y que producen una producción.

Para usar el interfaz común de pasarela:: marco de Prueba, usted tiene que configurar un interfaz común de pasarela:: objeto de prueba de actuar como un servidor web, proporcionando la base de URL donde los guiones de interfaz común de pasarela están en este pseudoservidor, y qué directorio físico equivale a aquella base de URL.
A partir de entonces, usted puede resultar CONSIGUEN Y PONEN UNA NOTA peticiones que dan un URL, y el pseudoservidor devuelve un interfaz común de pasarela:: Prueba:: objeto de Página que representa el resultado de la petición. Esta página puede ser un error, texto sin formato, algunos datos binarios, o una página de HTML (ver el interfaz común de pasarela:: Prueba:: Página para detalles).

Éste (una página de HTML) puede contener una o varias formas de interfaz común de pasarela (identificado por las etiquetas), que son descritos por casos del interfaz común de pasarela:: Prueba:: objetos de Forma (ver el interfaz común de pasarela:: Prueba:: Forma para detalles).

Las formas pueden ser preguntadas para ver si ellos contienen un tipo particular del artefacto (menú, área de texto, botón, etc...), de un nombre particular (thats el nombre de parámetro de interfaz común de pasarela). Una vez encontrado, uno puede relacionarse con un artefacto cuando el usuario iba de un navegador. Los artefactos son descritos por objetos polimorfos que se conforman con el interfaz común de pasarela:: la Prueba:: Forma:: tipo de Artefacto. La interacción específica que es ofrecida depende del tipo dinámico del objeto (ver el interfaz común de pasarela:: Prueba:: Forma:: Artefacto para detalles).

Una interacción con una forma se termina por una sumisión de los datos de forma al servidor, y regreso de una respuesta. Esto es hecho pulsando un botón presentar, y la prensa () la rutina devuelve una nueva página. Naturalmente, no se ponen en contacto a ningún servidor en absoluto dentro del interfaz común de pasarela:: marco de Prueba, y el guión de interfaz común de pasarela es traspasó una llamada apropiada a uno del método PONER/PONER UNA NOTA en el interfaz común de pasarela:: objeto de Prueba.

Finalmente, ya que el interfaz común de pasarela:: prueba se supone para estar usado de guiones de prueba de regresión, esto exporta un single okey () rutina que simplemente imprime los mensajes esperados por la Prueba:: Guarniciones. Esto es la única rutina funcional en este módulo, todos otros accesos hechos por un interfaz común de pasarela:: objeto de Prueba.

Pruebe:: UseAllModules es un módulo Perl que usa use_ok () función para todos los módulos MANIFESTADOS.

SINOPSIS

# uso básico
use estricto;
use la Prueba:: UseAllModules;

COMIENCE {all_uses_ok ();}

# si usted tiene módulos thatll fallan use_ok () para ellos
use estricto;
use la Prueba:: UseAllModules;

COMIENCE {
all_uses_ok excepto => qw (
Algún Módulo:: Dependiente::
Otro Módulo:: Dependiente::
^Yet:: Otro::.* dependiente:: # usted puede usar regex
)
}

Im enfermos de escribir 00_load.t (o algo así) thatll hacen use_ok () para cada módulo que escribo. Im más enfermo de actualizar 00_load.t cuando añado otro archivo al distro. Este módulo lee la MANIFESTACIÓN para encontrar módulos siendo probados y hace use_ok () para cada uno de ellos. Ahora todo que usted tiene que hacer actualiza la MANIFESTACIÓN. Usted dont tiene que modificar la prueba más (con esperanza).

Pruebe:: Fixme es un módulo Perl para comprobar el código FIXMEs.

SINOPSIS

# En un guión de prueba como t/test-fixme.t
use la Prueba:: Fixme;
run_tests ();

# Usted también puede adaptar el comportamiento.
use la Prueba:: Fixme;
run_tests (donde => lib, # donde encontrar archivos comprobando
empareje => TODO, # que comprobar
el skip_all => $ENV {BRINCO} # debería todas las pruebas ser saltado
);

Cuando la codificación de esto es común para subir contra problemas que tienen que ser dirigidos pero no está un trato grande en este momento. Lo que generalmente pasa es que el coder añade comentarios como:

# ¿FIXME - y las ventanas que son más grandes que el monitor?

# FIXME - añaden la comprobación del usuario priviledges aquí.

Pruebe a Fixme:: permite que usted añada un archivo de prueba que asegura que ninguno de éstos es olvidado en el módulo.

Argumentos

En ausencia el run_tests buscará FIXME en todos los archivos que esto puede encontrar en el proyecto. Usted puede cambiar estas faltas usando donde o emparejan como sigue:

el run_tests (donde => lib, # sólo comprueban los módulos.
empareje => TODO # buscan cosas que aún no son hechas.
);

Pruebe:: ISBN es un módulo Perl para comprobar números de libro estándar internacional.

SINOPSIS

use la Prueba:: Más pruebas => 1;
use la Prueba:: ISBN;

isbn_ok ($isbn);

Funciones

isbn_ok (CUERDA)

Okey es la CUERDA es ISBN válido, en cualquier formato que el Negocio:: ISBN acepta. Esta función sólo comprueba la suma de control. El editor y los códigos de país podrían ser inválidos aunque la suma de control sea válida.

isbn_country_ok (CUERDA, PAÍS)

Okey es la CUERDA es ISBN válido y su código de país es el mismo como el PAÍS.

isbn_publisher_ok (CUERDA, EDITOR)

Okey es la CUERDA es ISBN válido y su código de editor es el mismo como el EDITOR.

La Nueva suscripción:: de la prueba es un léxicamente scoped reemplazo de subrutina para pruebas.

SINOPSIS

#!/usr/bin/perl

use la Prueba:: Más pruebas => 4;
use la Prueba:: Nueva suscripción qw (nueva suscripción);

{
embale en Algún sitio;
espectáculo de suscripción {
mi ($class, $message) = _;
devuelva "el $class, el $message";
}
}

# cordura
está (en Algún sitio-> espectáculo (más allá del mar), en Algún sitio, más allá del mar);

# reemplazo de scoped de subrutina con captura de argumento
{
mi $rs = nueva suscripción en Algún sitio:: espectáculo, suscripción {hola}, captura => 1;
está (en Algún sitio-> espectáculo (sobre el arco iris), hola);
is_deeply ($rs-> method_args, [[sobre el arco iris]]);
}

# finales de alcance, la nueva suscripción se marcha, devoluciones de código originales
está (en Algún sitio-> espectáculo (esperándome), en Algún sitio, esperándome);

Este módulo permite que usted reemplace temporalmente una subrutina/método con el código arbitrario. Más tarde, usted puede contar cuantas veces era esto llamado y con que argumentos cada vez. Usted también puede especificar que la subrutina/método debe ser llamada, no debe ser llamada, o puede ser opcionalmente llamada.

Pruebe:: LectroTest es un módulo Perl con pruebas fáciles, automáticas, basadas en la especificación.

SINOPSIS

#!/usr/bin/perl-w

use MyModule; # contiene el código que queremos probar
use la Prueba:: LectroTest;

Propiedad {
## [x <-Int, y <-Int] ##
MyModule:: my_function ($x, $y)> = 0;
}, llame => "my_function la producción es no negativa";

Propiedad {...}, nombre => "una otra propiedad";

# más propiedades de comprobar aquí

Este módulo proporciona un simple (aún lleno presentado) interface a LectroTest, un sistema de pruebas automatizado, basado en la especificación para Perl. Para usarlo, declare propiedades que especifican el comportamiento esperado de su software. LectroTest entonces comprueba su software para ver si aquellas propiedades sostienen.
Declare propiedades usando la función de Propiedad, que toma un bloque de código y lo promueve a una Prueba:: LectroTest:: Propiedad:

Propiedad {
## [x <-Int, y <-Int] ##
MyModule:: my_function ($x, $y)> = 0;
}, llame => "my_function la producción es no negativa";

La primera parte del bloque debe contener una declaración obligatoria por el generador. Por ejemplo:

## [x <-Int, y <-Int] ##

(Note la puesta entre paréntesis especial, que se requiere.) Esta encuadernación particular dice, "Para todos los números enteros x y y." (A propósito, usted arent limitado con números enteros. LectroTest también le da booleans, cuerdas, listas, picadillos, y más, y esto le deja definir sus propios tipos de generador. Ver la Prueba:: LectroTest:: Generador para más.)

La segunda parte del bloque es simplemente un trocito de código que hace el uso de las variables que ligamos antes para probar si una propiedad sostiene para la pieza de software que probamos:

MyModule:: my_function ($x, $y)> = 0;

En este caso, esto afirma que MyModule:: my_function ($x, $y) devuelve un resultado no negativo. (Sí, el $x y el $y se refieren a mismo x y y que ligamos a los generadores antes. LectroTest automágicamente carga éstos léxicamente ligaron variables Perl con valores entre bastidores.)

Pruebe:: MockClass es un módulo Perl para proporcionar clases fingidas y objetos fingidos para pruebas.

SINOPSIS

# El pase del nombre de clase y versión de la cual usted quiere burlarse
use la Prueba:: MockClass qw {ClassToMock 1.1};

# cree un objeto de MockClass de manejarse una clase específica
mi $mockClass = Prueba:: MockClass-> nuevo (ClassToMock);

# especifique para heredar de una verdadera clase, o una clase burlada:
$mockClass-> inheritFrom (IO:: Enchufe);

# haga a un constructor para la clase, también puede usar addMethod para más control
$mockClass-> defaultConstructor (%classWideDefaults);

# añada un método:
$mockClass-> addMethod (methodname, $coderef);

# añada un método más simple, y especifique valores de devolución que esto devolverá automáticamente
$mockClass-> setReturnValues (methodname2, siempre, 3);

# cree un caso de la clase burlada:
mi $mockObject = $mockClass-> crea (%instanceData);

# establezca el orden de llamada deseado para los métodos:
$mockClass-> setCallOrder (methodname2, methodname, methodname);

# pruebas ejecutadas usando la Clase fingida en otra parte:
#:in la clase para probar:
suscripción objectFactory {
devuelva ClassToMock-> nuevo;
}
#:in su código de prueba:
afirme ($testObj-> objectFactory-> isa ("ClassToMock"));

# consiga la Identificación de objeto para el resto de los métodos:
mi $objectId = "$mockObject";
#or
$objectId = $mockClass-> getNextObjectId ();

# verifique que los métodos fueron llamados en la orden correcta:
si ($mockClass-> verifyCallOrder ($objectId)) {
# haga algo
}

# consiga la orden que los métodos fueron llamados:
mi @calls = $mockClass-> getCallOrder ($objectId);

# póngase la lista de argumentos pasó por llamada:
mi @argList = $mockClass-> getArgumentList ($objectId, methodname, $callPosition);

# consiga la lista de accesos hechos a un atributo particular (hashkey en el $mockObject)
mi @accesses = $mockClass-> getAttributeAccess ($objectId, atributo);

Pruebe:: URI es un módulo Perl que puede comprobar Identificadores de Recurso Uniformes (URIs).

SINOPSIS

use la Prueba:: Más pruebas => 5;
use la Prueba:: URI;

# http://www.example.com:8080/index.html#name

uri_scheme_ok ($uri, http);
uri_host_ok ($uri, www.example.com);
uri_port_ok ($uri, 8080);
uri_path_ok ($uri, /index.html);
uri_fragment_ok ($uri, nombre);

FUNCIONES

uri_scheme_ok (STRING|URI, ESQUEMA)

Okey es la CUERDA es URI válido, en cualquier formato que URI acepta, y el URI usa el mismo ESQUEMA (es decir protocolo: http, ftp...). El ESQUEMA no es el caso sensible.

LA CUERDA puede ser un objeto de URI.

uri_host_ok (STRING|URI, SERVIDOR)

Okey es la CUERDA es URI válido, en cualquier formato que URI acepta, y el URI usa al mismo SERVIDOR. EL SERVIDOR No es el caso sensible.

No Okey es el esquema URI no tiene una parte de servidor.

LA CUERDA puede ser un objeto de URI.

uri_port_ok (STRING|URI, PUERTA)

Okey es la CUERDA es URI válido, en cualquier formato que URI acepta, y el URI usa la misma PUERTA.

No Okey es el esquema URI no tiene una parte de puerta.

LA CUERDA puede ser un objeto de URI.

uri_canonical_ok

UNIMPLEMENTED. Im no seguro por qué pensé esto debería ser una prueba. Si alguien más sabe, Mal lo ponen en práctica.

uri_path_ok (STRING|URI, PASO)

Okey es la CUERDA es URI válido, en cualquier formato que URI acepta, y el URI tiene el PASO de paso. Recuerde que los pasos comienzan con un/, aun si esto al cual doesnt parecen hay algo después de las partes de servidor.

LA CUERDA puede ser un objeto de URI.

uri_fragment_ok (STRING|URI, FRAGMENTO)

Okey es la CUERDA es URI válido, en cualquier formato que URI acepta, y el URI tiene el FRAGMENTO de fragmento.

LA CUERDA puede ser un objeto de URI.

Pruebe:: C2FIT es una puerta de Perl directa de la Sala Cunninghams marco de prueba de aceptación ADECUADO para la Java.

SINOPSIS

FileRunner.pl input_containing_fit_tests.html test_results.html

perl-MTest:: C2FIT-e file_runner input_containing_fit_tests.html test_results.html

perl-MTest:: C2FIT-e fit_shell

El gran software requiere la colaboración y la comunicación. Adecuado es unas herramientas para realzar la colaboración en el desarrollo de software. Su un modo inestimable de colaborar en problemas complicados - y acertar en ellos - temprano en desarrollo.

Adecuado permite que clientela, probadores, y programadores aprendan lo que su software debería hacer y lo que esto realmente hace. Esto automáticamente compara expectativas de clientela con resultados actuales.

Esta puerta de los ADECUADOS tiene un equivalente featureset con v1.1 de ADECUADO. La puerta de inicial de Dave W. Smiths estaba basada en adecuado-b021021j e Ive actualizó la mayor parte del corazón para emparejar la 1.1 versión.

Esta puerta pasa el detalle ADECUADO corriente y también pone en práctica unos todos los ejemplos.

Las funciones siguientes son proporcionadas (y exportadas) por este módulo:
file_runner ($infile, $outfile)

Trate un DOCUMENTO ADECUADO contenido en el $infile y escribe el resultado al $outfile.
wiki_runer ($infile, $outfile)

Mismo como file_runner, salvo que no <tabla>, <tr> <y td> pero <wiki>, <tabla>, <tr> <y td> es buscado en el documento de insumo.

fit_shell

Crea una cáscara interactiva de la cual usted puede ejecutar fácilmente pruebas. Comiéncelo y escriba "la ayuda" para más información.

Suponga, sus archivos relacionados con las pruebas residen en un directorio con tres subdirectorios: el insumo - donde los archivos vienen de, producción - donde los resultados serán escritos a y lib - donde sus encuentros residen, todo que usted tiene que hacer debe escribir sólo "runall"

Registro

El file_runner y la filtración de apoyo de wiki_runner de advierten mensajes, similares al registro común javas. Para cambiar el nivel de registro, use el parámetro-L, p.ej:

perl-MTest:: C2FIT-e file_runner--L 1 input_containing_fit_tests.html test_results.html

Allí siguen niveles de registro definidos: 0 - rastro, 1 - ajuste, 2 - información, 3 - advierten, 4 - error, 5 - fatal.

En su código, simplemente use advierten "el mensaje" si debería ser imprimido incondicionalmente o advertir 1, "mensaje" si debería ser imprimido, cuando el nivel de registro es RASTRO O AJUSTE.

El nombramiento, Namespace (s)

En sus DOCUMENTOS ADECUADOS, por favor use la nota de punto de estilo de java para calificar nombres de paquete. P.ej si usted quiere el Dominio de paquete:: Objeto:: Simple de estar usado, especifíquelo escribiendo el Dominio. Objeto. Simple en su documento adecuado.
Los nombres de paquete deberían ser totalmente calificados, el caso es importat. El cuidado especial es tomado en los paquetes adecuados *, éstos pueden ser especificados cualquiera por adecuado. Nombre así como Prueba. C2FIT.Name.

El Constructor:: de la prueba es una parte trasera para construir bibliotecas de prueba.

SINOPSIS

embale Mi prueba de:::: Módulo;
use la Prueba:: Constructor;
requiera al Exportador;
@ISA = qw (Exportador);
@EXPORT = qw (okey);

mi $Test = Prueba:: Constructor-> nuevo;
$Test-> producción (my_logfile);

importación de suscripción {
mi ($self) = cambio;
mi $pack = visitante;

$Test-> exported_to ($pack);
$Test-> plan (_);

$self-> export_to_level (1, $self, okey);
}

suscripción okey {
mi ($test, $name) = _;

$Test-> okey ($test, $name);
}

Pruebe:: Simple y Prueba:: el Más ha resultado ser módulos de pruebas populares, pero theyre no siempre bastante flexible. El Constructor:: de la prueba proporciona un componente básico para escribir sus propias bibliotecas de prueba que pueden trabajar juntos.