"doctest" -- Prueba ejemplos interactivos de Python
***************************************************

**Código fuente:** Lib/doctest.py

======================================================================

El módulo "doctest" busca pedazos de texto que lucen como sesiones
interactivas de Python, y entonces ejecuta esas sesiones para
verificar que funcionen exactamente como son mostradas. Hay varias
maneras de usar doctest:

* Para revisar que los docstrings de un módulo están al día al
  verificar que todos los ejemplos interactivos todavía trabajan como
  está documentado.

* Para realizar pruebas de regresión al verificar que los ejemplos
  interactivos de un archivo de pruebas o un objeto de pruebas trabaje
  como sea esperado.

* Para escribir documentación de tutorial para un paquete,
  generosamente ilustrado con ejemplos de entrada-salida. Dependiendo
  si los ejemplos o el texto expositivo son enfatizados, tiene el
  sabor de "pruebas literarias" o "documentación ejecutable".

Aquí hay un módulo de ejemplo completo pero pequeño:

   """
   This is the "example" module.

   The example module supplies one function, factorial().  For example,

   >>> factorial(5)
   120
   """

   def factorial(n):
       """Return the factorial of n, an exact integer >= 0.

       >>> [factorial(n) for n in range(6)]
       [1, 1, 2, 6, 24, 120]
       >>> factorial(30)
       265252859812191058636308480000000
       >>> factorial(-1)
       Traceback (most recent call last):
           ...
       ValueError: n must be >= 0

       Factorials of floats are OK, but the float must be an exact integer:
       >>> factorial(30.1)
       Traceback (most recent call last):
           ...
       ValueError: n must be exact integer
       >>> factorial(30.0)
       265252859812191058636308480000000

       It must also not be ridiculously large:
       >>> factorial(1e100)
       Traceback (most recent call last):
           ...
       OverflowError: n too large
       """

       import math
       if not n >= 0:
           raise ValueError("n must be >= 0")
       if math.floor(n) != n:
           raise ValueError("n must be exact integer")
       if n+1 == n:  # catch a value like 1e300
           raise OverflowError("n too large")
       result = 1
       factor = 2
       while factor <= n:
           result *= factor
           factor += 1
       return result


   if __name__ == "__main__":
       import doctest
       doctest.testmod()

Si tu ejecutas "example.py" directamente desde la línea de comandos,
"doctest" hará su magia:

   $ python example.py
   $

¡No hay salida! Eso es normal, y significa que todos los ejemplos
funcionaron. Pasa "-v" al script, y "doctest" imprime un registro
detallado de lo que está intentando, e imprime un resumen al final:

   $ python example.py -v
   Trying:
       factorial(5)
   Expecting:
       120
   ok
   Trying:
       [factorial(n) for n in range(6)]
   Expecting:
       [1, 1, 2, 6, 24, 120]
   ok

Y demás, eventualmente terminando con:

   Trying:
       factorial(1e100)
   Expecting:
       Traceback (most recent call last):
           ...
       OverflowError: n too large
   ok
   2 items passed all tests:
      1 tests in __main__
      8 tests in __main__.factorial
   9 tests in 2 items.
   9 passed and 0 failed.
   Test passed.
   $

¡Eso es todo lo que necesitas saber para empezar a hacer uso
productivo de "doctest"! Lánzate. Las siguientes secciones
proporcionan detalles completos. Note que hay muchos ejemplos de
doctests en el conjunto de pruebas estándar de Python y bibliotecas.
Especialmente ejemplos útiles se pueden encontrar en el archivo de
pruebas estándar "Lib/test/test_doctest.py".


Uso simple: verificar ejemplos en docstrings
============================================

La forma más simple para empezar a usar doctest (pero no
necesariamente la forma que continuarás usándolo) es terminar cada
módulo "M" con:

   if __name__ == "__main__":
       import doctest
       doctest.testmod()

"doctest" entonces examina docstrings en el módulo "M".

Ejecutar el módulo como un script causa que los ejemplos en los
docstrings se ejecuten y verifiquen:

   python M.py

No mostrará nada a menos que un ejemplo falle, en cuyo caso el ejemplo
fallido o ejemplos fallidos y sus causas de la falla son imprimidas a
stdout, y la línea final de salida es "***Test Failed*** N failures.",
donde *N* es el número de ejemplos que fallaron.

Ejecútalo con el modificador "-v" en su lugar:

   python M.py -v

y un reporte detallado de todos los ejemplos intentados es impreso a
la salida estándar, junto con resúmenes clasificados  al final.

Puedes forzar el modo verboso al pasar "verbose=True" a "testmod()", o
prohibirlo al pasarlo "verbose=False". En cualquiera de estas casos,
"sys.argv" no es examinado por "testmod()" (por lo que pasar o no
"-v", no tiene efecto).

También hay un atajo de línea de comandos para ejecutar "testmod()".
Puedes instruir al intérprete de Python para ejecutar el módulo
doctest directamente de la biblioteca estándar y pasar los nombres del
módulo en la línea de comandos:

   python -m doctest -v example.py

Esto importará "example.py" como un módulo independiente y ejecutará a
"testmod()". Note que esto puede no funcionar correctamente si el
archivo es parte de un paquete e importa otros submódulos de ese
paquete.

Para más información de "testmod()", véase la sección API básica.


Uso Simple: Verificar ejemplos en un Archivo de Texto
=====================================================

Otra simple aplicación de doctest es probar ejemplos interactivos en
un archivo de texto.  Esto puede ser hecho con la función
"testfile()":

   import doctest
   doctest.testfile("example.txt")

Este script corto ejecuta y verifica cualquier ejemplo interactivo de
Python contenido en el archivo "example.txt". El contenido del archivo
es tratado como si fuese un solo gran docstring; ¡el archivo no
necesita contener un programa de Python! Por ejemplo, tal vez
"example.txt" contenga esto:

   The ``example`` module
   ======================

   Using ``factorial``
   -------------------

   This is an example text file in reStructuredText format.  First import
   ``factorial`` from the ``example`` module:

       >>> from example import factorial

   Now use it:

       >>> factorial(6)
       120

Ejecutar "doctest.testfile("example.txt")" entonces encuentra el error
en esta documentación:

   File "./example.txt", line 14, in example.txt
   Failed example:
       factorial(6)
   Expected:
       120
   Got:
       720

Como con "testmod()", "testfile()" no mostrará nada a menos que un
ejemplo falle. Si un ejemplo no falla, entonces los ejemplos fallidos
y sus causas son impresas a stdout, usando el mismo formato como
"testmod()".

Por defecto, "testfile()" busca archivos en el directorio del módulo
al que se llama. Véase la sección API básica para una descripción de
los argumentos opcionales que pueden ser usados para decirle que
busque archivos en otros lugares.

Como "testmod()", la verbosidad de "testfile()" puede ser establecida
con el modificador de la línea de comandos "-v" o con el argumento por
palabra clave opcional *verbose*.

También hay un atajo de línea de comandos para ejecutar "testfile()".
Puedes indicar al intérprete de Python para correr el módulo doctest
directamente desde la biblioteca estándar y pasar el nombre de los
archivos en la línea de comandos:

   python -m doctest -v example.txt

Porque el nombre del archivo no termina con ".py", "doctest" infiere
que se debe ejecutar con "testfile()", no "testmod()".

Para más información en "testfile()", véase la sección API básica.


Cómo funciona
=============

Esta sección examina en detalle cómo funciona doctest: qué docstrings
revisa, cómo encuentra ejemplos interactivos, qué contexto de
ejecución usa, cómo maneja las excepciones, y cómo las banderas pueden
ser usadas para controlar su comportamiento. Esta es la información
que necesitas saber para escribir ejemplos de doctest; para
información sobre ejecutar doctest en estos ejemplos, véase las
siguientes secciones.


¿Qué docstrings son examinados?
-------------------------------

Se busca en el docstring del módulo, y todos los docstrings de las
funciones, clases, y métodos.  Los objetos importados en el módulo no
se buscan.

Además, si "M.__test__" existe y "es verdaderos", debe ser un
diccionario, y cada entrada mapea un nombre (cadena de caracteres) a
un objeto de función, objeto de clase, o cadena de caracteres. Se
buscan los docstrings de los objetos de función o de clase encontrados
de "M.__test__", y las cadenas de caracteres son tratadas como si
fueran docstrings. En la salida, una clave "K" en "M.__test__" aparece
con el nombre:

   <name of M>.__test__.K

Todas las clases encontradas se buscan recursivamente de manera
similar, para probar docstrings en sus métodos contenidos y clases
anidadas.


¿Cómo se reconocen los ejemplos de docstring?
---------------------------------------------

En la mayoría de los casos un copiar y pegar de una sesión de consola
interactiva funciona bien, pero doctest no está intentando hacer una
emulación exacta de ningún shell específico de Python.

   >>> # comments are ignored
   >>> x = 12
   >>> x
   12
   >>> if x == 13:
   ...     print("yes")
   ... else:
   ...     print("no")
   ...     print("NO")
   ...     print("NO!!!")
   ...
   no
   NO
   NO!!!
   >>>

Cualquier salida esperada debe seguir inmediatamente el final de la
línea "'>>>'" o "'...'" conteniendo el código, y la salida esperada
(si la hubiera) se extiende hasta el siguiente "'>>>'" o la línea en
blanco.

La letra pequeña:

* La salida esperada no puede contener una línea de espacios en
  blanco, ya que ese tipo de línea se toma para indicar el fin de la
  salida esperada. Si la salida esperada de verdad contiene una línea
  en blanco, pon "<BLANKLINE>" en tu ejemplo de doctest en cada lugar
  donde una línea en blanco sea esperada.

* Todos los caracteres de tabulación se expanden a espacios, usando
  paradas de tabulación de 8 -columnas. Las tabulaciones generadas por
  el código en pruebas no son modificadas. Ya que todas las
  tabulaciones en la salida de prueba *son* expandidas, significa que
  si el código de salida incluye tabulaciones, la única manera de que
  el doctest pueda pasar es si la opción "NORMALIZE_WHITESPACE" o
  directive está en efecto. Alternativamente, la prueba puede ser
  reescrita para capturar la salida y compararla a un valor esperado
  como parte de la prueba. Se llegó a este tratamiento de tabulaciones
  en la fuente a través de prueba y error, y ha demostrado ser la
  manera menos propensa a errores de manejarlos. Es posible usar un
  algoritmo diferente para manejar tabulaciones al escribir una clase
  "DocTestParser" personalizada.

* La salida a stdout es capturada, pero no la salida a stderr (los
  rastreos de la excepción son capturados a través de maneras
  diferentes).

* Si continuas una línea poniendo una barra invertida en una sesión
  interactiva, o por cualquier otra razón usas una barra invertida,
  debes usar un docstring crudo, que preservará tus barras invertidas
  exactamente como las escribes:

     >>> def f(x):
     ...     r'''Backslashes in a raw docstring: m\n'''
     >>> print(f.__doc__)
     Backslashes in a raw docstring: m\n

  De otra manera, la barra invertida será interpretada como parte de
  una cadena. Por ejemplo, el "\n" arriba sería interpretado como un
  carácter de nueva línea. Alternativamente, puedes duplicar cada
  barra invertida en  la versión de doctest (y no usar una cadena de
  caracteres cruda):

     >>> def f(x):
     ...     '''Backslashes in a raw docstring: m\\n'''
     >>> print(f.__doc__)
     Backslashes in a raw docstring: m\n

* La columna inicial no importa:

     >>> assert "Easy!"
           >>> import math
               >>> math.floor(1.9)
               1

  y tantos espacios en blanco al principio se eliminan de la salida
  esperada como aparece en la línea "'>>>'" inicial que empezó el
  ejemplo.


¿Cuál es el contexto de ejecución?
----------------------------------

Por defecto, cada vez que un "doctest" encuentre un docstring para
probar, usa una *copia superficial*  de los globales de "M", por lo
que ejecutar pruebas no cambia los globales reales del módulo, y por
lo que una prueba en "M" no puede dejar atrás migajas que permitan a
otras pruebas trabajar. Significa que los ejemplos pueden usar
libremente cualquier nombre definido en el nivel superior en "M", y
nombres definidos más temprano en los docstrings siendo ejecutados.
Los ejemplos no pueden ver nombres definidos en otros docstrings.

Puedes forzar el uso de tus propios diccionarios como contexto de
ejecución al pasar "globs=your_dict" a "testmod()" o "testfile()" en
su lugar.


¿Y las excepciones?
-------------------

No hay problema, siempre que el rastreo sea la única salida producida
por el ejemplo: sólo copia el rastreo.  [1] Ya que los rastreos
contienen detalles que probablemente cambien rápidamente (por ejemplo,
rutas de archivos exactas y números de línea), este es un caso donde
doctest trabaja duro para ser flexible en lo que acepta.

Ejemplo simple:

   >>> [1, 2, 3].remove(42)
   Traceback (most recent call last):
     File "<stdin>", line 1, in <module>
   ValueError: list.remove(x): x not in list

El doctest tiene éxito si se lanza "ValueError", con el detalle
"list.remove(x): x not in list" como se muestra.

La salida esperada para una excepción debe empezar con una cabecera de
rastreo, que puede ser una de las siguientes dos líneas, con el mismo
sangrado de la primera línea del ejemplo:

   Traceback (most recent call last):
   Traceback (innermost last):

La cabecera de rastreo es seguida por una pila de rastreo opcional,
cuyo contenido es ignorado por doctest.  La pila de rastreo es
típicamente omitida, o copiada palabra por palabra de una sesión
interactiva.

La pila de rastreo es seguida por la parte más interesante: la línea o
líneas conteniendo el tipo de excepción y detalle. Esto es usualmente
la última línea de un rastreo, pero se puede extender a través de
múltiples líneas si la excepción tiene un detalle de varias líneas:

   >>> raise ValueError('multi\n    line\ndetail')
   Traceback (most recent call last):
     File "<stdin>", line 1, in <module>
   ValueError: multi
       line
   detail

Las últimas tres líneas (empezando con "ValueError") son comparados
con el tipo de excepción y detalle, y el resto es ignorado.

La mejor práctica es omitir la pila de rastreo, a menos que añada
valor de documentación significante al ejemplo. Por lo que el último
ejemplo es probablemente mejor como:

   >>> raise ValueError('multi\n    line\ndetail')
   Traceback (most recent call last):
       ...
   ValueError: multi
       line
   detail

Note que los rastreos son tratados de manera especial. En particular,
en el ejemplo reescrito, el uso de "..." es independiente de la opción
"ELLIPSIS" de doctest. Se pueden excluir los puntos suspensivos en ese
ejemplo, así como también pueden haber tres (o trescientas) comas o
dígitos, o una transcripción sangrada de un *sketch* de Monty Python.

Algunos detalles que debes leer una vez, pero no necesitarás recordar:

* Doctest no puede adivinar si tu salida esperada vino de una
  excepción de rastreo o de una impresión ordinaria. Así que, un
  ejemplo que espera "ValueError: 42 is prime" pasará, ya sea si de
  hecho se lance "ValueError" o si el ejemplo simplemente imprime ese
  texto de rastreo. En la práctica, la salida ordinaria raramente
  comienza con una línea de cabecera de rastreo, por lo que esto no
  crea problemas reales.

* Cada línea de la pila de rastreo (si se presenta) debe estar más
  sangrada que la primera línea del ejemplo, *o* empezar con un
  carácter no alfanumérico. la primera línea que sigue a la cabecera
  de rastreo sangrada de igual forma y empezando con un alfanumérico
  es considerado el inicio del detalle de la excepción. Por supuesto
  que esto es lo correcto para rastreos genuinos.

* Cuando se especifica la opción "IGNORE_EXCEPTION_DETAIL" de doctest.
  todo lo que sigue a los dos puntos más a la izquierda y cualquier
  otra información del módulo en el nombre de la excepción se ignora.

* El shell interactivo omite la línea de la cabecera de rastreo para
  algunos "SyntaxError". Pero doctest usa la línea de la cabecera de
  rastreo para distinguir excepciones de los que no son. Así que en
  algunos casos raros donde necesitas probar un "SyntaxError" que
  omite la cabecera de rastreo, necesitarás poner manualmente la línea
  de cabecera de rastreo en tu ejemplo de prueba.

* Para algunos "SyntaxError", Python muestra la posición del carácter
  del error de sintaxis, usando un marcador "^":

     >>> 1 1
       File "<stdin>", line 1
         1 1
           ^
     SyntaxError: invalid syntax

  Ya que las líneas mostrando la posición del error vienen antes del
  tipo de excepción y detalle, no son revisadas por doctest. Por
  ejemplo, el siguiente test pasaría, a pesar de que pone el marcador
  "^" en la posición equivocada:

     >>> 1 1
     Traceback (most recent call last):
       File "<stdin>", line 1
         1 1
         ^
     SyntaxError: invalid syntax


Banderas de Opción
------------------

Varias banderas de opción controlan diversos aspectos del
comportamiento de doctest. Los nombres simbólicos para las banderas
son proporcionados como constantes del módulo, que se pueden conectar
mediante *OR* bit a bit  y pasar a varias funciones. Los nombres
también pueden ser usados en las directivas de doctest, y se pueden
pasar a la interfaz de la línea de comandos de doctest a través de la
opción "-o".

Nuevo en la versión 3.4: La opción de la línea de comandos "-o".

El primer grupo de opciones definen las semánticas de la prueba,
controlando aspectos de cómo doctest decide si la salida de hecho
concuerda con la salida esperada del ejemplo:

doctest.DONT_ACCEPT_TRUE_FOR_1

   Por defecto, si un bloque de salida esperada contiene sólo "1", se
   considera igual a un bloque de salida real conteniendo sólo "1" o
   "true", y similarmente para "0" contra "False". Cuando se
   especifica "DONT_ACCEPT_TRUE_FOR_1`", no se permite ninguna
   sustitución.  El comportamiento por defecto atiende a que Python
   cambió el tipo de retorno de muchas funciones de enteros a
   booleanos; los doctest esperando salidas "de pequeño enteros"
   todavía trabajan en estos casos. Esta opción probablemente se vaya,
   pero no por muchos años.

doctest.DONT_ACCEPT_BLANKLINE

   Por defecto, si un bloque de salida esperada contiene una línea que
   sólo tiene la cadena de caracteres "<BLANKLINE>", entonces esa
   línea corresponderá a una línea en blanco en la salida real. Ya que
   una línea en blanca auténtica delimita la salida esperada, esta es
   la única manera de comunicar que una línea en blanco es esperada.
   Cuando se especifica "DONT_ACCEPT_BLANKLINE", esta substitución no
   se permite.

doctest.NORMALIZE_WHITESPACE

   Cuando se especifica, todas las secuencias de espacios en blanco
   (vacías y nuevas líneas) son tratadas como iguales. Cualquier
   secuencia de espacios en blanco dentro de la salida esperada
   corresponderá a cualquier secuencia de espacios en blanco dentro de
   la salida real. Por defecto, los espacios en blanco deben
   corresponderse exactamente.  "NORMALIZE_WHITESPACE" es
   especialmente útil cuando una línea de la salida esperada es muy
   larga, y quieres envolverla a través de múltiples líneas en tu
   código fuente.

doctest.ELLIPSIS

   Cuando se especifica, un marcador de puntos suspensivos ("...") en
   la salida esperada puede corresponder a cualquier cadena de
   caracteres en la salida real. Esto incluye las cadenas de
   caracteres que abarcan límites de líneas, y cadenas de caracteres
   vacías, por lo que es mejor mantener su uso simple. Usos
   complicados pueden conducir a los mismo tipos de sorpresa de "ups,
   coincidió demasiado" que ".*" es propenso a hacer en expresiones
   regulares.

doctest.IGNORE_EXCEPTION_DETAIL

   When specified, doctests expecting exceptions pass so long as an
   exception of the expected type is raised, even if the details
   (message and fully qualified exception name) don't match.

   For example, an example expecting "ValueError: 42" will pass if the
   actual exception raised is "ValueError: 3*14", but will fail if,
   say, a "TypeError" is raised instead. It will also ignore any fully
   qualified name included before the exception class, which can vary
   between implementations and versions of Python and the
   code/libraries in use. Hence, all three of these variations will
   work with the flag specified:

      >>> raise Exception('message')
      Traceback (most recent call last):
      Exception: message

      >>> raise Exception('message')
      Traceback (most recent call last):
      builtins.Exception: message

      >>> raise Exception('message')
      Traceback (most recent call last):
      __main__.Exception: message

   Note that "ELLIPSIS" can also be used to ignore the details of the
   exception message, but such a test may still fail based on whether
   the module name is present or matches exactly.

   Distinto en la versión 3.2: "IGNORE_EXCEPTION_DETAIL" también
   ignora cualquier información relacionada al módulo conteniendo la
   excepción bajo prueba.

doctest.SKIP

   Cuando se especifica, no ejecuta el ejemplo del todo. Puede ser
   útil en contextos donde los ejemplos de doctest sirven como
   documentación y casos de prueba a la vez, y un ejemplo debe ser
   incluido para propósitos de documentación, pero no debe ser
   revisado. P. ej., la salida del ejemplo puede ser aleatoria, o el
   ejemplo puede depender de recursos que no estarían disponibles para
   el controlador de pruebas.

   La bandera *SKIP* también se puede usar para temporalmente "quitar"
   ejemplos.

doctest.COMPARISON_FLAGS

   Una máscara de bits o juntadas lógicamente todas las banderas de
   arriba.

El segundo grupo de opciones controla cómo las fallas de las pruebas
son reportadas:

doctest.REPORT_UDIFF

   Cuando se especifica, las fallas que involucran salidas multilínea
   esperadas y reales son mostradas usando una diferencia (*diff*)
   unificada.

doctest.REPORT_CDIFF

   Cuando se especifica, las fallas que involucran salidas multilínea
   esperadas y reales se mostrarán usando una diferencia (*diff*)
   contextual.

doctest.REPORT_NDIFF

   Cuando se especifica, las diferencias son computadas por
   "difflib.Differ", usando el mismo algoritmo que la popular utilidad
   "ndiff.py". Este es el único método que marca diferencias dentro de
   líneas también como a través de líneas. Por ejemplo, si una línea
   de salida esperada contiene el dígito "1" donde la salida actual
   contiene la letra "l", se inserta una línea con una marca de
   inserción marcando la posición de las columnas que no coinciden.

doctest.REPORT_ONLY_FIRST_FAILURE

   Cuando se especifica, muestra el primer ejemplo fallido en cada
   doctest, pero suprime la salida para todos ejemplos restantes. Esto
   evitará que doctest reporte los ejemplos correctos que se rompen
   por causa de fallos tempranos; pero también puede esconder ejemplos
   incorrectos que fallen independientemente de la primera falla.
   Cuando se especifica "REPORT_ONLY_FIRST_FAILURE", los ejemplos
   restantes aún se ejecutan, y aún cuentan para el número total de
   fallas reportadas, sólo se suprime la salida.

doctest.FAIL_FAST

   Cuando se especifica, sale después del primer ejemplo fallido y no
   intenta ejecutar los ejemplos restantes. Por consiguiente, el
   número de fallas reportadas será como mucho 1. Esta bandera puede
   ser útil durante la depuración, ya que los ejemplos después de la
   primera falla ni siquiera producirán salida de depuración.

   La línea de comandos de doctest acepta la opción "-f" como un atajo
   para "-o FAIL_FAST".

   Nuevo en la versión 3.4.

doctest.REPORTING_FLAGS

   Una máscara de bits o todas las banderas de reporte arriba
   combinadas.

También hay una manera de registrar nombres de nuevas opciones de
banderas, aunque esto no es útil a menos que intentes extender
"doctest" a través de herencia:

doctest.register_optionflag(name)

   Crea una nueva bandera de opción con un nombre dado, y retorna el
   valor entero de la nueva bandera. se puede usar
   "register_optionflag()" cuando se hereda "OutputChecker" o
   "DocTestRunner" para crear nuevas opciones que sean compatibles con
   tus clases heredadas. "register_optionflag()" siempre debe ser
   llamado usando la siguiente expresión:

      MY_FLAG = register_optionflag('MY_FLAG')


Directivas
----------

Se pueden usar las directivas de doctest para modificar las banderas
de opción para un ejemplo individual. Las directivas de doctest son
comentarios de Python especiales que siguen el código fuente de un
ejemplo:

   directive             ::= "#" "doctest:" directive_options
   directive_options     ::= directive_option ("," directive_option)*
   directive_option      ::= on_or_off directive_option_name
   on_or_off             ::= "+" | "-"
   directive_option_name ::= "DONT_ACCEPT_BLANKLINE" | "NORMALIZE_WHITESPACE" | ...

No se permite el espacio en blanco entre el "+" o "-" y el nombre de
la opción de directiva (*directive option name*). El nombre de la
opción de directiva puede ser cualquiera de los nombres de las
banderas de opciones explicadas arriba.

Las directivas de doctest de un ejemplo modifican el comportamiento de
doctest para ese único ejemplo. Usa "+" para habilitar el
comportamiento nombrado, o "-" para deshabilitarlo.

For example, this test passes:

   >>> print(list(range(20)))  # doctest: +NORMALIZE_WHITESPACE
   [0,   1,  2,  3,  4,  5,  6,  7,  8,  9,
   10,  11, 12, 13, 14, 15, 16, 17, 18, 19]

Without the directive it would fail, both because the actual output
doesn't have two blanks before the single-digit list elements, and
because the actual output is on a single line.  This test also passes,
and also requires a directive to do so:

   >>> print(list(range(20)))  # doctest: +ELLIPSIS
   [0, 1, ..., 18, 19]

Multiple directives can be used on a single physical line, separated
by commas:

   >>> print(list(range(20)))  # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE
   [0,    1, ...,   18,    19]

If multiple directive comments are used for a single example, then
they are combined:

   >>> print(list(range(20)))  # doctest: +ELLIPSIS
   ...                         # doctest: +NORMALIZE_WHITESPACE
   [0,    1, ...,   18,    19]

As the previous example shows, you can add "..." lines to your example
containing only directives.  This can be useful when an example is too
long for a directive to comfortably fit on the same line:

   >>> print(list(range(5)) + list(range(10, 20)) + list(range(30, 40)))
   ... # doctest: +ELLIPSIS
   [0, ..., 4, 10, ..., 19, 30, ..., 39]

Tenga en cuenta que ya que todas las opciones están deshabilitadas por
defecto, y las directivas sólo aplican a los ejemplos en los que
aparecen, habilitarlas (a través de "+" en la directiva) usualmente es
la única opción significativa. Sin embargo, las banderas de opciones
también pueden ser pasadas a funciones que ejecutan doctests,
estableciendo valores por defecto diferentes. En tales casos,
deshabilitar una opción a través de "-" en una directiva puede ser
útil.


Advertencias
------------

"doctest" es serio acerca de requerir coincidencias exactas en la
salida esperada. Si incluso un solo carácter no coincide, el test
falla. Esto probablemente te sorprenderá algunas veces, mientras
aprendes exactamente lo que Python asegura y no asegura sobre la
salida. Por ejemplo, cuando se imprime un conjunto, Python no asegura
que el elemento sea impreso en ningún orden particular, por lo que una
prueba como

   >>> foo()
   {"Hermione", "Harry"}

¡es vulnerable! Una solución puede ser hacer

   >>> foo() == {"Hermione", "Harry"}
   True

es su lugar. Otra es hacer

   >>> d = sorted(foo())
   >>> d
   ['Harry', 'Hermione']

Existen otros casos, pero ya captas la idea.

Another bad idea is to print things that embed an object address, like

   >>> id(1.0)  # certain to fail some of the time  
   7948648
   >>> class C: pass
   >>> C()  # the default repr() for instances embeds an address   
   <C object at 0x00AC18F0>

The "ELLIPSIS" directive gives a nice approach for the last example:

   >>> C()  # doctest: +ELLIPSIS
   <C object at 0x...>

Los números de coma flotante también son sujetos a pequeñas
variaciones de la salida a través de las plataformas, porque Python
defiere a la librería C de la plataforma para el formato de flotantes,
y las librerías de C varían extensamente en calidad aquí.

   >>> 1./7  # risky
   0.14285714285714285
   >>> print(1./7) # safer
   0.142857142857
   >>> print(round(1./7, 6)) # much safer
   0.142857

Números de la forma "I/2.**J" son seguros a lo largo de todas las
plataformas, y yo frecuentemente planeo ejemplos de doctest para
producir números de esa forma:

   >>> 3./4  # utterly safe
   0.75

Las facciones simples también son más fáciles de entender para las
personas, y eso conduce a una mejor documentación.


API básica
==========

Las funciones "testmod()" y "testfile()" proporcionan una interfaz
simple para doctest que debe ser suficiente para la mayoría de los
usos básicos. Para una introducción menos formal a estas funciones,
véase las secciones Uso simple: verificar ejemplos en docstrings y Uso
Simple: Verificar ejemplos en un Archivo de Texto.

doctest.testfile(filename, module_relative=True, name=None, package=None, globs=None, verbose=None, report=True, optionflags=0, extraglobs=None, raise_on_error=False, parser=DocTestParser(), encoding=None)

   Todos los argumentos excepto *filename* son opcionales, y deben ser
   especificados en forma de palabras claves.

   Prueba los ejemplos en el archivo con nombre *filename*. Retorna
   "(failure_count, test_count)".

   El argumento opcional *module_relative* especifica cómo el nombre
   de archivo debe ser interpretado:

   * Si *module_relative* es "True" (el valor por defecto), entonces
     *filename* especifica una ruta relativa al módulo que es
     independiente del SO. Por defecto, esta ruta es relativa al
     directorio del módulo que lo invoca; pero si el argumento
     *package* es especificado, entonces es relativo a ese paquete.
     Para asegurar la independencia del SO, *filename* debe usar
     caracteres "/" para separar segmentos, y no puede ser una ruta
     absoluta (por ejemplo., no puede empezar con "/").

   * Si *module_relative* es "False", entonces *filename* especifica
     una ruta especifica del SO. La ruta puede ser absoluta o
     relativa; las rutas relativas son resueltas con respecto al
     directorio de trabajo actual.

   El argumento opcional *name* proporciona el nombre de la prueba;
   por defecto, o si es "None", se usa "os.path.basename(filename)".

   El argumento opcional *package* es un paquete de Python o el nombre
   de una paquete de Python cuyo directorio debe ser usado como el
   directorio base para un nombre de archivo relativo al módulo. Si no
   se especifica ningún paquete, entonces el directorio del módulo que
   invoca se usa como el directorio base para los nombres de archivos
   relativos al módulo. Es un error especificar *package* si
   *module_relative* es "False".

   El argumento opcional *globs* proporciona un diccionario a ser
   usado como los globales cuando se ejecuten los ejemplos. Se crea
   una nueva copia superficial de este diccionario para el doctest,
   por lo que sus ejemplos empiezan con una pizarra en blanco. Por
   defecto, o si es "None", se usa un nuevo diccionario vacío.

   El argumento opcional *extraglobs* proporciona un diccionario
   mezclado con los globales usados para ejecutar ejemplos. Funciona
   como "dict.update()": si *globs* y *extraglobs* tienen una clave en
   común, el valor asociado en *extraglobs* aparece en el diccionario
   combinado. Por defecto, o si es "None", no se usa ninguna variable
   global. Es una característica avanzada que permite la
   parametrización de doctests. Por ejemplo, un doctest puede ser
   escribo para una clase base, usando un nombre genérico para la
   clase, y luego reusado para probar cualquier número de clases
   heredadas al pasar un diccionario de *extraglobs* mapeando el
   nombre genérico a la clase heredada para ser probada.

   El argumento opcional *verbose* imprime un montón de cosas si es
   verdadero, e imprime sólo las fallas si es falso; por defecto, o si
   es "None", es verdadero si y sólo si "'-v'" está en "sys.argv".

   El argumento opcional *report* imprime un resumen al final cuando
   es verdadero; si no, no imprime nada al final. En modo verboso
   (*verbose*), el resumen es detallado; si no, el resumen es muy
   corto (de hecho, vacío si todos las pruebas pasan).

   El argumento opcional *optionflags* (valor por defecto 0) toma las
   banderas de opciones juntadas lógicamente por un OR. Véase la
   sección Banderas de Opción.

   El argumento opcional *raise_on_error* tiene como valor por defecto
   *false*. Si es *true*, se lanza una excepción sobre la primera
   falla o excepción no esperada en un ejemplo. Esto permite que los
   fallos sean depurados en un análisis a posteriori. El
   comportamiento por defecto es continuar corriendo los ejemplos.

   El argumento opcional *parser* especifica un "DocTestParser" (o
   subclase) que debe ser usado para extraer las pruebas de los
   archivos. Su valor por defecto es un analizador sintáctico normal
   (i.e., "DocTestParser()").

   El argumento opcional *encoding* especifica una codificación que
   debe ser usada para convertir el archivo a *unicode*.

doctest.testmod(m=None, name=None, globs=None, verbose=None, report=True, optionflags=0, extraglobs=None, raise_on_error=False, exclude_empty=False)

   Todos los argumentos son opcionales, y todos excepto por *m* deben
   ser especificados en forma de palabras claves.

   Prueba los ejemplos en los docstring de las funciones y clases
   alcanzables desde el módulo *m* (o desde el módulo "__main__" si
   *m* no es proporcionado o es "None"), empezando con "m.__doc__".

   También prueba los ejemplos alcanzables desde el diccionario de
   "m.__test__", si existe y no es "None". "m.__test__" mapea los
   nombres (cadenas de caracteres) a funciones, clases y cadenas de
   caracteres; se buscan los ejemplos de las funciones y clases; se
   buscan las cadenas de caracteres directamente como si fueran
   docstrings.

   Sólo se buscan los docstrings anexados a los objetos pertenecientes
   al módulo *m*.

   Retorna "(failure_count, test_count)".

   El argumento opcional *name* proporciona el nombre del módulo; por
   defecto, o si es "None", se usa "m.__name__".

   El argumento opcional *exclude_empty* es por defecto *false*. Si es
   verdadero, se excluyen los objetos por los cuales no se encuentren
   doctest. El valor por defecto es un *hack* de compatibilidad hacia
   atrás, por lo que el código que use "doctest.master.summarize()" en
   conjunto con "testmod()" continua obteniendo la salida para objetos
   sin pruebas. El argumento *exclude_empty* para el más nuevo
   constructor "DocTestFinder" es por defecto verdadero.

   Los argumentos opcionales *extraglobs*, *verbose*, *report*,
   *optionflags*, *raise_on_error*, y *globs* son los mismos en cuanto
   a la función "testfile()" arriba, excepto que *globs* es por
   defecto "m.__dict__".

doctest.run_docstring_examples(f, globs, verbose=False, name='NoName', compileflags=None, optionflags=0)

   Prueba los ejemplos asociados con el objeto *f*; por ejemplo, *f*
   puede ser una cadena de caracteres, un módulo, una función, o un
   objeto clase.

   Una copia superficial del diccionario del argumento *globs* se usa
   para la ejecución del contexto.

   Se usa el argumento opcional *name* en mensajes de fallos, y por
   defecto es ""NoName"".

   Si el argumento opcional *verbose* es verdadero, la salida se
   genera incluso si no hay fallas. Por defecto, la salida se genera
   sólo en caso de la falla de un ejemplo.

   El argumento opcional *compileflags* proporciona el conjunto de
   banderas que se deben usar por el compilador de Python cuando se
   corran los ejemplos. Por defecto, o si es "None", las banderas se
   deducen correspondiendo al conjunto de características futuras
   encontradas en *globs*.

   El argumento opcional *optionflags* trabaja con respecto a la
   función "testfile()" de arriba.


API de unittest
===============

Mientras crece tu colección de módulos probados con doctest, vas a
querer una forma de ejecutar todos sus doctests sistemáticamente.
"doctest" proporciona dos funciones que se pueden usar para crear un
banco de pruebas (*test suite*) de "unittest" desde módulos y archivos
de texto que contienen doctests. Para integrarse con el descubrimiento
de pruebas de "unittest" , incluye una función  "load_tests()" en tu
módulo de pruebas:

   import unittest
   import doctest
   import my_module_with_doctests

   def load_tests(loader, tests, ignore):
       tests.addTests(doctest.DocTestSuite(my_module_with_doctests))
       return tests

Hay dos funciones principales para crear instancias de
"unittest.TestSuite" desde los archivos de texto y módulos con
doctests:

doctest.DocFileSuite(*paths, module_relative=True, package=None, setUp=None, tearDown=None, globs=None, optionflags=0, parser=DocTestParser(), encoding=None)

   Convierte las pruebas de doctest de uno o más archivos de texto a
   una "unittest.TestSuite".

   El "unittest.TestSuite" que se retorne será ejecutado por el
   framework de unittest y ejecuta los ejemplos interactivos en cada
   archivo. Si un ejemplo en cualquier archivo falla, entonces la
   prueba unitaria sintetizada falla, y una excepción
   "failureException" se lanza mostrando el nombre del archivo
   conteniendo la prueba y un número de línea (algunas veces
   aproximado).

   Pasa una o más rutas (como cadenas de caracteres) a archivos de
   texto para ser examinados.

   Se pueden proporcionar las opciones como argumentos por palabra
   clave:

   El argumento opcional *module_relative* especifica cómo los nombres
   de archivos en *paths* se deben interpretar:

   * Si *module_relative* is "True" (el  valor por defecto), entonces
     cada archivo de nombre en *paths* especifica una ruta relativa al
     módulo independiente del SO. Por defecto, esta ruta es relativa
     al directorio del módulo lo está invocando; pero si se especifica
     el argumento *package*, entonces es relativo a ese paquete. Para
     asegurar la independencia del SO, cada nombre de archivo debe
     usar caracteres "/" para separar los segmentos de rutas, y puede
     no ser una ruta absoluta (i.e., puede no empezar con "/").

   * Si *module_relative* es "False", entonces cada archivo de nombre
     en *paths* especifica una ruta especifica al SO. La ruta puede
     ser absoluta o relativa; las rutas relativas son resueltas con
     respecto a directorio de trabajo actual.

   El argumento opcional *package* es un paquete de Python o el nombre
   de un paquete de Python cuyo directorio debe ser usado como el
   directorio base para los nombres de archivos relativos al módulo en
   *paths*. Si no se especifica ningún paquete, entonces el directorio
   del módulo que lo está invocando se usa como el directorio base
   para los archivos de nombres relativos al módulo. Es un error
   especificar *package* si *module_relative* es "False".

   El argumento opcional *setUp* especifica una función de
   configuración para el banco de pruebas. Es invocado antes de
   ejecutar las pruebas en cada archivo. La función *setUp* se pasará
   a un objeto "DocTest". La función *setUp* puede acceder a las
   variables globales de prueba como el atributo *globs* de la prueba
   pasada.

   El argumento opcional *tearDown* especifica una función de
   destrucción para el banco de pruebas. Es invocado después de
   ejecutar las pruebas en cada archivo. Se pasará un objeto "DocTest"
   a la función *tearDown*. La función *setUp* de configuración puede
   acceder a los globales de la prueba como el atributo *globs* de la
   prueba pasada.

   El argumento opcional *globs* es un diccionario que contiene las
   variables globales iniciales para las pruebas. Se crea una nueva
   copia de este diccionario para cada prueba. Por defecto, *globs* es
   un nuevo diccionario vacío.

   El argumento opcional *optionflags* especifica las opciones de
   doctest por defecto para las pruebas, creado al juntar lógicamente
   las opciones de bandera individuales. Véase la sección Banderas de
   Opción. Véase la función "set_unittest_reportflags()" abajo para
   una mejor manera de definir las opciones de informe.

   El argumento opcional *parser* especifica un "DocTestParser" (o
   subclase) que debe ser usado para extraer las pruebas de los
   archivos. Su valor por defecto es un analizador sintáctico normal
   (i.e., "DocTestParser()").

   El argumento opcional *encoding* especifica una codificación que
   debe ser usada para convertir el archivo a *unicode*.

   Se añade el global "__file__" a los globales proporcionados a los
   doctests cargados desde un archivo de texto usando
   "DocFileSuite()".

doctest.DocTestSuite(module=None, globs=None, extraglobs=None, test_finder=None, setUp=None, tearDown=None, checker=None)

   Convierte las pruebas de doctest para un módulo a un
   "unittest.TestSuite".

   El "unittest.TestSuite" que se retorne será ejecutado por el
   framework de unittest y corre cada doctest en el módulo. Si
   cualquiera de los doctests falla, entonces la prueba unitaria
   combinada falla, y se lanza una excepción "failureException"
   mostrando el nombre del archivo que contiene la prueba y un número
   de línea (a veces aproximado).

   El argumento opcional *module* proporciona el módulo a probar.
   Puede ser un objeto de módulo o un nombre (posiblemente punteado)
   de módulo. Si no se especifica, se usa el módulo que invoca esta
   función.

   El argumento opcional *globs* es un diccionario que contiene las
   variables globales iniciales para las pruebas. Se crea una nueva
   copia de este diccionario para cada prueba. Por defecto, *globs* es
   un nuevo diccionario vacío.

   El argumento opcional *extraglobs* especifica un conjunto de
   variables globales adicionales que son mezcladas con *globs*. Por
   defecto, no se usa ningún global adicional.

   El argumento opcional *test_finder* es el objeto "DocTestFinder" (o
   un reemplazo directo) que se usa para extraer doctests desde el
   módulo.

   Los argumentos opcionales *setUp*, *tearDown*, y *optionflags* son
   lo mismo con respecto a la función "DocFileSuite()" arriba.

   Esta función usa la misma técnica de búsqueda que "testmod()".

   Distinto en la versión 3.5: "DocTestSuite()" retorna un
   "unittest.TestSuite" vacío si *module* no contiene ningún docstring
   en vez de lanzar  un "ValueError".

Por detrás, "DocTestSuite()" crea un "unittest.TestSuite" de las
instancias de "doctest.DocTestCase", y "DocTestCase" es una subclase
de "unittest.TestCase". "DocTestCase" no está documentado aquí (es un
detalle interno), pero estudiar su código puede responder preguntas
sobre los detalles exactos de la integración de "unittest".

De manera similar, "DocFileSuite()" crea un  "unittest.TestSuite" de
las instancias de "doctest.DocFileCase", y "DocFileCase" es una
subclase de  "DocTestCase".

Por lo que ambas formas de crear un "unittest.TestSuite" ejecutan
instancias de "DocTestCase". Esto es importante por una razón sutil:
cuando ejecutas las funciones de "doctest" por ti mismo, puedes
controlar las opciones de "doctest" en uso directamente, al pasar las
banderas de opciones a las funciones de "doctest". Sin embargo, si
estás escribiendo un framework de "unittest", básicamente "unittest"
controla cuándo y cómo se ejecutan las pruebas. El autor del framework
típicamente, quiere controlar las opciones de reporte de "doctest"
(quizás, p.ej., especificadas por las opciones de la línea de
comandos), pero no hay forma de pasar opciones a través de "unittest"
al probador de ejecución (*test runner*) de "doctest".

Por esta razón, "doctest" también admite una noción de banderas de
informe de "doctest" específicas para la compatibilidad con
"unittest", a través de esta función:

doctest.set_unittest_reportflags(flags)

   Establece las banderas de informe de "doctest" a usar.

   El argumento *flags* toma la combinación por el operador OR de las
   banderas de opciones. Véase la sección Banderas de Opción. Sólo se
   pueden usar las "banderas de informe".

   Esta es una configuración global del módulo, y afecta a todos los
   doctests futuros a ejecutar por "unittest": el método "runTest()"
   de "DocTestCase" revisa las banderas de opciones especificadas para
   el caso de prueba cuando la instancia de "DocTestCase" fue
   construida. Si no se especificó ninguna bandera de informe (que es
   el caso típico y esperado), las banderas de informe -pertenecientes
   a "doctest"- de "unittest" son combinadas por la operación Or en
   las banderas de opciones, y las banderas de opciones aumentadas se
   pasan a la instancia de "DocTestRunner" creada para ejecutar los
   doctest. Si se especificó alguna bandera de informe cuando el
   "DocTestCase" fue construido, se ignoran las banderas de informe
   -pertenecientes a "doctest"- de "unittest".

   La función retorna el valor de las banderas de informe de
   "unittest" en efecto antes de que la función fuera invocada.


API avanzada
============

La API básica es un simple envoltorio que sirve para hacer los doctest
fáciles de usar. Es bastante flexible, y debe cumplir las necesidades
de la mayoría de los usuarios; si requieres un control más preciso en
las pruebas, o deseas extender las capacidades de doctest, entonces
debes usar la API avanzada.

La API avanzada gira en torno a dos clases contenedoras, que se usan
para guardar los ejemplos interactivos extraídos de los casos doctest:

* "Example": Un *statement* de Python, emparejado con su salida
  esperada.

* "DocTest": Una colección de clases "Example", típicamente extraídos
  de un sólo docstring o archivo de texto.

Se definen clases de procesamiento adicionales para encontrar,
analizar sintácticamente, y ejecutar, y comprobar ejemplos de doctest:

* "DocTestFinder": Encuentra todos los docstrings en un módulo dado, y
  usa un "DocTestParser" para crear un "DocTest" de cada docstring que
  contiene ejemplos interactivos.

* "DocTestParser": Crea un objeto "DocTest" de una cadena de
  caracteres (tal como un docstring de un objeto).

* "DocTestRunner": Ejecuta los ejemplos en un "DocTest", y usa un
  "OutputChecker" para verificar su salida.

* "OutputChecker": Compara la salida real de un ejemplo de doctest con
  la salida esperada, y decide si coinciden.

Las relaciones entre estas clases de procesamiento se resumen en el
siguiente diagrama:

                               list of:
   +------+                   +---------+
   |module| --DocTestFinder-> | DocTest | --DocTestRunner-> results
   +------+    |        ^     +---------+     |       ^    (printed)
               |        |     | Example |     |       |
               v        |     |   ...   |     v       |
              DocTestParser   | Example |   OutputChecker
                              +---------+


Objetos DocTest
---------------

class doctest.DocTest(examples, globs, name, filename, lineno, docstring)

   Una colección de ejemplos de doctest que deben ejecutarse en un
   sólo nombre de espacios. Se usan los argumentos del constructor
   para inicializar los atributos de los mismos nombres.

   "DocTest" define los siguientes atributos. Son inicializados por el
   constructor, y no deben ser modificados directamente.

   examples

      Una lista de objetos "Example" codificando los ejemplos
      interactivos de Python individuales que esta prueba debe
      ejecutar.

   globs

      El nombre de espacios (alias *globals*) en que los ejemplos se
      deben ejecutar. Este es un diccionario que mapea nombres a
      valores. Cualquier cambio al nombre de espacios hecho por los
      ejemplos (tal como juntar nuevas variables) se reflejará en
      "globs" después de que se ejecute la prueba.

   name

      Un nombre de cadena de caracteres que identifica el "DocTest".
      Normalmente, este es el nombre del objeto o archivo del que se
      extrajo la prueba.

   filename

      El nombre del archivo del que se extrajo este "DocTest"; o
      "None" si el nombre del archivo se desconoce, o si "DocTest" no
      se extrajo de un archivo.

   lineno

      El número de línea dentro de "filename" donde este "DocTest"
      comienza, o "None" si el número de línea no está disponible.
      Este número de línea es comienza en 0 con respecto al comienzo
      del archivo.

   docstring

      La cadena de caracteres del que se extrajo la cadena, o "None"
      si la cadena no está disponible, o si la prueba no se extrajo de
      una cadena de caracteres.


Objetos *Example*
-----------------

class doctest.Example(source, want, exc_msg=None, lineno=0, indent=0, options=None)

   Un sólo ejemplo interactivo, que consta de una sentencia de Python
   y su salida esperada. Los argumentos del constructor se usan para
   inicializar los atributos del mismo nombre.

   La clase "Example" define los siguientes atributos. Son
   inicializados por el constructor, y no deben ser modificados
   directamente.

   source

      Una cadena de caracteres que contiene el código fuente del
      ejemplo. Este código fuente consiste de una sola sentencia
      Python, y siempre termina en una nueva línea; el constructor
      añade una nueva línea cuando sea necesario.

   want

      La salida esperada de ejecutar el código fuente del ejemplo (o
      desde la salida estándar, o un seguimiento en caso de una
      excepción). "wants" termina con una nueva línea a menos que no
      se espera ninguna salida, en cuyo caso es una cadena vacía. El
      constructor añade una nueva línea cuando sea necesario.

   exc_msg

      El mensaje de excepción que el ejemplo genera, si se espera que
      el ejemplo genere una excepción; o "None" si no se espera que
      genere una excepción. Se compara este mensaje de excepción con
      el valor de retorno de "traceback.format_exception_only()".
      "exc_msg" termina con una nueva línea a menos que sea "None".
      El constructor añade una nueva línea si se necesita.

   lineno

      El número de línea dentro de la cadena de caracteres que
      contiene este ejemplo donde el ejemplo comienza. Este número de
      línea comienza en 0 con respecto al comienzo de la cadena que lo
      contiene.

   indent

      La sangría del ejemplo en la cadena que lo contiene; i.e., el
      número de caracteres de espacio que preceden la primera entrada
      del ejemplo.

   options

      Un diccionario que mapea de las banderas de opciones a "True" o
      "False", que se usa para anular las opciones por defecto para
      este ejemplo. Cualquier bandera de opción que no contiene este
      diccionario se deja con su valor por defecto (como se especifica
      por los "optionflags" de "DocTestRunner"). Por defecto, no se
      establece ninguna opción.


Objetos *DocTestFinder*
-----------------------

class doctest.DocTestFinder(verbose=False, parser=DocTestParser(), recurse=True, exclude_empty=True)

   Una clase de procesamiento que se usa para extraer los "DocTest"
   que son relevantes para un objeto dado, desde su docstring y los
   docstring de sus objetos contenidos. Se puede extraer los "DocTest"
   de los módulos, clases, funciones, métodos, métodos estáticos,
   métodos de clase, y propiedades.

   Se puede usar el argumento opcional *verbose* para mostrar los
   objetos buscados por *finder*. Su valor por defecto es "False"
   (ninguna salida).

   El argumento opcional *parser* especifica el objeto "DocTestParser"
   (o un reemplazo directo) que se usa para extraer doctests desde
   docstrings.

   Si el argumento opcional *recurse* es falso, entonces el método
   "DocTestFinder.find()" sólo examinará el objeto dado, y no
   cualquier objeto contenido.

   Si el argumento opcional *exclude_empty* es falso, entonces
   "DocTestFinder.find()" incluirá pruebas para objetos con docstrings
   vacíos.

   "DocTestFinder" define los siguientes métodos:

   find(obj[, name][, module][, globs][, extraglobs])

      Retorna una lista de los "Doctest" que se definen por el
      docstring de *obj*, o por cualquiera de los docstring de sus
      objetos contenidos.

      El argumento opcional *name* especifica el nombre del objeto;
      este nombre será usado para construir los nombres de los
      "DocTest" retornados. Si *name* no se especifica, entonces se
      usa "obj.__name__".

      El parámetro opcional *module* es el módulo que contiene el
      objeto dado. Si no se especifica el módulo o si es "None",
      entonces el buscador de pruebas tratará de determinar
      automáticamente el módulo correcto. Se usa el módulo del objeto:

      * Como un espacio de nombres por defecto, si no se especifica
        *globs*.

      * Para evitar que *DocTestFinder* extraiga DocTests desde
        objetos que se importan desde otros módulos. (Se ignoran
        objetos contenidos con módulos aparte de *module*.)

      * Para encontrar el nombre del archivo conteniendo el objeto.

      * Para ayudar a encontrar el número de línea del objeto dentro
        de su archivo.

      Si *module* es falso, no se hará ningún intento de encontrar el
      módulo. Es poco claro, de uso mayormente para probar doctest en
      si mismo: si *module* es "False", o es "None" pero no se puede
      encontrar automáticamente, entonces todos los objetos se
      consideran que pertenecen al módulo (inexistente), por lo que
      todos los objetos contenidos se buscarán (recursivamente) por
      doctests.

      Los globales para cada "DocTest" se forma al combinar *globs* y
      *extraglobs* (los enlaces en *extraglobs* anulan los enlaces en
      *globs*). Se crea una nueva copia superficial del diccionario de
      globales para cada "DocTest". Si *globs* no se especifica,
      entonces su valor por defecto es el *__dict__* del módulo, si se
      especifica, o es "{}" de lo contrario, si *extraglobs* no se
      especifica, entonces su valor por defecto es "{}".


Objetos *DocTestParser*
-----------------------

class doctest.DocTestParser

   Un clase de procesamiento usada para extraer ejemplos interactivos
   de una cadena de caracteres, y usarlos para crear un objeto
   "DocTest".

   "DocTestParser" define los siguientes métodos:

   get_doctest(string, globs, name, filename, lineno)

      Extrae todos los ejemplos de *doctest* de una cadena dada, y los
      recolecta en un objeto "DocTest".

      *globs*, *name*, *filename*, y *lineno* son atributos para el
      nuevo objeto "DocTest". Véase la documentación de "DocTest" para
      más información.

   get_examples(string, name='<string>')

      Extrae todos los ejemplos de la cadena de caracteres dada, y los
      retorna como una lista de objetos "Example". Los números de
      línea empiezan en 0. El argumento opcional *name* es una nombre
      identificando esta cadena, y sólo es usada para mensajes de
      errores.

   parse(string, name='<string>')

      Divide el string dado en ejemplos y texto intermedio, y los
      retorna como una lista que alterna entre objetos "Example" y
      cadenas de caracteres. Los números de línea para los objetos
      "Example" empiezan en 0. El argumento opcional *name* es un
      nombre identificando esta cadena, y sólo se usa en mensajes de
      error.


Objetos *DocTestRunner*
-----------------------

class doctest.DocTestRunner(checker=None, verbose=None, optionflags=0)

   Una clase de procesamiento usada para ejecutar y verificar los
   ejemplos interactivos en un "DocTest".

   La comparación entre salidas esperadas y salidas reales se hace por
   un "OutputChecker". Esta comparación puede ser personalizada con un
   número de banderas de opción; véase la sección Banderas de Opción
   para más información. Si las banderas de opción son insuficientes,
   entonces la comparación también puede ser personalizada al pasar
   una subclase de "OutputChecker" al constructor.

   La salida de la pantalla del *test runner* se puede controlar de
   dos maneras. Primero, se puede pasar una función de salida a
   "TestRunner.run()"; esta función se invocará con cadenas que deben
   mostrarse. Su valor por defecto es "sys.stdout.write". Si no es
   suficiente capturar el resultado, entonces la salida de la pantalla
   también se puede personalizar al heredar de DocTestRunner, y
   sobreescribir los métodos "report_start()", "report_success()",
   "report_unexpected_exception()", y "report_failure()".

   El argumento por palabra clave opcional *checker* especifica el
   objeto "OutputChecker" (o un reemplazo directo) que se debe usar
   para comparar las salidas esperadas con las salidas reales de los
   ejemplos de doctest.

   El argumento por palabra clave opcional *verbose* controla la
   verbosidad de "DocTestRunner". Si *verbose* es "True", entonces la
   información de cada ejemplo se imprime , mientras se ejecuta. Si
   *verbose* es "False", entonces sólo las fallas se imprimen. Si
   *verbose* no se especifica, o es "None", entonces la salida verbosa
   se usa si y sólo se usa el modificador de la línea de
   comandos``-v``.

   El argumento por palabra clave opcional *optionflags* se puede usar
   para controlar cómo el *test runner* compara la salida esperada con
   una salida real, y cómo muestra las fallas. Para más información,
   véase la sección Banderas de Opción.

   "DocTestParser" define los siguientes métodos:

   report_start(out, test, example)

      Notifica que el *test runner* está a punto de procesar el
      ejemplo dado. Este método es proporcionado para permitir que
      clases heredadas de "DocTestRunner" personalicen su salida; no
      debe ser invocado directamente.

      *example* es el ejemplo a punto de ser procesado. *test* es la
      prueba que contiene a *example*. *out* es la función de salida
      que se pasó a "DocTestRunner.run()".

   report_success(out, test, example, got)

      Notifica que el ejemplo dado se ejecutó correctamente. Este
      método es proporcionado para permitir que las clases heredadas
      de "DocTestRunner" personalicen su salida; no debe ser invocado
      directamente.

      *example* es el ejemplo a punto de ser procesado. *got* es la
      salida real del ejemplo. *test* es la prueba conteniendo
      *example*. *out* es la función de salida que se pasa a
      "DocTestRunner.run()".

   report_failure(out, test, example, got)

      Notifica que el ejemplo dado falló. Este método es proporcionado
      para permitir que clases heredadas de "DocTestRunner"
      personalicen su salida; no debe ser invocado directamente.

      *example* es el ejemplo a punto de ser procesado. *got* es la
      salida real del ejemplo. *test* es la prueba conteniendo
      *example*. *out* es la función de salida que se pasa a
      "DocTestRunner.run()".

   report_unexpected_exception(out, test, example, exc_info)

      Notifica que el ejemplo dado lanzó una excepción inesperada.
      Este método es proporcionado para permitir que las clases
      heredadas de "DocTestRunner" personalicen su salida; no debe ser
      invocado directamente.

      *example* es el ejemplo a punto de ser procesado, *exc_info* es
      una tupla que contiene información sobre la excepción inesperada
      (como se retorna por "sys.exc_info()"). *test* es la prueba
      conteniendo *example*. *out* es la función de salida que debe
      ser pasada a "DocTestRunner.run()".

   run(test, compileflags=None, out=None, clear_globs=True)

      Ejecuta los ejemplos en *test* (un objeto "DocTest"), y muestra
      los resultados usando función de escritura *out*.

      Los ejemplo se ejecutan en el espacio de nombres "test.globs".
      Si *clear_globs* es verdadero (el valor por defecto), entonces
      este espacio de nombres será limpiado después de la prueba se
      ejecute, para ayudar con la colección de basura. Si quisieras
      examinar el espacio de nombres después de que la prueba se
      complete, entonces use *clear_globs=False*.

      *compileflags* da el conjunto de banderas que se deben usar por
      el compilador de Python cuando se ejecutan los ejemplos. Si no
      se especifica, entonces su valor por defecto será el conjunto de
      banderas de *future-import* que aplican a *globs*.

      La salida de cada ejemplo es revisada usando el *output checker*
      del "DocTestRunner", y los resultados se formatean por los
      métodos de "DocTestRunner.report_*()".

   summarize(verbose=None)

      Imprime un resumen de todos los casos de prueba que han sido
      ejecutados por este *DocTestRunner*, y retorna un *named tuple*
      "TestResults(failed, attempted)".

      El argumento opcional *verbose* controla qué tan detallado es el
      resumen. Si no se especifica la verbosidad, entonces se usa la
      verbosidad de "DocTestRunner".


Objetos *OutputChecker*
-----------------------

class doctest.OutputChecker

   Una clase que se usa para verificar si la salida real de un ejemplo
   de doctest coincide con la salida esperada. "OutputChecker" define
   dos métodos: "check_output()", que compara un par de salidas dadas,
   y retorna "True" si coinciden; y "output_difference()", que retorna
   una cadena que describe las diferencias entre las dos salidas.

   "OutputChecker" define los siguientes métodos:

   check_output(want, got, optionflags)

      Retorna "True" si y sólo si la salida real de un ejemplo (*got*)
      coincide con la salida esperada (*want*). Siempre se considera
      que estas cadenas coinciden si son idénticas; pero dependiendo
      de qué banderas de opción el *test runner* esté usando, varias
      coincidencias inexactas son posibles. Véase la sección Banderas
      de Opción para más información sobre las banderas de opción.

   output_difference(example, got, optionflags)

      Retorna una cadena que describe las diferencias entre la salida
      esperada para un ejemplo dado (*example*) y la salida real
      (*got*). *optionflags* es el conjunto de banderas de opción
      usado para comparar *want* y *got*.


Depuración
==========

Doctest proporciona varios mecanismos para depurar los ejemplos de
doctest:

* Varias funciones convierten los doctest en programas de Python
  ejecutables, que pueden ser ejecutadas bajo el depurador de Python,
  "pdb".

* La clase "DebugRunner" es una subclase de "DocTestRunner" que lanza
  una excepción por el primer ejemplo fallido, conteniendo información
  sobre ese ejemplo. Esta información se puede usar para realizar
  depuración a posteriori en el ejemplo.

* Los casos de "unittest" generados por "DocTestSuite()" admiten el
  método "debug()" definido por "unittest.TestCase".

* Puedes añadir una llamada a "pdb.set_trace()" en un ejemplo de
  doctest, y bajarás al depurador de Python cuando esa línea sea
  ejecutada. Entonces puedes inspeccionar los valores de las
  variables, y demás. Por ejemplo, supongamos que "a.py" contiene sólo
  este docstring de módulo:

     """
     >>> def f(x):
     ...     g(x*2)
     >>> def g(x):
     ...     print(x+3)
     ...     import pdb; pdb.set_trace()
     >>> f(3)
     9
     """

  Entonces una sesión interactiva puede lucir como esta:

     >>> import a, doctest
     >>> doctest.testmod(a)
     --Return--
     > <doctest a[1]>(3)g()->None
     -> import pdb; pdb.set_trace()
     (Pdb) list
       1     def g(x):
       2         print(x+3)
       3  ->     import pdb; pdb.set_trace()
     [EOF]
     (Pdb) p x
     6
     (Pdb) step
     --Return--
     > <doctest a[0]>(2)f()->None
     -> g(x*2)
     (Pdb) list
       1     def f(x):
       2  ->     g(x*2)
     [EOF]
     (Pdb) p x
     3
     (Pdb) step
     --Return--
     > <doctest a[2]>(1)?()->None
     -> f(3)
     (Pdb) cont
     (0, 3)
     >>>

Funciones que convierten los doctest a código de Python, y
posiblemente ejecuten el código sintetizado debajo del depurador:

doctest.script_from_examples(s)

   Convierte texto con ejemplos a un script.

   El argumento *s* es una cadena que contiene los ejemplos de
   doctest. La cadena se convierte a un script de Python, donde los
   ejemplos de doctest en *s* se convierten en código regular, y todo
   lo demás se convierte en comentarios de Python. El script generado
   se retorna como una cadena: Por ejemplo,

      import doctest
      print(doctest.script_from_examples(r"""
          Set x and y to 1 and 2.
          >>> x, y = 1, 2

          Print their sum:
          >>> print(x+y)
          3
      """))

   muestra:

      # Set x and y to 1 and 2.
      x, y = 1, 2
      #
      # Print their sum:
      print(x+y)
      # Expected:
      ## 3

   Esta función se usa internamente por otras funciones (véase más
   abajo), pero también pueden ser útiles cuando quieres transformar
   una sesión de Python interactiva en un script de Python.

doctest.testsource(module, name)

   Convierte el doctest para un objeto en un script.

   El argumento *module* es un objeto módulo, o un nombre por puntos
   de un módulo, que contiene el objeto cuyos doctest son de interés.
   El argumento *name* es el nombre (dentro del módulo) del objeto con
   los doctest de interés. El resultado es una cadena de caracteres,
   que contiene el docstring del objeto convertido en un script de
   Python, como se describe por "script_from_examples()" arriba. Por
   ejemplo, si el módulo "a.py" contiene un función de alto nivel
   "f()", entonces

      import a, doctest
      print(doctest.testsource(a, "a.f"))

   imprime una versión de script del docstring de la función "f()",
   con los doctest convertidos en código, y el resto puesto en
   comentarios.

doctest.debug(module, name, pm=False)

   Depura los doctest para un objeto.

   Los argumentos *module* y *name* son los mismos que para la función
   "testsource()" arriba. El script de Python sintetizado para el
   docstring del objeto nombrado es escrito en un archivo temporal, y
   entonces ese archivo es ejecutado bajo el control del depurador de
   PYthon, "pdb".

   Se usa una copia superficial de "module.__dict__" para el contexto
   de ejecución local y global.

   El argumento opcional *pm* controla si se usa la depuración post-
   mortem. Si *pm* tiene un valor verdadero, el archivo de script es
   ejecutado directamente, y el depurador está involucrado sólo si el
   script termina a través del lanzamiento de una excepción. Si lo
   hace, entonces la depuración post-mortem es invocada, a través de
   "pdb.post_mortem()", pasando el objeto de rastreo desde la
   excepción sin tratar. Si no se especifica *pm*, o si es falso, el
   script se ejecuta bajo el depurador desde el inicio, a través de
   una llamada de "exec()" apropiada a "pdb.run()".

doctest.debug_src(src, pm=False, globs=None)

   Depura los doctest en una cadena de caracteres.

   Es como la función function "debug()" arriba, excepto que una
   cadena de caracteres que contiene los ejemplos de doctest se
   especifica directamente, a través del argumento *src*.

   El argumento opcional *pm* tiene el mismo significado como en la
   función "debug()" arriba.

   El argumento opcional *globs* proporciona un diccionario a usar
   como contexto de ejecución local y global. Si no se especifica, o
   es "None", se usa un diccionario vacío. Si se especifica, se usa
   una copia superficial del diccionario.

La clase "DebugRunner", y las excepciones especiales que puede lanzar,
son de más interés a los autores de frameworks de pruebas, y sólo
serán descritos brevemente aquí. Véase el código fuente, y
especialmente el docstring de "DebugRunner" (¡que es un doctest!) para
más detalles:

class doctest.DebugRunner(checker=None, verbose=None, optionflags=0)

   Una subclase de "DocTestRunner" que lanza una excepción tan pronto
   como se encuentra una falla. Si ocurre una excepción inesperada, se
   lanza una excepción "UnexpectedException", conteniendo la prueba,
   el ejemplo, y la excepción original. Si la salida no coincide,
   entonces se lanza una excepción "DocTestFailure", conteniendo la
   prueba, el ejemplo, y la salida real.

   Para información sobre los parámetros de construcción y los
   métodos, véase la documentación para "DocTestRunner" en la sección
   API avanzada.

Hay dos excepciones que se pueden lanzar por instancias de
"DebugRunner":

exception doctest.DocTestFailure(test, example, got)

   Una excepción lanzada por "DocTestRunner" para señalar que la
   salida real del ejemplo de un doctest no coincidió con su salida
   esperada. Los argumentos del constructor se usan para inicializar
   los atributos del mismo nombre.

"DocTestFailure" define los siguientes atributos:

DocTestFailure.test

   El objeto "DocTest" que estaba siendo ejecutado cuando el ejemplo
   falló.

DocTestFailure.example

   El objeto "Example" que falló.

DocTestFailure.got

   La salida real del ejemplo.

exception doctest.UnexpectedException(test, example, exc_info)

   Una excepción lanzada por "DocTestRunner" para señalar que un
   ejemplo de doctest lanzó una excepción inesperada. Los argumentos
   del constructor se usan para inicializar los atributos del mismo
   nombre.

"UnexpectedException" define los siguientes atributos:

UnexpectedException.test

   El objeto "DocTest" que estaba siendo ejecutado cuando el ejemplo
   falló.

UnexpectedException.example

   El objeto "Example" que falló.

UnexpectedException.exc_info

   Una tupla que contiene información sobre la excepción inesperada,
   como es retornado por "sys.exc_info()".


Plataforma improvisada
======================

Como se menciona en la introducción, "doctest" ha crecido para tener
tres usos primarios:

1. Verificar los ejemplos en los docstring.

2. Pruebas de regresión.

3. Documentación ejecutable / pruebas literarias.

Estos usos tienen diferentes requerimientos, y es importante
distinguirlos. En particular, llenar tus docstring con casos de prueba
desconocidos conduce a mala documentación.

Cuando se escribe un docstring, escoja ejemplos de docstring con
cuidado. Hay un arte para eso que se debe aprender -- puede no ser
natural al comienzo. Los ejemplos deben añadir valor genuino a la
documentación. Un buen ejemplo a menudo puede valer muchas palabras.
Si se hace con cuidado, los ejemplos serán invaluables para tus
usuarios, y compensarán el tiempo que toma recolectarlos varias veces
mientras los años pasan y las cosas cambian. Todavía estoy sorprendido
de qué tan frecuente uno de mis ejemplos de "doctest" paran de
funcionar después de un cambio "inofensivo".

Doctest también es una excelente herramienta para pruebas de
regresión, especialmente si no escatimas en texto explicativo. Al
intercalar prosa y ejemplos, se hace mucho más fácil mantener el
seguimiento de lo que realmente se está probando, y por qué. Cuando
una prueba falla, buena prosa puede hacer mucho más fácil comprender
cuál es el problema, y cómo debe ser arreglado. Es verdad que puedes
escribir comentarios extensos en pruebas basadas en código, pero pocos
programadores lo hacen. Quizás es porque simplemente doctest hace
escribir pruebas mucho más fácil que escribir código, mientras que
escribir comentarios en código es mucho más difícil. Pienso que va más
allá de eso: la actitud natural cuando se escribe una prueba basada en
doctest es que quieres explicar los puntos finos de tu software, e
ilustrarlos con ejemplos. Esto naturalmente lleva a archivos de
pruebas que empiezan con las características más simples, y
lógicamente progresan a complicaciones y casos extremos. Una narrativa
coherente es el resultado, en vez de una colección de funciones
aisladas que pruebas trozos aislados de funcionalidad aparentemente al
azar. Es una actitud diferente, y produce resultados diferentes,
difuminando la distinción entre probar y explicar.

Pruebas de regresión se limitan mejor a objetos o archivos dedicados.
Hay varias opciones para organizar pruebas:

* Escribe archivos de texto que contienen los casos de prueba como
  ejemplos interactivos, y prueba los archivos usando "testfile()" o
  "DocFileSuite()". Esto es lo recomendado, aunque es más fácil
  hacerlo para nuevos proyectos, diseñados desde el comienzo para usar
  doctest.

* Define funciones nombradas "_regrtest_topic" que consisten en
  docstrings únicas, que contienen casos de prueba por los tópicos
  nombrados. Estas funciones se pueden incluir en el mismo archivo que
  el módulo, o separadas en un archivo de prueba separado.

* Define un diccionario "__test__" que asigna desde temas de prueba de
  integración a los docstring que contienen casos de prueba.

Cuando has puesto tus pruebas en un módulo, el módulo puede ser el
mismo *test runner*. Cuando una prueba falla, puedes hacer que tu
*test runner* vuelva a ejecutar sólo los doctest fallidos mientras que
tu depuras el problema. Aquí hay un ejemplo mínimo de tal *test
runner*:

   if __name__ == '__main__':
       import doctest
       flags = doctest.REPORT_NDIFF|doctest.FAIL_FAST
       if len(sys.argv) > 1:
           name = sys.argv[1]
           if name in globals():
               obj = globals()[name]
           else:
               obj = __test__[name]
           doctest.run_docstring_examples(obj, globals(), name=name,
                                          optionflags=flags)
       else:
           fail, total = doctest.testmod(optionflags=flags)
           print("{} failures out of {} tests".format(fail, total))

-[ Notas al pie de página ]-

[1] No se admiten los ejemplos que contienen una salida esperada y una
    excepción. Intentar adivinar dónde una termina y la otra empieza
    es muy propenso a errores, y da lugar a una prueba confusa.
