provar - Online na nuvem

PROGRAMA:

NOME

provar - Execute testes por meio de um chicote TAP.

USO

provar [opções] [arquivos ou diretórios]

OPÇÕES

Opções booleanas:

-v, --verbose Imprime todas as linhas de teste.
-l, --lib Adiciona 'lib' ao caminho para seus testes (-Ilib).
-b, --blib Adiciona 'blib / lib' e 'blib / arch' ao caminho para
seus testes
-s, --shuffle Executa os testes em ordem aleatória.
-c, --color Saída de teste colorida (padrão).
--nocolor Não colora a saída do teste.
--count Mostra a contagem de teste X / Y quando não detalhado
(Padrão)
--nocount Desativa a contagem de teste X / Y.
-D --seca Execução a seco. Mostre o teste que seria executado.
-f, --failures Mostra os testes que falharam.
-o, --comments Mostra comentários.
--ignore-exit Ignora o status de saída dos scripts de teste.
-m, --merge Mesclar STDERR dos scripts de teste com seu STDOUT.
-r, --recurse Desce recursivamente nos diretórios.
--reverse Executa os testes na ordem inversa.
-q, --quiet Suprime alguma saída de teste durante a execução de testes.
-Q, --QUIET Imprime apenas resultados resumidos.
-p, --parse Mostra a lista completa de erros de análise TAP, se houver.
--directives Mostra apenas os resultados com as diretivas TODO ou SKIP.
--timer Imprime o tempo decorrido após cada teste.
--trap Trap Ctrl-C e imprimir o resumo na interrupção.
--normalize Normaliza a saída TAP na saída detalhada
-T Ativa verificações de contaminação.
-t Ativa avisos de contaminação.
-W Ativa avisos fatais.
-w Ativa avisos.
-h, --help Exibe esta ajuda
- ?, Exibir esta ajuda
-V, --version Exibe a versão
-H, --man Página de manual mais longa para provar
--norc Não processa .proverc padrão

Opções que levam argumentos:

-I Caminhos de biblioteca a serem incluídos.
-P Carregar plugin (pesquisa App :: Prove :: Plugin :: *.)
-M Carrega um módulo.
-e, --exec Interpretador para executar os testes ('' para compilado
testes.)
--ext Define a extensão para testes (padrão '.t')
--harness Define o equipamento de teste a ser usado. Veja TAP :: Arnês.
--formatter Formatador de resultados a ser usado. Veja FORMATTERS.
--source Carregar e / ou configurar um SourceHandler. Ver
MANIPULADORES DE FONTE.
-a, --archive out.tgz Armazena o TAP resultante em um arquivo compactado.
-j, --jobs N Executa N trabalhos de teste em paralelo (tentativa 9.)
--state = opts Controle prova o estado persistente.
--rc = rcfile Opções de processo do rcfile
--rules Regras para processamento paralelo vs sequencial.

NOTAS

.provec
If ~ / .proverc or ./.provec existir, eles serão lidos e quaisquer opções que eles contenham serão processadas
antes das opções da linha de comando. Opções em .provec são especificados da mesma maneira que
opções de linha de comando:

# .provec
--state = quente, rápido, salvar
-j9

Arquivos de opções adicionais podem ser especificados com a opção "--rc". Arquivo de opções padrão
o processamento é desabilitado pela opção "--norc".

No Windows e VMS, o arquivo de opções é denominado _provérbio em vez de .provec e é procurado
apenas no diretório atual.

Leitura da "STDIN"
Se você tiver uma lista de testes (ou URLs, ou qualquer outra coisa que deseja testar) em um arquivo, você
pode adicioná-los aos seus testes usando um '-':

provar - <my_list_of_things_to_test.txt

Veja o "LEIA-ME" no diretório "exemplos" desta distribuição.

Padrão Teste Diretório
Se nenhum arquivo ou diretório for fornecido, "provar" procura todos os arquivos que correspondem ao padrão
"t / *. t".

Colori Teste saída
A saída de teste colorido usando TAP :: Formatter :: Color é o padrão, mas se a saída não for para um
terminal, a cor está desativada. Você pode substituir isso adicionando a opção "--color".

O suporte a cores requer Term :: ANSIColor em plataformas do tipo Unix e Win32 :: Console em
janelas. Se o módulo necessário não estiver instalado, a saída colorida não estará disponível.

saída Code
Se os testes falharem, "provar" sairá com status diferente de zero.

Argumentos para Testes
É possível fornecer argumentos para testes. Para fazer isso, separe-os dos próprios da prova
argumentos com o arisdottle, '::'. Por exemplo

prove -vt / mytest.t :: --url http://example.com

correria t / mytest.t com as opções '--url http://example.com'. Ao executar vários
testes, cada um deles receberá os mesmos argumentos.

"--exec"
Normalmente você pode apenas passar por uma lista de testes Perl e o chicote saberá como executar
eles. No entanto, se seus testes não forem escritos em Perl ou se você quiser que todos os testes sejam invocados
exatamente da mesma maneira, use a opção "-e" ou "--exec":

provar --exec '/ usr / bin / ruby -w 't /
provar --exec '/ usr / bin / perl -Tw -mstrict -Ilib 't /
provar --exec '/ caminho / para / meu / cliente / exec'

"--merge"
Se você precisar ter certeza de que seus diagnósticos são exibidos na ordem correta em relação a
resultados de teste, você pode usar a opção "--merge" para mesclar o STDERR dos scripts de teste em seus
STDOUT.

Isso garante que STDOUT (onde os resultados do teste aparecem) e STDERR (onde o
diagnóstico aparecer) permanecerá em sincronia. O arnês exibirá todos os diagnósticos de seus testes
emitir em STDERR.

Advertência: isso é um pouco confuso. Em particular, observe que se houver algo que apareça
STDERR parece um resultado de teste que o equipamento de teste ficará confuso. Use esta opção apenas
se você entende as consequências e pode viver com o risco.

"--armadilha"
A opção "--trap" tentará interceptar SIGINT (Ctrl-C) durante uma execução de teste e exibir o
resumo do teste, mesmo se a execução for interrompida

"--Estado"
Você pode pedir "provar" para lembrar o estado das execuções de teste anteriores e selecionar e / ou solicitar
os testes a serem executados com base nesse estado salvo.

A opção "--state" requer um argumento que deve ser uma lista separada por vírgulas de um ou
mais das seguintes opções.

"último"
Execute os mesmos testes da última vez que o estado foi salvo. Isso torna possível, para
exemplo, para recriar a ordem de um teste embaralhado.

# Execute todos os testes em ordem aleatória
$ prove -b --state = save --shuffle

# Execute-os novamente na mesma ordem
$ prove -b --state = last

"fracassado"
Execute apenas os testes que falharam na última execução.

# Execute todos os testes
$ prove -b --state = save

# Executar falhas
$ prove -b --state = falhou

Se você também especificar a opção "salvar", os testes recém-aprovados serão excluídos do
corridas subsequentes.

# Repita até que não haja mais falhas
$ prove -b --state = falhou, salve

"passado"
Execute apenas os testes aprovados da última vez. Útil para garantir que nenhum problema novo
foram introduzidos.

"tudo"
Execute todos os testes em ordem normal. Várias opções podem ser especificadas, para executar todos os testes
com as falhas da última vez primeiro:

$ prove -b --state = falhou, tudo, salvar

"quente"
Execute primeiro os testes que falharam mais recentemente. O último tempo de falha de cada teste é
armazenado. A opção "quente" faz com que os testes sejam executados na ordem de falha mais recente.

$ prove -b --state = hot, salve

Os testes que nunca falharam não serão selecionados. Para executar todos os testes com o máximo
falhou recentemente no primeiro uso

$ prove -b --state = hot, all, save

Esta combinação de opções também pode ser especificada assim

$ prove -b --state = adrian

"tudo"
Execute todos os testes com todos.

"lento"
Execute os testes da ordem mais lenta para a mais rápida. Isso é útil em conjunto com o "-j"
alternar teste paralelo para garantir que seus testes mais lentos comecem a ser executados primeiro.

$ prove -b --state = lento -j9

"velozes"
Execute os testes de teste da ordem do mais rápido para o mais lento.

"Novo"
Execute os testes da ordem do mais recente para o mais antigo com base nos tempos de modificação do teste
scripts.

"velho"
Execute os testes da ordem mais antiga para a mais recente.

"fresco"
Execute os scripts de teste que foram modificados desde a última execução de teste.

"Salve "
Salve o estado ao sair. O estado é armazenado em um arquivo chamado .provar (_provar no Windows
e VMS) no diretório atual.

A opção "--state" pode ser usada mais de uma vez.

$ prove -b --state = hot --state = all, salve

--as regras
A opção "--rules" é usada para controlar quais testes são executados sequencialmente e quais são executados
em paralelo, se a opção "--jobs" for especificada. A opção pode ser especificada em vários
horários, e a ordem é importante.

O uso mais prático provavelmente especifica que alguns testes não estão "prontos para uso em paralelo".
Visto que mencionar um arquivo com --rules não faz com que ele seja selecionado para ser executado como um teste, você
pode "definir e esquecer" algumas preferências de regras em seu arquivo .proverc. Então você será capaz de
tirar o máximo proveito dos benefícios de desempenho dos testes paralelos, enquanto alguns
as exceções ainda são executadas em paralelo.

--as regras exemplos

# Todos os testes podem ser executados em paralelo, exceto aqueles começando com "p"
--rules = 'seq = t / p * .t' --rules = 'par = **'

# Todos os testes devem ser executados em sequência, exceto aqueles começando com "p", que devem ser executados em paralelo
--rules = 'par = t / p * .t'

--as regras resolução

· Por padrão, todos os testes podem ser executados em paralelo. Especificando qualquer um dos seus
regras remove este.

· "Vence o primeiro jogo". A primeira regra que corresponder a um teste será aquela que se aplica.

· Qualquer teste que não corresponda a uma regra será executado em sequência no final da execução.

· A existência de uma regra não implica a seleção de um teste. Você ainda deve especificar o
testes para executar.

· Especificar uma regra para permitir que os testes sejam executados em paralelo não os torna executados em
paralelo. Você ainda precisa especificar o número de "trabalhos" paralelos em seu objeto Chicote.

--as regras Estilo Glob de cinto de segurança correspondente

Implementamos nossa própria correspondência de padrões no estilo glob para --rules. Aqui estão os suportados
padrões:

** é qualquer número de caracteres, incluindo /, em um nome de caminho
* é zero ou mais caracteres em um nome de arquivo / diretório
? é exatamente um caractere dentro de um nome de arquivo / diretório
{foo, bar, baz} é qualquer um de foo, bar ou baz.
\ é um caractere de escape

Mais avançado especificações for paralelo vs seqüência corrida regras

Se você precisar de gerenciamento mais avançado do que é executado em paralelo ou em sequência, consulte o
documentação de 'regras' associadas em TAP :: Harness e TAP :: Parser :: Scheduler. Se o que
possível diretamente através de "provar" não é suficiente, você pode escrever seu próprio chicote para
acessar esses recursos diretamente.

@INC
provar introduz uma separação entre "opções passadas para o perl que executa o prove" e
"opções passadas para o perl que executa os testes"; esta distinção é intencional. Assim, o
perl que está executando um teste começa com o padrão @INC. Diretórios de biblioteca adicionais
pode ser adicionado por meio da variável de ambiente "PERL5LIB", via -Ifoo em "PERL5OPT" ou via
Opção "-Ilib" para provar.

Taint Moda
Normalmente, quando um programa Perl é executado em modo contaminado, o conteúdo do "PERL5LIB"
a variável de ambiente não aparece em @INC.

Porque "PERL5LIB" é frequentemente usado durante o teste para adicionar diretórios de construção para @INC provar
passa os nomes de quaisquer diretórios encontrados em "PERL5LIB" como opções -I. O efeito líquido de
é que "PERL5LIB" é honrado mesmo quando o teste é executado no modo contaminado.

FORMATADORES

Você pode carregar um TAP :: Parser :: Formatter personalizado:

provar --formatter MyFormatter

FONTE MANIPULADORES

Você pode carregar TAP :: Parser :: SourceHandlers customizado, para alterar a forma como o analisador interpreta
particular fontes da TAP.

provar --source MyHandler --source YetAnother t

Se você deseja fornecer configuração para a fonte, pode usar:

provar --source MyCustom \
--source Perl --perl-option 'foo = bar baz' --perl-option avg = 0.278 \
--source File --file-option extensions = .txt --file-option extensions = .tmp t
--source pgTAP --pgtap-option pset = format = html --pgtap-option pset = border = 2

Cada opção "- $ source-option" deve especificar um par chave / valor separado por um "=". Se um
opção pode assumir vários valores, basta especificá-lo várias vezes, como com o "extensions ="
exemplos acima. Se a opção deve ser uma referência de hash, especifique o valor como um segundo
par separado por um "=", como nos exemplos "pset =" acima (escape "=" com uma barra invertida).

Todas as "--sources" são combinadas em um hash e passadas para "new" em TAP :: Harness's "sources"
parâmetro.

Veja TAP :: Parser :: IteratorFactory para mais detalhes sobre como a configuração é passada para
Manipuladores de Origem.

PLUGINS

Os plug-ins podem ser carregados usando o "-Pplugar" sintaxe, por exemplo:

provar -PMyPlugin

Isto irá procurar por um módulo denominado "App :: Prove :: Plugin :: MyPlugin" ou, na sua falta,
"MyPlugin". Se o plugin não for encontrado, "provar" irá reclamar e sair.

Você pode passar argumentos para seu plug-in acrescentando "= arg1, arg2, etc" ao nome do plug-in:

prove -PMyPlugin = fou, du, fafa

Por favor, verifique a documentação do plugin individual para mais detalhes.

Disponível Plugins
Para obter uma lista atualizada dos plug-ins disponíveis, verifique o CPAN:

<http://search.cpan.org/search? query = App% 3A% 3AProve + Plugin>

Escrevendo Plugins
Consulte "PLUGINS" em App :: Prove.

Use provar online usando serviços onworks.net