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:: 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.
);

El Tornasol:: de la prueba es un módulo Perl para presentar resultados de prueba al Tornasol testcase herramientas de dirección.

SINOPSIS

use la Prueba:: Tornasol;

$t = Prueba:: Tornasol-> nuevo (-machinename => mycomputer,
- nombre de usuario => usuario,
-authtoken => señal,
# opcional # - servidor => http://litmus.mozilla.org/process_test.cgi,
# opcional # - acción => se rinden);

$t-> sysconfig (-producto => Firefox,
- plataforma => Windows,
-opsys => Windows XP,
- se bifurcan => Tronco,
-buildid => 2006061314,
-buildtype => depuran de cvs,
- lugar => en estadounidense);

mi $result = Prueba:: Tornasol:: Resultado-> nuevo (
-isAutomatedResult => 1, # opcional
-testid => 27,
-resultstatus => pase, # los resultados válidos son el pase
# o falle
-exitstatus => 0,
- duración => 666,
-timestamp => 20051111150944, # opcional (falta: tiempo corriente)
- comentan => comentario opcional aquí, # opcional
-bugnumber => 300010, # opcional
- registran => [Prueba:: Tornasol:: Registro-> nuevo (# opcional
- teclean => STDOUT,
- datos => foobar),
Pruebe el Tornasol:::: Registro-> nuevo (
- teclean => Extensiones Instaladas,
- los datos => registran la información aquí)]
);
$t-> addResult ($result);
# $t-> addResult ($someOtherResult);
# etc...

# añada la información de registro que debería ser conectada con
# todos los resultados (es decir variables env, config información)
$t-> addLog (Prueba:: Tornasol:: Registro-> nuevo (
- teclean => STDOUT,
- los datos => registran datos));

mi $res = $t-> se rinde ();

# El $res es 0 para errores no fatales (algunos resultados fueron presentados), y
# el undef para errores fatales (ningunos resultados fueron presentados con éxito)

si ($t-> errstr ()) {mueren el $t-> errstr ()}

la Manifestación de:: de prueba es un módulo Perl creado para relacionarse con un archivo t/test_manifest.

SINOPSIS

# en Makefile. GRÁFICOS
los eval "usan la Prueba:: Manifestación";

# en el archivo t/test_manifest, ponga en una lista las pruebas que usted quiere
# ejecutarse

Las Guarniciones de:: de prueba suponen que usted quiera ejecutarse todos los archivos.t en el directorio t/en la orden de ascii-betical durante hacen la prueba a menos que usted diga por otra parte. Esto lleva a algunos esquemas de nombramiento interesantes de archivos de prueba para conseguirlos en la orden deseada. Esto los nombres interesantes se osifican cuando ellos entran en el control de la fuente, y se hacen aún más interesantes cuando más pruebas se revelan.

Pruebe las comisiones de ventas Manifiestas de:: el comportamiento por defecto reemplazando el objetivo de test_via_harness en el Makefile. En vez de ejecutarse en los archivos t/*.t en la orden de ascii-betical, mira en el archivo t/test_manifest para averiguar qué pruebas usted quiere ejecutar y la orden en la cual usted quiere ejecutarlos. Esto construye el valor correcto para MakeMaker para hacer la cosa correcta.

En t/test_manifest, simplemente ponga en una lista las pruebas que usted quiere ejecutar. Su orden en el archivo es la orden en la cual ellos se ejecutan. Usted puede comentar líneas con un #, justo como en Perl, y la Prueba:: Manifestación quitará la conducción y el rastreo whitespace de cada línea. Esto también comprueba que el archivo especificado está realmente en el directorio t/. Si el archivo no existe, no pone su nombre en la lista de archivos de prueba para ejecutarse.

Opcionalmente, usted puede añadir un número después del nombre de prueba en test_manifest para definir juegos de pruebas. Ver get_t_files () para más información.

Funciones

run_t_manifest (TEST_VERBOSE, INST_LIB, INST_ARCHLIB, TEST_LEVEL)

Ejecute todos los archivos en t/test_manifest por la Prueba:: Harness:runtests en la orden ellos aparecen en el archivo.

los eval "usan la Prueba:: Manifestación";
get_t_files ([NIVEL])

En el contexto escalar esto devuelve una cuerda sola que usted puede usar directamente en WriteMakefile (). En el contexto de lista esto devuelve una lista de los archivos que esto encontró en t/test_manifest.

Si un archivo t/test_manifest no existe, get_t_files () no devuelve nada.
el get_t_files () le advierte si se inclina encuentran t/test_manifest, o si las entradas comienzan "con t /". Esto salta líneas en blanco, y quita comentarios de estilo de Perl del archivo.

Cada línea en t/test_manifest puede tener tres partes: el nombre de prueba, el nivel de prueba (un número de punto de flotación), y un comentario. En ausencia, el nivel de prueba es 1.

test_name.t 2 #Run esto sólo para pruebas del nivel 2

Sin un argumento, get_t_files () devuelve todos los archivos de prueba que esto encuentra. Con un argumento que es verdad (entonces usted inclina el uso 0 como un nivel) y es un número, salta pruebas con un nivel mayor que aquel argumento. Usted puede definir entonces juegos de pruebas y elegir un juego para ejecutarse. Por ejemplo, usted podría crear un juego para usuarios finales, sino también añadir un juego para pruebas más profundas para reveladores.

Experimentalmente, usted puede incluir un orden de hacer con nombres de prueba de otro archivo. El orden comienza con a; distinguirlo de un nombre del archivo verdadero. El nombre del archivo (actualmente) es con relación al directorio de trabajo corriente, a diferencia de los nombres del archivo, que son con relación a t/. Los nombres del archivo en el incluido todavía son con relación a t/.

; incluya t/file_with_other_test_names.txt

Para seleccionar juegos de pruebas, especifique que el nivel en TEST_LEVEL variable durante `hace la prueba`.

haga la prueba # ejecutar todas las pruebas no importa el nivel
haga la prueba TEST_LEVEL=2 # ejecutan todo el nivel 2 de prueba y abajo

make_test_manifest ()

Crea el archivo test_manifest en el directorio t leyendo los contenido del directorio t.

HACER: especifique pruebas en listas de argumento.

HACER: especifique archivos para saltarse.

manifest_name ()

Devuelve el nombre del archivo manifiesto de prueba, con relación a t/

Las Dependencias:: de la prueba son un módulo Perl para asegurar que su Makefile. Los GRÁFICOS especifican todas las dependencias de módulo.

SINOPSIS

En su t/00-dependencies.t:
use la Prueba:: las Dependencias excluyen =>
[qw/Su:: Namespace Algún:: Otro:: Namespace/];

ok_dependencies ();

Se asegura que todos los módulos que están usados son puestos en una lista en el Makefile. GRÁFICOS como dependencias.

FUNCIONES EXPORTADAS

ok_dependencies

Esto debería ser la única prueba llamada en el archivo de prueba. Esto escanea el recipiente / y lib/para el uso de módulo y t/para construyen el uso. Esto probará entonces esto todos los módulos usados son puestos en una lista como requerido en Makefile. Los GRÁFICOS, todos los módulos usados en t/son puestos en una lista como construyen requerido, que todos los módulos puestos en una lista realmente están usados, y esto los módulos que son puestos en una lista no están en la lista principal.

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.

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:: 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.

la Clase:: de la prueba es un módulo Perl que permite que usted cree fácilmente clases de prueba en un estilo de xUnit/JUnit.

SINOPSIS

Ejemplo de paquete:: Prueba;
use la base qw (Prueba:: Clase);
use la Prueba:: Más;

# los métodos de instalador son ejecutados antes de cada método de prueba.
suscripción make_fixture: prueba (instalador) {
mi $array = [1, 2];
cambio-> {test_array} = $array;
};

# un método de prueba que ejecuta 1 prueba
suscripción test_push: prueba {
mi $array = cambio-> {test_array};
empuje $array, 3;
is_deeply ($array, [1, 2, 3], el empuje trabajó);
};

# un método de prueba que ejecuta 4 pruebas
suscripción test_pop: prueba (4) {
mi $array = cambio-> {test_array};
es (música pop $array, 2, música pop = 2);
es (música pop $array, 1, música pop = 1);
is_deeply ($array, [], matriz vacía);
es (música pop $array, undef, música pop = undef);
};

# los métodos de desmontaje son ejecutados después de cada método de prueba.
desmontaje de suscripción: prueba (desmontaje) {
mi $array = cambio-> {test_array};
el diag ("ponen en orden = ($array) después de la prueba (s)");
};
más tarde en un archivo.t cercano
¡#!/usr/bin/perl
use el Ejemplo:: Prueba;

# ejecute todos los métodos de prueba en el Ejemplo:: prueba
Pruebe la Clase::-> runtests;

Producciones:

1.. 5
okey 1 - revientan = 2
okey 2 - revientan = 1
okey 3 - ponen en orden vacío
okey 4 - revientan = undef
# ponga en orden = () después de la prueba (s)

okey 5 - el empuje trabajó
# ponga en orden = (1 2 3) después de la prueba (s)

la Firma:: de la prueba es un módulo Perl para automatizar pruebas de FIRMA.

SINOPSIS

# Esto es realmente el t/00signature.t
# archivo de esta distribución.
use la Prueba:: Más pruebas => 1;
use la Prueba:: Firma;

signature_ok ();

EXTRACTO

la Firma:: de la prueba verifica que el Módulo:: la firma generada de la Firma de un módulo es correcto.

El módulo:: Firma permite que usted verifique que una distribución no ha sido manipulada. la Firma:: de la prueba deja a esto ser probado cuando la parte de las distribuciones prueba la suite.
En ausencia, si el Módulo:: Firma no es instalado entonces esto dirá sólo tan y no fallará la prueba. Esto puede ser anulado aunque.

IMPORTANTE: Esto no es un sustituto de los usuarios que verifican la distribución ellos mismos. Cuando este módulo es ejecutado, los usuarios habrán ejecutado ya su Makefile. Los GRÁFICOS o Construyen. Los guiones de GRÁFICOS que podrían haber estado puestos en peligro.
Este módulo es más para asegurar que youve actualizó su firma apropiadamente antes de la distribución, y para prevenir errores casuales durante transmisión o embalaje.

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:: LectroTest:: el Seminario es un módulo Perl que contiene la documentación de como usar LectroTest para probar su software.

SINOPSIS

LectroTest es un sistema de pruebas automatizado, basado en la especificación. Para usarlo, declare propiedades que especifican el comportamiento esperado de su software. Entonces invoque LectroTest para probar si aquellas propiedades sostienen.

LectroTest hace esto ejecutándose repitió evaluaciones arbitrarias contra su software. Si LectroTest encuentra que una propiedad doesnt sostiene, esto emite el contraejemplo que "rompió" su software. Usted puede tapar entonces el contraejemplo en su software para depurar del problema. (Su también una idea buena de añadir el contraejemplo a su lista de pruebas de regresión.)

Piense en su comportamiento de software como un almiar que youre buscando agujas. Cada error es una aguja. Usted quiere encontrar las agujas y borrar de ellos. LectroTest le buscará el almiar - su agradable que camino - pero primero usted debe decirlo sobre la forma del almiar y como reconocer una aguja cuando esto ve el que.

El Almiar

la forma del almiar es definida por un juego "del generador bindings," en que las variables son atadas a la producción generadores de valor:

x <-Int, c <-Trabajo por horas (charset => "A-Z")

El susodicho puede ser leído, "Para todos los números enteros x y todos los carácteres c en la variedad un por Z." la idea consiste en que cada caso único del par (x, c) especifica un punto en el almiar que podemos buscar agujas.

El Reconocedor de Aguja

"El reconocedor de aguja" es definido por un trocito de código que usa las variables atadas para inspeccionar un punto dado en el almiar. Esto devuelve "unos pulgares" (serás verdad) si el punto está sin agujas "o unos pulgares abajo" (falsos) si esto encuentra una aguja:

the_thing_we_are_testing ($x, $c)> = 0;

El susodicho afirma para cada punto en el almiar que la producción de la función the_thing_we_are_testing debe ser no negativa.

Reúnalos para hacer una Propiedad

El generador bindings y el reconocedor de aguja son combinados para hacer una propiedad:

Propiedad {
## [x <-Int, c <-Trabajo por horas (charset => "A-Z")] ##
the_thing_we_are_testing ($x, $c)> = 0;
}, llame => "the_thing_we_are_testing (...) es no negativo";

Youll notan que también añadimos un nombre significativo. Aunque no estrictamente requerido, su una práctica excelente que hace la vida más fácil. (Youll también notan que colocamos el generador bindings dentro de la magia delimiters ## [] ##. Esto dice a Perl que nuestros bindings son bindings y no código de Perl regular.)

Podemos leer la susodicha propiedad como tan: "Para todos los números enteros x y todos los carácteres c en la variedad un por Z, afirmamos que the_thing_we_are_testing es no negativo."

Las pruebas si sus Propiedades sostienen

Después de que usted define propiedades para su software, sólo añádalos a un pequeño programa de Perl que usa la Prueba:: LectroTest módulo:

# MyProperties.l.t

use MyModule; # proporciona the_thing_we_are_testing
use la Prueba:: LectroTest;

Propiedad {
## [x <-Int, c <-Trabajo por horas (charset => "A-Z")] ##
the_thing_we_are_testing ($x, $c)> = 0;
}, llame => "the_thing_we_are_testing (...) es no negativo";

Entonces usted puede probar sus propiedades simplemente ejecutando el programa:

$ perl MyProperties.l.t

Si sus propiedades comprueban, los youll ven algo como esto:

1.. 1
okey 1 - el the_thing_we_are_testing (...) es no negativo (1000 tentativas)

Si algo se equivoca, sin embargo, LectroTest le dirá donde pasó:

1.. 1
no okey 1 - el the_thing_we_are_testing (...) es no negativo
falsificado en 23 tentativas
# Contraejemplo:
# $x = 4
# $c = "R"

Lo que esto dice es que en el punto (x=4, c = "R") en el almiar, hay una aguja (es decir, su propiedad doesnt sostiene). Con esta información, usted puede examinar su código para determinar la causa del error.

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.

el pyGAIM-t es una refundición de GAIM popular IM cliente para estar basado en el transporte de Farfulla, que puede conectar a cualquier sistema IM que GAIM puede.

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.