Cgi : : Vérifier est un cadre de test de régression de cgi.

SYNTHÈSE

# dans le test de régression d'un certain t/script.t, par exemple
cgi d'utilisation : : test ; # les exportations approuvent ()

mon $ct = cgi : : Test->new (
- => « http://some.server:1234/cgi-bin » de base_url,
- => « /path/to/cgi-bin » de cgi_dir,
) ;

mon $page = $ct->GET (« http://some.server:1234/cgi-bin/script?arg=1 ") ;
ok 1, =~ m de $page->content_type|texte/htmlb|;

mon $form = $page->forms-> [0] ;
approuver 2, l'eq « /cgi-bin/some_target » de $form->action ;

mon $menu = $form->menu_by_name (« mois ») ;
ok 3, $menu->is_selected (« janvier ») ;
ok 4 ! $menu->is_selected (« mars ») ;
ok 5, $menu->multiple ;

mon $send = $form->submit_by_name (« send_form ») ;
ok 6, $send défini ;

#
# agir l'un sur l'autre maintenant avec le cgi
#

$menu->select (« mars ») ; # « cliquetis » sur l'étiquette de mars
mon $answer = $send->press ; # « cliquetis » sur le bouton d'envoi
ok 7, $answer->is_ok ; # et s'assurer que nous n'obtenons pas une erreur de HTTP

Le cgi : : Le module de test fournit un cadre de test de régression de cgi qui te permet d'exécuter vos procédures CGI en différé, c.-à-d. en dehors d'un web server, et agir l'un sur l'autre avec elles programmatiquement, sans nécessité de taper des caractéristiques et de cliqueter d'un web browser.

Si le youre using le module de cgi, vous peut être au courant de son mode de contrôle hors ligne. Cependant, ce mode est approprié pour des choses simples, et il n'y a aucun soutien de conduire une réunion plénière avec une séquence type de dynamique. Cgi : : Le test comble cette lacune en fournissant l'infrastructure nécessaire pour exécuter des scripts CGI, alors analyse la sortie pour construire les objectifs qui peuvent être questionnés, et sur ce qui vous pouvez agir l'un sur l'autre « pour jouer » avec les gadgets de contrôle de séquences type, finalement soumettant des caractéristiques en arrière. Et ainsi de suite…
Noter que les scripts CGI que vous pouvez vérifier avec le cgi : : Vérifier n'ont pas besoin d'être mis en application dans le Perl du tout. En ce qui concerne ce cadre, les scripts CGI sont des executables qui sont exécutés sur a Cgi-comme l'environnement et quel produit un résultat.

Pour employer le cgi : : Vérifier le cadre, vous doivent configurer un cgi : : Objectif de test à agir comme un web server, en fournissant la base d'URL où les scripts CGI se trouvent sur ce pseudo-serveur, et que le répertoire matériel correspond à cette base d'URL.
Dès lors, vous pouvez établir OBTENEZ et INSCRIVEZ des demandes donnant un URL, et le pseudo-serveur renvoie un cgi : : test : : Paginer l'objectif représentant le résultat de la demande. Cette page peut être une erreur, texte en clair, de la caractéristique binaire, ou un HTML page (voir le cgi : : test : : Page pour des groupes).

Ce dernier (un HTML page) peuvent contenir une ou plusieurs formes de cgi (recensées près étiquettes), qui sont décrites par des cas de cgi : : test : : Former les objectifs (voir le cgi : : test : : Former pour des groupes).

Des formes peuvent être questionnées pour voir si elles contiennent un type particulier de gadget (carte, endroit des textes, bouton, etc…), d'un nom particulier (qu'est à dire le nom de paramètre de cgi). Une fois trouvé, on peut agir l'un sur l'autre avec un gadget pendant que l'usager d'un programme de lecture. Des gadgets sont décrits par les objectifs polymorphes qui sont conformes au cgi : : test : : Forme : : Type de gadget. L'interaction particulière qui est offerte dépend du type dynamique de l'objectif (voir le cgi : : test : : Forme : : Gadget pour des groupes).

Une interaction avec une forme finit par une présentation des caractéristiques de forme au serveur, et à récupérer une réponse. Ceci est fait en appuyant sur un bouton de soumission, et le sous-programme de pression () renvoie une page neuve. Naturellement, aucun serveur n'est entré en contact du tout dans le cgi : : Vérifier le cadre, et le script CGI est a exécuté par un appel approprié à un de la méthode de GET/POST sur le cgi : : Objectif de test.

En conclusion, depuis le cgi : : Le test est censé pour être employé des séquences type de test de régression, il exporte () un sous-programme en bon état unique qui estampe simplement les messages prévus par test : : Harnais. C'est le seul sous-programme fonctionnel dans ce module, tous autres accès étant effectués par un cgi : : Objectif de test.

test : : Fixme est un module de Perl à codes de contrôle pour FIXMEs.

SYNTHÈSE

# dans une séquence type de test aimer t/test-fixme.t
test d'utilisation : : Fixme ;
run_tests () ;

# vous pouvez également régler le comportement.
test d'utilisation : : Fixme ;
run_tests (où bibliothèque de =>, # où trouver des dossiers pour vérifier
=> TODO d'allumette, # le ce qui à vérifier
le => $ENV {SAUT} de skip_all # devrait tout des tests être sauté
) ;

Quand le codage de lui est courant pour se heurter aux problèmes qui doivent être traités mais qui ne sont pas une affaire à l'heure actuelle. Ce qui se produit généralement est que le codeur ajoute des commentaires comme :

# FIXME - que diriez-vous des hublots qui sont plus grands que l'écran ?

# FIXME - ajouter vérifier des privilèges d'usager ici.

test : : Fixme te permet d'ajouter un dossier de test qui s'assure qu'aucun de ces derniers n'obtient oubliée dans le module.

Arguments

Par défaut les run_tests rechercheront FIXME dans tous les dossiers qu'il peut trouver dans le projet. Vous pouvez changer ces défauts en employant où ou apparier comme suit :

run_tests (où bibliothèque de =>, # juste vérification les modules.
le => d'allumette TODO # recherchent les choses qui ne sont pas faites encore.
) ;

test : : Le tournesol est un module de Perl pour soumettre des résultats de test à l'outil de gestion de jeu d'essai de tournesol.

SYNTHÈSE

test d'utilisation : : Tournesol ;

$t = test : : Litmus->new (- mycomputer de => de machinename,
- usager de => d'username,
- authtoken le jeton de =>,
# optionnel # - => http://litmus.mozilla.org/process_test.cgi de serveur,
# optionnel # - le => d'action soumettent) ;

$t->sysconfig (- => Firefox de produit,
- => Windows de plate-forme,
- => Windows Xp d'opsys,
- joncteur réseau de => de succursale,
- => 2006061314 de buildid,
- le => de buildtype mettent au point des cvs,
- => en-USA de lieu) ;

mon $result = test : : Tournesol : : Result->new (
- => 1 d'isAutomatedResult, # optionnel
- => 27 de testid,
- le passage de => de resultstatus, # des résultats admissibles sont passage
# ou défaillir
- => 0 d'exitstatus,
- => 666 de durée,
- => 20051111150944 d'horodateur, # optionnel (défaut : temps actuel)
- commentaire optionnel de => de commentaire ici, # optionnel
- => 300010 de bugnumber, # optionnel
- => de logarithme naturel [test : : Tournesol : : Log->new (# optionnel
- taper le => STDOUT,
- => de caractéristiques foobar),
test : : Tournesol : : Log->new (
- taper les extensions de => montées,
- l'information de logarithme naturel de => de caractéristiques ici)]
) ;
$t->addResult ($result) ;
# $t->addResult ($someOtherResult) ;
# etc….

# ajouter l'information de logarithme naturel avec laquelle devrait être joint
# tous les résultats (c.-à-d. variables d'ENV, information de config)
$t->addLog (test : : Tournesol : : Log->new (
- taper le => STDOUT,
- caractéristiques de logarithme naturel de => de caractéristiques));

mon $res = $t->submit () ;

# $res est 0 pour des erreurs non fatales (quelques résultats ont été soumis), et
# undef pour des erreurs bloquantes (aucun résultat n'a été soumis avec succès)

si ($t->errstr ()) {mourir $t->errstr ()}

test : : Manifeste est un module de Perl produit pour agir l'un sur l'autre avec un dossier de t/test_manifest.

SYNTHÈSE

# dans Makefile.PL
test d'utilisation d'éval « : : Se manifester » ;

# dans le dossier t/test_manifest, indiquer les tests que vous voulez
# pour exécuter

test : : Le harnais suppose que vous voulez exécuter tous les dossiers de .t dans le répertoire de t dans la commande ASCII-betical pendant effectuez le test à moins que vous disiez autrement. Ceci mène à quelques arrangements nommants intéressants pour que les dossiers de test les obtiennent dans la commande désirée. Ce les noms intéressants s'ossifient quand ils entrent dans le contrôle de source, et deviennent bien plus intéressants pendant que plus de tests apparaissent.

test : : Manifeste dépasse le comportement par défaut en changeant l'objectif de test_via_harness dans le fichier makefile. Au lieu de l'exécution aux dossiers de t/*.t dans la commande ASCII-betical, il examine dans le dossier de t/test_manifest pour découvrir que les tests vous veulent exécuter et la commande dans laquelle vous voulez les exécuter. Il construit la bonne valeur pour que MakeMaker fasse la bonne chose.

Dans t/test_manifest, indiquer simplement les tests que vous voulez exécuter. Leur commande dans le dossier est la commande dans laquelle ils fonctionnent. Vous pouvez les lignes de commentaire avec a #, juste comme dans le Perl, et le test : : Manifeste décollera le whitespace aboutissant et de remorquage de chaque ligne. Elle vérifie également que le fichier spécifié est réellement dans le répertoire de t. Si le dossier n'existe pas, il ne met pas son nom dans la liste de dossiers de test au passage.

Éventuellement, vous pouvez ajouter un numéro après que le nom de test dans test_manifest pour définir des ensembles de tests. Voir les get_t_files () pour plus d'information.

Fonctionnements

run_t_manifest (TEST_VERBOSE, INST_LIB, INST_ARCHLIB, TEST_LEVEL)

Exécuter tous les dossiers dans t/test_manifest par le test : : Harnais : des runtests dans la commande ils apparaissent dans le dossier.

test d'utilisation d'éval « : : Se manifester » ;
get_t_files ([DE NIVEAU])

Dans le contexte scalaire il renvoie une chaîne de caractères unique que vous pouvez employer directement dans WriteMakefile (). Dans le contexte de liste il renvoie une liste des dossiers qu'elle a trouvés dans t/test_manifest.

Si un dossier de t/test_manifest n'existe pas, les get_t_files () ne renvoie rien.
les get_t_files () vous avertit s'il la trouvaille biseautée t/test_manifest, ou si les entrées commencent par le « t ». Il saute des lignes vides, et décolle des commentaires de type de Perl à partir du dossier.

Chaque ligne dans t/test_manifest peut avoir trois parts : le nom de test, le niveau de test (un nombre à virgule flottante), et un commentaire. Par défaut, le niveau de test est 1.

#Run test_name.t2 ceci seulement pour le contrôle du niveau 2

Sans argument, les get_t_files () renvoie tous les dossiers de test qu'il trouve. Avec un argument qui est vrai (ainsi vous utilisation biseautée 0 comme niveau) et est un numéro, il saute des tests avec un plus grand de niveau que cet argument. Vous pouvez alors définir des ensembles de tests et choisir un jeu pour exécuter. Par exemple, vous pourriez produire un jeu pour des utilisateurs, mais ajoutez également sur un jeu pour un plus profond contrôle pour des développeurs.

Expérimental, vous pouvez inclure une commande de saisir des noms de test à partir d'un autre dossier. Les débuts de commande avec a ; pour le discerner d'un nom de fichier vrai. Le nom de fichier (actuel) est relativement au répertoire de travail actuel, à la différence des noms de fichier, qui sont à t relatif. Les noms de fichier dans l'inclus sont t encore relatif.

; comprendre t/file_with_other_test_names.txt

Pour sélectionner des ensembles de tests, spécifier le niveau dans le TEST_LEVEL variable pendant le `effectuent le `de test.

effectuer le test # exécuter tous les tests aucune question le niveau
effectuer le test TEST_LEVEL=2 # exécutent tout le niveau 2 de tests et ci-dessous

make_test_manifest ()

Produit le dossier test_manifest dans le répertoire de t en affichant les teneurs du répertoire de t.

POUR FAIRE : spécifier les tests dans les listes d'arguments.

POUR FAIRE : spécifier les dossiers pour sauter.

manifest_name ()

Renvoie le nom du dossier manifeste de test, relativement au t

test : : Les dépendances est un module de Perl pour s'assurer que votre Makefile.PL spécifie toutes les dépendances de module.

SYNTHÈSE

Dans votre t/00-dependencies.t :
test d'utilisation : : Les dépendances excluent le =>
[qw/votre : : Namespace certains : : Autre : : Namespace/] ;

ok_dependencies () ;

Veille que tous les modules qui sont utilisés sont indiqués dans le Makefile.PL comme dépendances.

FONCTIONNEMENTS EXPORTÉS

ok_dependencies

Ceci devrait être le seul test appelé dans le dossier de test. Il balaye le coffre et la bibliothèque pour l'usage de module et le t pour l'usage de construction. Il vérifiera alors que tous les modules utilisés sont indiqués de la manière prescrite dans Makefile.PL, tous les modules utilisés dans le t sont indiqués car construction exigée, que tous les modules indiqués sont utilisés réellement, et que les modules qui sont cotés ne soient pas dans la liste de faisceau.

test : : UseAllModules est un module de Perl qui emploie le fonctionnement d'use_ok () pour tous les modules manifestés.

SYNTHÈSE

# utilisation fondamentale
employer strict ;
test d'utilisation : : UseAllModules ;

COMMENCER {all_uses_ok () ; }

# si vous avez l'use_ok de défaillir de thatll de modules () pour eux-mêmes
employer strict ;
test d'utilisation : : UseAllModules ;

COMMENCER {
l'all_uses_ok exceptent le qw de => (
Certains : : Personne à charge : : Module
Des autres : : Personne à charge : : Module
^Yet : : Des autres : : Personne à charge : :. * # vous pouvez employer l'expression régulière
)
}

Le malade Im du thatll d'écriture 00_load.t (ou n'importe quoi de pareil) font l'use_ok () pour chaque module que je sauve. Im plus malade de mettre à jour 00_load.t quand j'ajoute un autre dossier au distro. Ce module indique MANIFESTE pour trouver des modules à vérifier et fait l'use_ok () pour chacun de eux. Maintenant tout que vous devez faire est mise à jour MANIFESTE. Vous ne devez modifier le test plus (si tout va bien).

test : : Le cours est un module de Perl qui te permet de produire facilement des classes de test dans un type de xUnit/JUnit.

SYNTHÈSE

exemple d'ensemble de mesures : : test ;
employer le qw de base (test : : Cours) ;
test d'utilisation : : Plus ;

# des méthodes installées sont exécutées avant chaque méthode de test.
make_fixture secondaire : Vérifier (installation) {
mon $array = [1, 2] ;
shift-> {test_array} = $array ;
} ;

# une méthode de test qui exécute 1 test
test_push secondaire : Vérifier {
mon $array = shift-> {test_array} ;
pousser @$array, 3 ;
is_deeply ($array, [1, 2, 3], poussée fonctionnée) ;
} ;

# une méthode de test qui exécute 4 tests
test_pop secondaire : Vérifier (4) {
mon $array = shift-> {test_array} ;
est (bruit @$array, 2, bruit = 2) ;
est (bruit @$array, 1, bruit = 1) ;
is_deeply ($array, [], rangent vide) ;
est (bruit @$array, undef, bruit = undef) ;
} ;

# des méthodes de démontage sont exécutées après chaque méthode de test.
démontage secondaire : Vérifier (démontage) {
mon $array = shift-> {test_array} ;
diag (« choix = (@$array) après des tests ") ;
} ;
plus tard dans un dossier avoisinant de .t
# ! /usr/bin/perl
exemple d'utilisation : : test ;

# exécuter toutes les méthodes de test dans l'exemple : : Vérifier
test : : Class->runtests ;

Sorties :

1..5
ok 1 - bruit = 2
ok 2 - bruit = 1
ok 3 - choix vide
ok 4 - bruit = undef
# choix = () après des tests
ok 5 - poussée fonctionnée
# choix = (1 2 3) après des tests

test : : La signature est un module de Perl pour automatiser le contrôle de SIGNATURE.

SYNTHÈSE

# c'est réellement le t/00signature.t
# dossier de cette distribution.
test d'utilisation : : Plus de => 1 de tests ;
test d'utilisation : : Signature ;

signature_ok () ;

ABSTRAIT

test : : La signature vérifie que le module : : La signature produite par signature d'un module est correcte.

Module : : La signature te permet de vérifier qu'une distribution n'a pas été déplacée. test : : La signature laisse qu'être vérifié en tant qu'élément de la suite de test de distributions.
Par défaut, si module : : La signature ne lui est pas montée alors dira juste ainsi et passera le test. Cela peut être dépassé cependant.

IMPORTANT : Ce n'est pas un produit de remplacement pour les usagers vérifiant la distribution eux-mêmes. Avant que ce module soit exécuté, les usagers auront déjà exécuté vos séquences type de Makefile.PL ou de Build.PL qui pourraient avoir été compromises.
Ce module est plus pour vous assurer ont mis à jour votre signature convenablement avant la distribution, et pour prévenir des erreurs accidentelles pendant la boîte de vitesses ou l'empaquetage.

test : : Cmd est un module de Perl pour le contrôle portatif des commandes et des séquences type.

SYNTHÈSE

test d'utilisation : : Cmd ;

$test = test : : Cmd->new (=> de prog program_or_script_to_test,
script_interpreter de => d'interprète,
=> de chaîne de caractères identifier_string,
=> de workdir,
dir de => de subdir,
=> $code_ref de match_sub,
=> bavard 1) ;

$test->verbose (1) ;

$test->prog (program_or_script_to_test) ;

$test->basename (@suffixlist) ;

$test->interpreter (script_interpreter) ;

$test->string (chaîne de caractères d'identificateur) ;

$test->workdir (préfixe) ;

$test->workpath (subdir, dossier) ;

$test->subdir (subdir,…);
$test->subdir ([sous-marin, dir],…);

$test->write (dossier, <<EOF) ;
contenu de dossier
EOF
$test->write ([subdir, dossier], <<EOF) ;
contenu de dossier
EOF

$test->read ($contents, dossier) ;
$test->read (@lines, dossier) ;
$test->read ($contents, [subdir, dossier]) ;
$test->read (@lines, [subdir, dossier]) ;

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

$test->preserve (condition,…);

$test->cleanup (condition) ;

$test->run (=> de prog program_or_script_to_test,
script_interpreter de => d'interprète,
dir de => de chdir, arguments de => d'args, <<EOF de => de stdin) ;
entrée au régime
EOF

$test->pass (condition) ;
$test->pass (condition, &func) ;

$test->fail (condition) ;
$test->fail (condition, &func) ;
$test->fail (état, &func, $caller) ;

$test->no_result (condition) ;
$test->no_result (condition, &func) ;
$test->no_result (état, &func, $caller) ;

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

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

$test->match (@lines, @matches) ;
$test->match ($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) ;

fonctionnel secondaire {
mon ($self, $lines, $matches) = @_ ;
# code pour apparier $lines et $matches
}
$test->match_sub (&func) ;
$test->match_sub (sous-marin {code pour apparier $_ [1] et $_ [2]}) ;

$test->here ;

Le test : : Le module de Cmd fournit un cadre à basse altitude pour le contrôle automatisé portatif des commandes et des séquences type exécutables (en tout langage, pas simplement Perl), particulièrement les commandes et les séquences type qui agissent l'un sur l'autre avec le système de fichiers.

Le test : : Le module de Cmd n'effectue aucune supposition au sujet de ce qui constitue un test couronné de succès ou failed. Essayant d'afficher un dossier qui n'existe pas, par exemple, des mai ou mai ne pas être une erreur, selon le logiciel étant vérifié.

En conséquence, aucun test : : La sortie de méthodes de Cmd (() méthode neuve y compris), meurent ou projettent tous les autres tris des exceptions (mais de elles toute renvoie des signes utiles des erreurs). Des exceptions ou tout autre mode d'erreur devraient être traités par une couche plus élevée : une sous-classe de test : : Un Cmd, ou un cadre différent de contrôle tel que le test ou le test : : Modules simples de Perl, ou par le test lui-même.
(Qui a indiqué, voir le test : : Cmd : : Module courant si vous voulez un module assimilé qui fournit le traitement des exceptions, ou pour employer directement dans vos propres tests, ou comme exemple de la façon employer le test : : Cmd.)

En plus des tests en marche et des conditions de évaluation, le test : : Le module de Cmd manage et nettoie un ou plusieurs répertoires temporaires de zone de travail, et fournit des méthodes pour produire des dossiers et des répertoires dans ces répertoires de zone de travail des caractéristiques intégrées (c'est-à-dire, ici-documents), permettant à des tests d'être complet indépendants. Une fois utilisé conjointement avec un autre cadre de contrôle, le test : : Le module de Cmd peut fonctionner comme dispositif (code de démarrage courant pour les tests multiples) pour le management simple de l'exécution de la commande et des zones de travail temporaires.

Le test : : Le module de Cmd hérite du dossier : : Méthodes de Spéc. (file_name_is_absolute (), catfile (), etc.) pour supporter des tests d'écriture portably en travers d'une série d'opération et systèmes de fichiers.

Un test : : L'objectif d'environnement de Cmd est produit par l'intermédiaire de l'invocation habituelle :

$test = test : : Cmd->new () ;

Arguments au test : : Cmd : : la méthode neuve sont des paires de mot-valeur qui peuvent être employées pour initialiser l'objectif, type en invoquant la méthode même-nommée comme mot clé.

OpenGuides : : Le test sont des méthodes pour aider des applications d'OpenGuides de test.

Fournit des méthodes pour aider en sauvant des tests pour OpenGuides. Distribué et monté en tant qu'élément du projet d'OpenGuides, non destiné à l'installation indépendante. Cette documentation est probablement seulement utile aux développeurs d'OpenGuides.

SYNTHÈSE

employer OpenGuides ;
utilisation OpenGuides : : test ;

mon $config = OpenGuides : : Test->make_basic_config ;
$config->default_language (« Pays-Bas ») ;

mon $guide = OpenGuides->new (=> $config de config) ;

OpenGuides : : Test->write_data (
=> $guide de guide,
=> « taverne de noeud de Crabtree »,
=> 523465 d'os_x,
=> os_y 177490,
=> « Pubs » de catégories,
) ;

test : : MultiFork est une suite de test qui a le soutien des régimes de multi-procédé.

SYNTHÈSE

test d'utilisation : : MultiFork ;

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

test d'utilisation : : Qw de MultiFork (stderr de dofork de setgroup de groupwait bail_on_bad_plan)

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

Ce module de test est de supporter produire des suites de test pour des régimes et des modules qui fonctionnent en tant que procédés multiples et font bloquer la plupart du temps l'E/S.

test : : MultiFork traite bifurquer de sorte qu'il puisse installer chaque enfant pour combiner la sortie. La sortie de chaque fourche d'enfant est dirigée à nouveau au parent. Chaque fourche produit la sortie normale de test -- probablement using le test normal les modules aiment le test : : Simple. La sortie est rassemblée et récrite par le processus père.

Chaque fourche d'enfant a une nomination de lettre et de numéro. Les fourches sont produites par le dofork (). Dofork prend un specifiction sur la forme : ([a-z] (d*))+. C'est-à-dire, une ou plusieurs lettres minuscules, chacune éventuellement followd par un numéro. Le numéro indique combien d'enfants à bifurquer pour cette lettre (défaut un). Les moyens du spécificateur ab2c3 ont un un enfant (numéro 1) ; deux enfants de b (numéro 1, 2) ; et trois enfants de C (numéro 1, 2, 3).

Pour faciliter des tests d'écriture, vérifier : : MultiFork passera des caractéristiques entre les processus fils. La caractéristique est test-auteur défini.

test : : TestCoverage est module de Perl à vérifier si vos caches de test tous des sous-routines publiques de l'ensemble de mesures.

SYNTHÈSE

test d'utilisation : : TestCoverage ;

test_coverage (mon : : Module) ;

mon $obj = mon : : Module->new () ;
$obj->foo () ;
$obj->bar () ;

# le test sera ok, supposé que mon : : Le module a les sous-routines neuves, le foo et la barre
ok_test_coverage (mon : : Module) ;

reset_test_coverage (mon : : Module) ;
reset_all_test_coverage () ;

test_coverage (mon : : Module) ;

mon $obj = mon : : Method->new () ;
$obj->foo () ;

# le test sera non en bon état, parce que la barre n'est pas invoquée
ok_test_coverage (mon : : Module) ;

reset_test_coverage (mon : : Module) ;
reset_all_test_coverage () ;

test_coverage (mon : : Module) ;
test_coverage_except (mon : : Module, barre) ;

mon $obj = mon : : Method->new () ;
$obj->foo () ;

# le test sera en bon état, parce que la barre est exceptée du test
ok_test_coverage (mon : : Module) ;

Si un module est sauvé, le cache de tests juste quelques sous-routines du module. Ce module vise à supporter l'auteur dans l'écriture « complètent » des tests. Si une des sous-routines « publiques » sont manquées dans le testscript, l'ok_test_coverage de test défaillira.

des sous-routines « privées » sont définies comme sous-routines que les noms commencent par le _ comme le _private_sub {…} et le « public » est l'opposé.

test : : CPANpm est un module de Perl pour vérifier une interaction de distributions avec CPAN avant le chargement.

SYNTHÈSE

test d'utilisation : : CPANpm ;
test d'utilisation : : Plus de qw (no_plan) ;

cpan_depends_ok (
[Cgi, module : : Construction, point culminant : : Wabbit],
a obtenu les bonnes dépendances
) ;

cpan_depends_ok_force_missing (
[Certains : : Module : : Construction : : Sous-classe, cgi, module : : Construction, point culminant : : Wabbit],
[Certains : : Module : : Construction : : Sous-classe],
dépendances obtenues quoique notre module : : La sous-classe de construction est manquante
) ;

test : : Les imbéciles CPAN.pm de CPANpm dans le penser a téléchargé et a éclaté votre ensemble de mesures, alors le fait essayer de produire d'un fichier makefile ou d'établir la séquence type. Après que ce procédé complète, il demande à votre module de CPAN quelles dépendances qu'il pense exister.

Si vous voulez juste s'assurer que votre distribution est empaquetée d'une manière dont est bon pour CPAN, considérer using le test : : Distribution au lieu. Le temps principal ce test : : CPANpm est utile est quand vous dépendez des modules à l'intérieur de votre Makefile.PL ou séquence type et vous de Build.PL veulent s'assurer que vous dégradez avec élégance si ces modules ne sont pas procurables.

test : : MockDBI est surface adjacente de la moquerie DBI de module de Perl pour le contrôle.

SYNTHÈSE

test d'utilisation : : MockDBI ;
OU
test d'utilisation : : Qw de MockDBI (: tous) ;

test : : MockDBI : : set_dbi_test_type (42) ;
si (test : : MockDBI : : == 42 de get_dbi_test_type ()) {
…

test de $mock_dbi = de get_instance : : 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,…

test : : MockDBI fournit une voie de vérifier des surfaces adjacentes de DBI en produisant des règles pour changer le comportement de DBIs, examinant alors la sortie normale pour les configurations assorties.

Contrôle using le test : : MockDBI est permis en réglant le type de contrôle de DBI à une valeur différente de zéro. Ceci peut être fait l'un ou l'autre en employant un premier argument de régime de « --dbitest [=TYPE] », ou en employant le test de méthode de cours : : MockDBI : : set_dbi_test_type (). (Fournissant un premier argument de « --dbitest [=TYPE] » fonctionne bien souvent pendant le TYPE de contrôle.) est un nombre entier simple (/^d+$/). Approvisionnement « --dbitest [=TYPE] » pendant qu'un premier argument fonctionne même si aucune autre ligne de commande traitement n'est faite, comme test : : MockDBI fait sa propre ligne de commande traitant pour vérifier ceci d'abord « --[=TYPE] le » argument dbitest.

Vous voudrez ajouter « --dbitest [=TYPE] » pendant un bloc BEGIN avant « le test d'utilisation : : MockDBI », de sorte que la moquerie DBI soit initialisée le plus tôt possible.

Le TYPE est optionnel, comme premier argument de « --dbitest » réglera le type de contrôle de DBI à 1 (un). Le contrôle de DBI est également invalidé par »--dbitest=0 " (bien que ceci peut ne pas être généralement utile). Le test de méthode de cours : : MockDBI : : le set_dbi_test_type () peut également être employé pour régler ou changer le type de contrôle de DBI.

test : : Le struct est une prolonge de Perl pour déterminer l'equivelence structural.

SYNTHÈSE

test d'utilisation : : Struct ;

deep_eq ($hairy_struct, $expected, test structural velu) ;
est ($x, $y) ; # et tout d'autre test : : Plus doit offrir !

test : : Le struct est employé pour faire de profondes comparaisons structurales de deux objectifs. Le module contient seulement un subrotuine qui se destine pour être employé comme a mélanger-dans avec l'autre test plus générique : : Les modules dérivés par constructeur aiment le test : : Plus ou test : : Simple. Le code emploie normalement la grandeur scalaire : : L'utilisation pour examiner les caractéristiques, mais lui utilisera également les outils ajustés fins supplémentaires de comparaison des caractéristiques : : Vidage mémoire : : Flamme si elle est procurable.
deep_eq ($got, $expected, $name)

Fait une profonde comparaison de niveau de deux objectifs. Elle traverse les deux structures en parallèle vérifiant autant d'attributs comme elle peut pour des différences. Si les objectifs diffèrent elle sortira un message de diagnostic contenant une liste des différences qu'elle a rencontrées avant elle a terminé la comparaison. Quelques types de mésappariement préviennent davantage de comparaison ainsi la liste peut ne pas être approfondie.

L'intention de ce sous-programme est qu'elle réussira le test seulement si $got est fonctionellement identique à $expected. Cependant, au temps actuel il y a des types de quelques caractéristiques qu'il ne traite pas correctement, comme des refs de CODE.

test : : STDmaker est un module de Perl pour produire des séquences type de test, séquences type de démonstration d'une main de circuit de description de test.

SYNTHÈSE

#######
# surface adjacente procédurale (de sous-routine)
#
test d'utilisation : : Qw de STDmake (perl_command de get_data de find_t_roots) ;

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

#####
# surface adjacente de cours
#
test d'utilisation : : STDmaker

$std = test neuf : : STDmaker (@options) ; # à partir du dossier : : Générateur

$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éthodes (privées) internes
#
$success = $std->build ($std_driver_class) ;
$success = $std->generate () ;
$success = $std->print ($file_out) ;

Le test : : Le module de régime de STDmaker fournit les capacités suivantes :
Automatiser la programmation associée par Perl requise pour produire une séquence type de test ayant pour résultat la réduction de temps et coût.

Traduire un dossier court de description de test de logiciel (STD) de main en séquence type de test de Perl qui se sert éventuellement du module de test.

Traduire le fichier de données de la main STD de tri en séquence type de démonstration de Perl qui explique les caractéristiques le du module au test.

Fournir dans la NACELLE d'information de dossier de STD requise par un document de description de test de logiciel gouvernement militaire/ (STD)fédéral qui peut facilement être index et consultée par le logiciel automatisé de test. L'OIN, les militaires britanniques exigent la majeure partie de même information, agences des USA telles que le FAA. La différence est cette OIN, les militaires britanniques ne dictent pas le format de groupe. Les agences des USA telles que FAA régleront généralement en bas des formats exigés par DOD.

Ainsi, il y a une variation extrêmement grande dans le format de même information parmi des activités et des militaires comericial certifiés par OIN autres que les USA. Une fois que l'information est dans une NACELLE, les différents traducteurs peuvent formater presque exact comme dicté par l'utilisateur, si c'est les USA DOD, activité commerciale certifiée par OIN, militaire britannique ou celui qui. En étant en mesure de fournir le plus exigeant, qui est habituellement les USA DOD, les capacités sont là pour tous les autres.

Le test : : L'ensemble de mesures de STDmaker détend le créateur et le développeur du fardeau de compléter des matrices de tôle de chaudière d'équipement de traitement de texte (si liquidation de sinistres, mot, ou vi), comptant des oks, fournissant des exemples de documentation, traçant vérifie pour vérifier des requirments, veillant qu'il est dans le bureau-chef approprié, OIN ou format militaire, et tout autre tel extrêmement long, sondage, tâches de support de développement. Au lieu de cela les créateurs et les développeurs doivent compléter seulement une forme using une main de circuit de description de test. Le test : : STDmaker le prendra produire de là et automatiquement et rapidement des séquences type désirées de test, des séquences type de démonstration, et des documents de description de test.

Regarder les sciences économiques. Elles ne semblent pas économiquement raisonnable d'avoir le talent cher effectuent ce travail. Dans ne semble pas même économiquement raisonnable de prendre des 16 ans lumineux, au salaire de mimimum et de le faire compter manuellement des oks. Le Perl peut compter ces oks beaucoup beaucoup meilleur marché et il est tellement facilement à automatisé avec le Perl. Et n'importe quoi de pareil étaient vous le font année dedans et année à l'extérieur, le sauvetage sont énorme. À un gestionnaire de programme ou à un officier de contrat, c'est sont la programmation et les ordinateurs de ce qui tout environ, argent sauvegardant et productivité croissante, programmation installée non orientée objets, gotos ou d'autres telles choses.

Le test : : L'ensemble de mesures de classe de STDmaker automatise le rétablissement documentation ordinaire de descriptions (STD) de test de logiciel de la vieille (POD), le test scripts, les démonstrations scripts et l'exécution des séquences type produites de test et des séquences type de démonstration. Elle insérera automatiquement la sortie de la séquence type de démonstration dans la NACELLE - chapitre de démonstration de headx du dossier étant vérifié.

test : : TempDatabase est un module de Perl pour la création et la destruction de base de données temporaires.

SYNTHÈSE

test d'utilisation : : TempDatabase ;

mon $td = test : : TempDatabase->create (temp_db de => de dbname) ;
mon $dbh = $td->handle ;

… quelques tests…
# test : : TempDatabase relâche la base de données

Ce module automatise la création et la baisse des bases de données de test.

USAGE

Produire la base de données de test using le test : : TempDatabase->create. Utiliser le traitement pour obtenir un traitement à la base de données. La base de données sera automagically abandonnée quand test : : Le cas de TempDatabase sort de l'étendue.

$class->become_postgres_user

En exécutant comme fond, ce fonctionnement va bien à l'usager différent. Il décide du nom d'utilisateur en sondant TEST_TEMP_DB_USER, variables d'environnement de SUDO_USER. Si ces variables sont vides, l'usager de « postgres » de défaut est employé.
produire

Produit la base de données temporaire. Elle sera relâchée quand le cas donnant droit sortira de l'étendue.

Des arguments sont réussis dedans en tant que paires d'une mot-valeur. Les mots clés procurables sont :
dbname : le nom de la base de données temporaire.

reste : le reste de la chaîne de caractères de connexion de base de données. Elle peut être employée pour brancher à un serveur, etc. différents.

username, mot de passe : explicite.

le pyGAIM-t est une retouche de l'usager populaire de MÉDECINE INTERNE de GAIM à baser sur le transport de Jabber, qui peut brancher à toute MÉDECINE INTERNE le système qui bidon de GAIM.

test : : L'ISBN est un module de Perl pour vérifier des numéros de livre de norme internationale.

SYNTHÈSE

test d'utilisation : : Plus de => 1 de tests ;
test d'utilisation : : ISBN ;

isbn_ok ($isbn) ;

Fonctionnements

isbn_ok (CHAÎNE DE CARACTÈRES)

L'ok est la CHAÎNE DE CARACTÈRES est un ISBN admissible, dans n'importe quel format ces affaires : : L'ISBN reçoit. Ce fonctionnement vérifie seulement le total de contrôle. L'éditeur et les codes du pays pourraient être incorrects quoique le total de contrôle soit admissible.

isbn_country_ok (CHAÎNE DE CARACTÈRES, PAYS)

L'ok est la CHAÎNE DE CARACTÈRES est un ISBN admissible et ses codes du pays sont identique que le PAYS.

isbn_publisher_ok (CHAÎNE DE CARACTÈRES, ÉDITEUR)

L'ok est la CHAÎNE DE CARACTÈRES est un ISBN admissible et son code d'éditeur est identique que l'ÉDITEUR.

test : : Resub est un remontage lexicologique scoped de sous-routine pour le contrôle.

SYNTHÈSE

# ! /usr/bin/perl

test d'utilisation : : Plus de => 4 de tests ;
test d'utilisation : : Qw de Resub (resub) ;

{
ensemble de mesures quelque part ;
exposition secondaire {
mon ($class, $message) = @_ ;
renvoyer « $class, $message » ;
}
}

# validité
est (Somewhere->show (au delà de la mer), quelque part, au delà de la mer) ;

# scoped le remontage de la sous-routine avec la retenue d'argument
{
mon $rs = resub quelque part : : montrer, substrater {salut}, le => 1 de saisie ;
est (Somewhere->show (au-dessus de l'arc-en-ciel), salut) ;
is_deeply ($rs->method_args, [[au-dessus de l'arc-en-ciel]]) ;
}

# l'étendue finit, resub va des renvois à l'opposé et originels de code
est (Somewhere->show (m'attendant), quelque part, m'attendant) ;

Ce module te permet de remplacer temporairement une sous-routine/méthode par le code arbitraire. Plus tard, vous pouvez dire combien temps étaient lui ont appelé et avec quels arguments chaque fois. Vous pouvez également spécifier que la sous-routine/méthode doit obtenir appelées, nécessité ne pas obtenir appelées, ou pouvez éventuellement s'appeler.