associação pythonbrasil[11] django zope/plone planet Início Logado como (Entrar)

Diferenças para "DocTest"

Diferenças entre as versões de 8 e 19 (11 versões de distância)
Revisão 8e 2004-07-19 19:24:40
Tamanho: 2589
Editor: RudaMoura
Comentário:
Revisão 19e 2004-08-16 02:27:04
Tamanho: 2667
Comentário:
Deleções são marcadas assim. Adições são marcadas assim.
Linha 1: Linha 1:
= doctest: teste automatizado utilizando DocStrings = = doctest: Assegurando que documentação e implementação estejam sempre corretos =
Linha 3: Linha 3:
Um bom programador procura documentar direito o código que escreve.
A linguagem Python é bem amiga nesse aspecto, com utilização de DocStrings.
Um bom programador procura documentar o código que escreve.
A linguagem Python é amiga do programador nesse aspecto
com utilização de !DocStrings.
Linha 8: Linha 9:
# minhasfuncoes.py
Linha 11: Linha 14:
  Exemplo de uso:
Linha 22: Linha 26:
é uma implementação documentada da função fatorial, dentro de um
possível módulo {{{minhasfuncoes.py}}}.
é uma implementação bem documentada da função fatorial dentro de um
possível módulo chamado {{{minhasfuncoes}}}.
Linha 25: Linha 29:
Uma preocupação maior seria sempre assegurar que o que escrevemos
está correto, mesmo quando procuramos melhorar ou até mesmo reescrever
Uma preocupação maior seria sempre assegurar que o que escrevemos,
código e documentação, estejam sempre em sincronia e corretos,
mesmo quando procuramos melhorar ou até mesmo reescrever
Linha 29: Linha 34:
A resposta está nos testes automatizados que vão garantir (se bem escolhidos)
que a nossa nova implemenmtação funciona como a anterior.
Repare nos exemplos apresentados para descrever a função fatorial,
que tal usá-los como garantia de que não fizemos bobagem?
Isto tudo é possível através do
módulo {{{doctest}}} do Python. vejamos como
{{{#!python
# minhasfuncoes.py
Linha 32: Linha 41:
Repare nos exemplos apresentados para
descrever a função fatorial, que tal usar esses exemplos
como teste?

Isto é possível através do módulo {{{doctest}}} do Python. vejamos
como utilizar
{{{#!python
Linha 42: Linha 44:
  Exemplo de uso:
Linha 60: Linha 63:
O que eu quero executar e testar eu formato igualzinho
como eu usaria no modo interativo do Python (repare nos >>> antes).
a saída esperada eu acrescento na linha logo a baixo,
O que se quer executar e testar formata-se igual
ao que se usaria no modo interativo do Python (repare nos {{{>>>}}} antes).
a saída esperada é indicada na linha logo a baixo,
Linha 65: Linha 68:
Para rodar o teste é simples, {{{$ python minhasfuncoes.py}}}. Se nenhum
erro acontecer a saída é muda, nada aparece na tela. Digamos
que eu mude o {{{if x == 0: return 1}}} para {{{if x == 0: return 0}}},
A execu
ção do teste me dirá que
Para rodar o teste é simples, {{{python minhasfuncoes.py}}}.
Se nenhum erro acontecer a saída é muda, nada aparece na tela.

Digamos que eu mude {{{if x == 0: return 1}}} para
{{{if x == 0: return 0}}} na implementação,
a execução
do teste me dirá que
Linha 87: Linha 92:
Para {{{fat(0)}}} era esperado o valor 1, veio 0. Para {{{fat(5)}}}
era esperado 120, veio 0 também.
para {{{fat(0)}}} era esperado o valor 1, veio 0.
Para {{{fat(5)}}} era esperado 120, veio 0 também.
Linha 94: Linha 99:

----

RudaMoura

doctest: Assegurando que documentação e implementação estejam sempre corretos

Um bom programador procura documentar o código que escreve. A linguagem Python é amiga do programador nesse aspecto com utilização de DocStrings.

Por exemplo:

   1 # minhasfuncoes.py
   2 
   3 def fat(n):
   4   """Calcula o fatorial de n.
   5 
   6   Exemplo de uso:
   7   >>> fat(0)
   8   1
   9   >>> fat(5)
  10   120
  11   """
  12   if x == 0:
  13     return 1
  14   else:
  15     return x * fat(x-1)

é uma implementação bem documentada da função fatorial dentro de um possível módulo chamado minhasfuncoes.

Uma preocupação maior seria sempre assegurar que o que escrevemos, código e documentação, estejam sempre em sincronia e corretos, mesmo quando procuramos melhorar ou até mesmo reescrever o que fizemos. Mas como certificar que não quebramos nada enquanto mudamos?

Repare nos exemplos apresentados para descrever a função fatorial, que tal usá-los como garantia de que não fizemos bobagem? Isto tudo é possível através do módulo doctest do Python. vejamos como

   1 # minhasfuncoes.py
   2 
   3 def fat(n):
   4   """Calcula o fatorial de n.
   5 
   6   Exemplo de uso:
   7   >>> fat(0)
   8   1
   9   >>> fat(5)
  10   120
  11   """
  12   if n == 0:
  13     return 1
  14   else:
  15     return n * fat(n-1)
  16 
  17 def _test():
  18   import doctest, minhasfuncoes
  19   return doctest.testmod(minhasfuncoes)
  20 
  21 if __name__ == '__main__':
  22   _test()

O que se quer executar e testar formata-se igual ao que se usaria no modo interativo do Python (repare nos >>> antes). a saída esperada é indicada na linha logo a baixo, conforme deveria ser numa seção interativa.

Para rodar o teste é simples, python minhasfuncoes.py. Se nenhum erro acontecer a saída é muda, nada aparece na tela.

Digamos que eu mude if x == 0: return 1 para if x == 0: return 0 na implementação, a execução do teste me dirá que

$ python minhasfuncoes.py
*****************************************************************
Failure in example: fat(0)
from line #1 of minhasfuncoes.fat
Expected: 1
Got: 0
*****************************************************************
Failure in example: fat(5)
from line #3 of minhasfuncoes.fat
Expected: 120
Got: 0
*****************************************************************
1 items had failures:
   2 of   2 in minhasfuncoes.fat
***Test Failed*** 2 failures.

para fat(0) era esperado o valor 1, veio 0. Para fat(5) era esperado 120, veio 0 também. Dois erros foram indicados através da própria documentação da função.

Para saber mais

  • Procure a documentação do doctest (>>> help(doctest)).

  • Um exemplo de uso em VerificadorDeCpf.


RudaMoura