# Copyright (C) 2001 Python Software Foundation

# This file is distributed under the same license as the Python package.

#

# Translators:

msgid ""

msgstr ""

"Project-Id-Version: Python 3.14\n"

"Report-Msgid-Bugs-To: \n"

"POT-Creation-Date: 2026-02-07 00:19+0000\n"

"PO-Revision-Date: 2018-05-23 14:43+0000\n"

"Last-Translator: Adrian Liaw <[email protected]>\n"

"Language-Team: Chinese - TAIWAN (https://github.com/python/python-docs-zh-"

"tw)\n"

"Language: zh_TW\n"

"MIME-Version: 1.0\n"

"Content-Type: text/plain; charset=UTF-8\n"

"Content-Transfer-Encoding: 8bit\n"

"Plural-Forms: nplurals=1; plural=0;\n"

#: ../../library/doctest.rst:2

msgid ":mod:`!doctest` --- Test interactive Python examples"

msgstr ":mod:`!doctest` --- 測試互動式 Python 範例"

#: ../../library/doctest.rst:12

msgid "**Source code:** :source:`Lib/doctest.py`"

msgstr "**原始碼：**\\ :source:`Lib/doctest.py`"

#: ../../library/doctest.rst:16

msgid ""

"The :mod:`!doctest` module searches for pieces of text that look like "

"interactive Python sessions, and then executes those sessions to verify that "

"they work exactly as shown. There are several common ways to use doctest:"

msgstr ""

#: ../../library/doctest.rst:20

msgid ""

"To check that a module's docstrings are up-to-date by verifying that all "

"interactive examples still work as documented."

msgstr ""

#: ../../library/doctest.rst:23

msgid ""

"To perform regression testing by verifying that interactive examples from a "

"test file or a test object work as expected."

msgstr "透過驗證測試檔案或測試物件中的互動式範例是否按預期運作來執行迴歸測試。"

#: ../../library/doctest.rst:26

msgid ""

"To write tutorial documentation for a package, liberally illustrated with "

"input-output examples. Depending on whether the examples or the expository "

"text are emphasized, this has the flavor of \"literate testing\" or "

"\"executable documentation\"."

msgstr ""

#: ../../library/doctest.rst:31

msgid "Here's a complete but small example module::"

msgstr ""

#: ../../library/doctest.rst:33

msgid ""

"\"\"\"\n"

"This is the \"example\" module.\n"

"\n"

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

"\n"

">>> factorial(5)\n"

"120\n"

"\"\"\"\n"

"\n"

"def factorial(n):\n"

" \"\"\"Return the factorial of n, an exact integer >= 0.\n"

"\n"

" >>> [factorial(n) for n in range(6)]\n"

" [1, 1, 2, 6, 24, 120]\n"

" >>> factorial(30)\n"

" 265252859812191058636308480000000\n"

" >>> factorial(-1)\n"

" Traceback (most recent call last):\n"

" ...\n"

" ValueError: n must be >= 0\n"

"\n"

" Factorials of floats are OK, but the float must be an exact integer:\n"

" >>> factorial(30.1)\n"

" Traceback (most recent call last):\n"

" ...\n"

" ValueError: n must be exact integer\n"

" >>> factorial(30.0)\n"

" 265252859812191058636308480000000\n"

"\n"

" It must also not be ridiculously large:\n"

" >>> factorial(1e100)\n"

" Traceback (most recent call last):\n"

" ...\n"

" OverflowError: n too large\n"

" \"\"\"\n"

"\n"

" import math\n"

" if not n >= 0:\n"

" raise ValueError(\"n must be >= 0\")\n"

" if math.floor(n) != n:\n"

" raise ValueError(\"n must be exact integer\")\n"

" if n+1 == n: # catch a value like 1e300\n"

" raise OverflowError(\"n too large\")\n"

" result = 1\n"

" factor = 2\n"

" while factor <= n:\n"

" result *= factor\n"

" factor += 1\n"

" return result\n"

"\n"

"\n"

"if __name__ == \"__main__\":\n"

" import doctest\n"

" doctest.testmod()"

msgstr ""

#: ../../library/doctest.rst:88

msgid ""

"If you run :file:`example.py` directly from the command line, :mod:`!"

"doctest` works its magic:"

msgstr ""

#: ../../library/doctest.rst:91

msgid ""

"$ python example.py\n"

"$"

msgstr ""

"$ python example.py\n"

"$"

#: ../../library/doctest.rst:96

msgid ""

"There's no output! That's normal, and it means all the examples worked. "

"Pass ``-v`` to the script, and :mod:`!doctest` prints a detailed log of what "

"it's trying, and prints a summary at the end:"

msgstr ""

#: ../../library/doctest.rst:100

msgid ""

"$ python example.py -v\n"

"Trying:\n"

" factorial(5)\n"

"Expecting:\n"

" 120\n"

"ok\n"

"Trying:\n"

" [factorial(n) for n in range(6)]\n"

"Expecting:\n"

" [1, 1, 2, 6, 24, 120]\n"

"ok"

msgstr ""

"$ python example.py -v\n"

"Trying:\n"

" factorial(5)\n"

"Expecting:\n"

" 120\n"

"ok\n"

"Trying:\n"

" [factorial(n) for n in range(6)]\n"

"Expecting:\n"

" [1, 1, 2, 6, 24, 120]\n"

"ok"

#: ../../library/doctest.rst:114

msgid "And so on, eventually ending with:"

msgstr ""

#: ../../library/doctest.rst:116

msgid ""

"Trying:\n"

" factorial(1e100)\n"

"Expecting:\n"

" Traceback (most recent call last):\n"

" ...\n"

" OverflowError: n too large\n"

"ok\n"

"2 items passed all tests:\n"

" 1 test in __main__\n"

" 6 tests in __main__.factorial\n"

"7 tests in 2 items.\n"

"7 passed.\n"

"Test passed.\n"

"$"

msgstr ""

"Trying:\n"

" factorial(1e100)\n"

"Expecting:\n"

" Traceback (most recent call last):\n"

" ...\n"

" OverflowError: n too large\n"

"ok\n"

"2 items passed all tests:\n"

" 1 test in __main__\n"

" 6 tests in __main__.factorial\n"

"7 tests in 2 items.\n"

"7 passed.\n"

"Test passed.\n"

"$"

#: ../../library/doctest.rst:133

msgid ""

"That's all you need to know to start making productive use of :mod:`!"

"doctest`! Jump in. The following sections provide full details. Note that "

"there are many examples of doctests in the standard Python test suite and "

"libraries. Especially useful examples can be found in the standard test "

"file :file:`Lib/test/test_doctest/test_doctest.py`."

msgstr ""

#: ../../library/doctest.rst:139

msgid ""

"Output is colorized by default and can be :ref:`controlled using environment "

"variables <using-on-controlling-color>`."

msgstr ""

#: ../../library/doctest.rst:147

msgid "Simple Usage: Checking Examples in Docstrings"

msgstr ""

#: ../../library/doctest.rst:149

msgid ""

"The simplest way to start using doctest (but not necessarily the way you'll "

"continue to do it) is to end each module :mod:`!M` with::"

msgstr ""

#: ../../library/doctest.rst:152

msgid ""

"if __name__ == \"__main__\":\n"

" import doctest\n"

" doctest.testmod()"

msgstr ""

"if __name__ == \"__main__\":\n"

" import doctest\n"

" doctest.testmod()"

#: ../../library/doctest.rst:156

msgid ":mod:`!doctest` then examines docstrings in module :mod:`!M`."

msgstr ""

#: ../../library/doctest.rst:158

msgid ""

"Running the module as a script causes the examples in the docstrings to get "

"executed and verified::"

msgstr ""

#: ../../library/doctest.rst:161

msgid "python M.py"

msgstr "python M.py"

#: ../../library/doctest.rst:163

msgid ""

"This won't display anything unless an example fails, in which case the "

"failing example(s) and the cause(s) of the failure(s) are printed to stdout, "

"and the final line of output is ``***Test Failed*** N failures.``, where *N* "

"is the number of examples that failed."

msgstr ""

#: ../../library/doctest.rst:168

msgid "Run it with the ``-v`` switch instead::"

msgstr ""

#: ../../library/doctest.rst:170

msgid "python M.py -v"

msgstr "python M.py -v"

#: ../../library/doctest.rst:172

msgid ""

"and a detailed report of all examples tried is printed to standard output, "

"along with assorted summaries at the end."

msgstr ""

#: ../../library/doctest.rst:175

msgid ""

"You can force verbose mode by passing ``verbose=True`` to :func:`testmod`, "

"or prohibit it by passing ``verbose=False``. In either of those cases, :"

"data:`sys.argv` is not examined by :func:`testmod` (so passing ``-v`` or not "

"has no effect)."

msgstr ""

#: ../../library/doctest.rst:180

msgid ""

"There is also a command line shortcut for running :func:`testmod`, see "

"section :ref:`doctest-cli`."

msgstr ""

#: ../../library/doctest.rst:183

msgid ""

"For more information on :func:`testmod`, see section :ref:`doctest-basic-"

"api`."

msgstr ""

#: ../../library/doctest.rst:189

msgid "Simple Usage: Checking Examples in a Text File"

msgstr ""

#: ../../library/doctest.rst:191

msgid ""

"Another simple application of doctest is testing interactive examples in a "

"text file. This can be done with the :func:`testfile` function::"

msgstr ""

#: ../../library/doctest.rst:194

msgid ""

"import doctest\n"

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

msgstr ""

"import doctest\n"

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

#: ../../library/doctest.rst:197

msgid ""

"That short script executes and verifies any interactive Python examples "

"contained in the file :file:`example.txt`. The file content is treated as "

"if it were a single giant docstring; the file doesn't need to contain a "

"Python program! For example, perhaps :file:`example.txt` contains this:"

msgstr ""

#: ../../library/doctest.rst:202

msgid ""

"The ``example`` module\n"

"======================\n"

"\n"

"Using ``factorial``\n"

"-------------------\n"

"\n"

"This is an example text file in reStructuredText format. First import\n"

"``factorial`` from the ``example`` module:\n"

"\n"

" >>> from example import factorial\n"

"\n"

"Now use it:\n"

"\n"

" >>> factorial(6)\n"

" 120"

msgstr ""

"The ``example`` module\n"

"======================\n"

"\n"

"Using ``factorial``\n"

"-------------------\n"

"\n"

"This is an example text file in reStructuredText format. First import\n"

"``factorial`` from the ``example`` module:\n"

"\n"

" >>> from example import factorial\n"

"\n"

"Now use it:\n"

"\n"

" >>> factorial(6)\n"

" 120"

#: ../../library/doctest.rst:220

msgid ""

"Running ``doctest.testfile(\"example.txt\")`` then finds the error in this "

"documentation::"

msgstr ""

#: ../../library/doctest.rst:223

msgid ""

"File \"./example.txt\", line 14, in example.txt\n"

"Failed example:\n"

" factorial(6)\n"

"Expected:\n"

" 120\n"

"Got:\n"

" 720"

msgstr ""

"File \"./example.txt\", line 14, in example.txt\n"

"Failed example:\n"

" factorial(6)\n"

"Expected:\n"

" 120\n"

"Got:\n"

" 720"

#: ../../library/doctest.rst:231

msgid ""

"As with :func:`testmod`, :func:`testfile` won't display anything unless an "

"example fails. If an example does fail, then the failing example(s) and the "

"cause(s) of the failure(s) are printed to stdout, using the same format as :"

"func:`!testmod`."

msgstr ""

#: ../../library/doctest.rst:236

msgid ""

"By default, :func:`testfile` looks for files in the calling module's "

"directory. See section :ref:`doctest-basic-api` for a description of the "

"optional arguments that can be used to tell it to look for files in other "

"locations."

msgstr ""

#: ../../library/doctest.rst:240

msgid ""

"Like :func:`testmod`, :func:`testfile`'s verbosity can be set with the ``-"

"v`` command-line switch or with the optional keyword argument *verbose*."

msgstr ""

#: ../../library/doctest.rst:244

msgid ""

"There is also a command line shortcut for running :func:`testfile`, see "

"section :ref:`doctest-cli`."

msgstr ""

#: ../../library/doctest.rst:247

msgid ""

"For more information on :func:`testfile`, see section :ref:`doctest-basic-"

"api`."

msgstr ""

#: ../../library/doctest.rst:253

msgid "Command-line Usage"

msgstr "命令列用法"

#: ../../library/doctest.rst:255

msgid ""

"The :mod:`!doctest` module can be invoked as a script from the command line:"

msgstr "可以從命令列以腳本方式叫用 :mod:`!doctest` 模組："

#: ../../library/doctest.rst:257

msgid "python -m doctest [-v] [-o OPTION] [-f] file [file ...]"

msgstr "python -m doctest [-v] [-o OPTION] [-f] file [file ...]"

#: ../../library/doctest.rst:265

msgid ""

"Detailed report of all examples tried is printed to standard output, along "

"with assorted summaries at the end::"

msgstr ""

#: ../../library/doctest.rst:268

msgid "python -m doctest -v example.py"

msgstr "python -m doctest -v example.py"

#: ../../library/doctest.rst:270

msgid ""

"This will import :file:`example.py` as a standalone module and run :func:"

"`testmod` on it. Note that this may not work correctly if the file is part "

"of a package and imports other submodules from that package."

msgstr ""

#: ../../library/doctest.rst:274

msgid ""

"If the file name does not end with :file:`.py`, :mod:`!doctest` infers that "

"it must be run with :func:`testfile` instead::"

msgstr ""

#: ../../library/doctest.rst:277

msgid "python -m doctest -v example.txt"

msgstr "python -m doctest -v example.txt"

#: ../../library/doctest.rst:281

msgid ""

"Option flags control various aspects of doctest's behavior, see section :ref:"

"`doctest-options`."

msgstr ""

#: ../../library/doctest.rst:288

msgid "This is shorthand for ``-o FAIL_FAST``."

msgstr ""

#: ../../library/doctest.rst:296

msgid "How It Works"

msgstr "運作方式"

#: ../../library/doctest.rst:298

msgid ""

"This section examines in detail how doctest works: which docstrings it looks "

"at, how it finds interactive examples, what execution context it uses, how "

"it handles exceptions, and how option flags can be used to control its "

"behavior. This is the information that you need to know to write doctest "

"examples; for information about actually running doctest on these examples, "

"see the following sections."

msgstr ""

#: ../../library/doctest.rst:309

msgid "Which Docstrings Are Examined?"

msgstr ""

#: ../../library/doctest.rst:311

msgid ""

"The module docstring, and all function, class and method docstrings are "

"searched. Objects imported into the module are not searched."

msgstr ""

#: ../../library/doctest.rst:321

msgid ""

"In addition, there are cases when you want tests to be part of a module but "

"not part of the help text, which requires that the tests not be included in "

"the docstring. Doctest looks for a module-level variable called ``__test__`` "

"and uses it to locate other tests. If ``M.__test__`` exists, it must be a "

"dict, and each entry maps a (string) name to a function object, class "

"object, or string. Function and class object docstrings found from ``M."

"__test__`` are searched, and strings are treated as if they were "

"docstrings. In output, a key ``K`` in ``M.__test__`` appears with name ``M."

"__test__.K``."

msgstr ""

#: ../../library/doctest.rst:330

msgid "For example, place this block of code at the top of :file:`example.py`:"

msgstr ""

#: ../../library/doctest.rst:332

msgid ""

"__test__ = {\n"

" 'numbers': \"\"\"\n"

">>> factorial(6)\n"

"720\n"

"\n"

">>> [factorial(n) for n in range(6)]\n"

"[1, 1, 2, 6, 24, 120]\n"

"\"\"\"\n"

"}"

msgstr ""

"__test__ = {\n"

" 'numbers': \"\"\"\n"

">>> factorial(6)\n"

"720\n"

"\n"

">>> [factorial(n) for n in range(6)]\n"

"[1, 1, 2, 6, 24, 120]\n"

"\"\"\"\n"

"}"

#: ../../library/doctest.rst:344

msgid ""

"The value of ``example.__test__[\"numbers\"]`` will be treated as a "

"docstring and all the tests inside it will be run. It is important to note "

"that the value can be mapped to a function, class object, or module; if so, :"

"mod:`!doctest` searches them recursively for docstrings, which are then "

"scanned for tests."

msgstr ""

#: ../../library/doctest.rst:350

msgid ""

"Any classes found are recursively searched similarly, to test docstrings in "

"their contained methods and nested classes."

msgstr ""

#: ../../library/doctest.rst:355

msgid ""

"``doctest`` can only automatically discover classes and functions that are "

"defined at the module level or inside other classes."

msgstr ""

#: ../../library/doctest.rst:358

msgid ""

"Since nested classes and functions only exist when an outer function is "

"called, they cannot be discovered. Define them outside to make them visible."

msgstr ""

#: ../../library/doctest.rst:364

msgid "How are Docstring Examples Recognized?"

msgstr ""

#: ../../library/doctest.rst:366

msgid ""

"In most cases a copy-and-paste of an interactive console session works fine, "

"but doctest isn't trying to do an exact emulation of any specific Python "

"shell."

msgstr ""

#: ../../library/doctest.rst:371

msgid ""

">>> # comments are ignored\n"

">>> x = 12\n"

">>> x\n"

"12\n"

">>> if x == 13:\n"

"... print(\"yes\")\n"

"... else:\n"

"... print(\"no\")\n"

"... print(\"NO\")\n"

"... print(\"NO!!!\")\n"

"...\n"

"no\n"

"NO\n"

"NO!!!\n"

">>>"

msgstr ""

">>> # 註解會被忽略\n"

">>> x = 12\n"

">>> x\n"

"12\n"

">>> if x == 13:\n"

"... print(\"yes\")\n"

"... else:\n"

"... print(\"no\")\n"

"... print(\"NO\")\n"

"... print(\"NO!!!\")\n"

"...\n"

"no\n"

"NO\n"

"NO!!!\n"

">>>"

#: ../../library/doctest.rst:391

msgid ""

"Any expected output must immediately follow the final ``'>>> '`` or ``'... "

"'`` line containing the code, and the expected output (if any) extends to "

"the next ``'>>> '`` or all-whitespace line."

msgstr ""

#: ../../library/doctest.rst:395

msgid "The fine print:"

msgstr ""

#: ../../library/doctest.rst:397

msgid ""

"Expected output cannot contain an all-whitespace line, since such a line is "

"taken to signal the end of expected output. If expected output does contain "

"a blank line, put ``<BLANKLINE>`` in your doctest example each place a blank "

"line is expected."

msgstr ""

#: ../../library/doctest.rst:402

msgid ""

"All hard tab characters are expanded to spaces, using 8-column tab stops. "

"Tabs in output generated by the tested code are not modified. Because any "

"hard tabs in the sample output *are* expanded, this means that if the code "

"output includes hard tabs, the only way the doctest can pass is if the :"

"const:`NORMALIZE_WHITESPACE` option or :ref:`directive <doctest-directives>` "

"is in effect. Alternatively, the test can be rewritten to capture the output "

"and compare it to an expected value as part of the test. This handling of "

"tabs in the source was arrived at through trial and error, and has proven to "

"be the least error prone way of handling them. It is possible to use a "

"different algorithm for handling tabs by writing a custom :class:"

"`DocTestParser` class."

msgstr ""

#: ../../library/doctest.rst:414

msgid ""

"Output to stdout is captured, but not output to stderr (exception tracebacks "

"are captured via a different means)."

msgstr ""

#: ../../library/doctest.rst:417

msgid ""

"If you continue a line via backslashing in an interactive session, or for "

"any other reason use a backslash, you should use a raw docstring, which will "

"preserve your backslashes exactly as you type them::"

msgstr ""

#: ../../library/doctest.rst:421

msgid ""

">>> def f(x):\n"

"... r'''Backslashes in a raw docstring: m\\n'''\n"

"...\n"

">>> print(f.__doc__)\n"

"Backslashes in a raw docstring: m\\n"

msgstr ""

#: ../../library/doctest.rst:427

msgid ""

"Otherwise, the backslash will be interpreted as part of the string. For "

"example, the ``\\n`` above would be interpreted as a newline character. "

"Alternatively, you can double each backslash in the doctest version (and not "

"use a raw string)::"

msgstr ""

#: ../../library/doctest.rst:431

msgid ""

">>> def f(x):\n"

"... '''Backslashes in a raw docstring: m\\\\n'''\n"

"...\n"

">>> print(f.__doc__)\n"

"Backslashes in a raw docstring: m\\n"

msgstr ""

#: ../../library/doctest.rst:437

msgid "The starting column doesn't matter::"

msgstr ""

#: ../../library/doctest.rst:439

msgid ""

">>> assert \"Easy!\"\n"

" >>> import math\n"

" >>> math.floor(1.9)\n"

" 1"

msgstr ""

">>> assert \"Easy!\"\n"

" >>> import math\n"

" >>> math.floor(1.9)\n"

" 1"

#: ../../library/doctest.rst:444

msgid ""

"and as many leading whitespace characters are stripped from the expected "

"output as appeared in the initial ``'>>> '`` line that started the example."

msgstr ""

#: ../../library/doctest.rst:451

msgid "What's the Execution Context?"

msgstr ""

#: ../../library/doctest.rst:453

msgid ""

"By default, each time :mod:`!doctest` finds a docstring to test, it uses a "

"*shallow copy* of :mod:`!M`'s globals, so that running tests doesn't change "

"the module's real globals, and so that one test in :mod:`!M` can't leave "

"behind crumbs that accidentally allow another test to work. This means "

"examples can freely use any names defined at top-level in :mod:`!M`, and "

"names defined earlier in the docstring being run. Examples cannot see names "

"defined in other docstrings."

msgstr ""

#: ../../library/doctest.rst:461

msgid ""

"You can force use of your own dict as the execution context by passing "

"``globs=your_dict`` to :func:`testmod` or :func:`testfile` instead."

msgstr ""

#: ../../library/doctest.rst:468

msgid "What About Exceptions?"

msgstr ""

#: ../../library/doctest.rst:470

msgid ""

"No problem, provided that the traceback is the only output produced by the "

"example: just paste in the traceback. [#]_ Since tracebacks contain details "

"that are likely to change rapidly (for example, exact file paths and line "

"numbers), this is one case where doctest works hard to be flexible in what "

"it accepts."

msgstr ""

#: ../../library/doctest.rst:476

msgid "Simple example::"

msgstr "簡單範例： ::"

#: ../../library/doctest.rst:478

msgid ""

">>> [1, 2, 3].remove(42)\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 1, in <module>\n"

"ValueError: list.remove(x): x not in list"

msgstr ""

">>> [1, 2, 3].remove(42)\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 1, in <module>\n"

"ValueError: list.remove(x): x not in list"

#: ../../library/doctest.rst:483

msgid ""

"That doctest succeeds if :exc:`ValueError` is raised, with the ``list."

"remove(x): x not in list`` detail as shown."

msgstr ""

#: ../../library/doctest.rst:486

msgid ""

"The expected output for an exception must start with a traceback header, "

"which may be either of the following two lines, indented the same as the "

"first line of the example::"

msgstr ""

#: ../../library/doctest.rst:490

msgid ""

"Traceback (most recent call last):\n"

"Traceback (innermost last):"

msgstr ""

"Traceback (most recent call last):\n"

"Traceback (innermost last):"

#: ../../library/doctest.rst:493

msgid ""

"The traceback header is followed by an optional traceback stack, whose "

"contents are ignored by doctest. The traceback stack is typically omitted, "

"or copied verbatim from an interactive session."

msgstr ""

#: ../../library/doctest.rst:497

msgid ""

"The traceback stack is followed by the most interesting part: the line(s) "

"containing the exception type and detail. This is usually the last line of "

"a traceback, but can extend across multiple lines if the exception has a "

"multi-line detail::"

msgstr ""

#: ../../library/doctest.rst:502

msgid ""

">>> raise ValueError('multi\\n line\\ndetail')\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 1, in <module>\n"

"ValueError: multi\n"

" line\n"

"detail"

msgstr ""

">>> raise ValueError('multi\\n line\\ndetail')\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 1, in <module>\n"

"ValueError: multi\n"

" line\n"

"detail"

#: ../../library/doctest.rst:509

msgid ""

"The last three lines (starting with :exc:`ValueError`) are compared against "

"the exception's type and detail, and the rest are ignored."

msgstr ""

#: ../../library/doctest.rst:512

msgid ""

"Best practice is to omit the traceback stack, unless it adds significant "

"documentation value to the example. So the last example is probably better "

"as::"

msgstr ""

#: ../../library/doctest.rst:515

msgid ""

">>> raise ValueError('multi\\n line\\ndetail')\n"

"Traceback (most recent call last):\n"

" ...\n"

"ValueError: multi\n"

" line\n"

"detail"

msgstr ""

">>> raise ValueError('multi\\n line\\ndetail')\n"

"Traceback (most recent call last):\n"

" ...\n"

"ValueError: multi\n"

" line\n"

"detail"

#: ../../library/doctest.rst:522

msgid ""

"Note that tracebacks are treated very specially. In particular, in the "

"rewritten example, the use of ``...`` is independent of doctest's :const:"

"`ELLIPSIS` option. The ellipsis in that example could be left out, or could "

"just as well be three (or three hundred) commas or digits, or an indented "

"transcript of a Monty Python skit."

msgstr ""

#: ../../library/doctest.rst:528

msgid "Some details you should read once, but won't need to remember:"

msgstr ""

#: ../../library/doctest.rst:530

msgid ""

"Doctest can't guess whether your expected output came from an exception "

"traceback or from ordinary printing. So, e.g., an example that expects "

"``ValueError: 42 is prime`` will pass whether :exc:`ValueError` is actually "

"raised or if the example merely prints that traceback text. In practice, "

"ordinary output rarely begins with a traceback header line, so this doesn't "

"create real problems."

msgstr ""

#: ../../library/doctest.rst:537

msgid ""

"Each line of the traceback stack (if present) must be indented further than "

"the first line of the example, *or* start with a non-alphanumeric character. "

"The first line following the traceback header indented the same and starting "

"with an alphanumeric is taken to be the start of the exception detail. Of "

"course this does the right thing for genuine tracebacks."

msgstr ""

#: ../../library/doctest.rst:543

msgid ""

"When the :const:`IGNORE_EXCEPTION_DETAIL` doctest option is specified, "

"everything following the leftmost colon and any module information in the "

"exception name is ignored."

msgstr ""

#: ../../library/doctest.rst:547

msgid ""

"The interactive shell omits the traceback header line for some :exc:"

"`SyntaxError`\\ s. But doctest uses the traceback header line to "

"distinguish exceptions from non-exceptions. So in the rare case where you "

"need to test a :exc:`!SyntaxError` that omits the traceback header, you will "

"need to manually add the traceback header line to your test example."

msgstr ""

#: ../../library/doctest.rst:555

msgid ""

"For some exceptions, Python displays the position of the error using ``^`` "

"markers and tildes::"

msgstr ""

#: ../../library/doctest.rst:558

msgid ""

">>> 1 + None\n"

" File \"<stdin>\", line 1\n"

" 1 + None\n"

" ~~^~~~~~\n"

"TypeError: unsupported operand type(s) for +: 'int' and 'NoneType'"

msgstr ""

">>> 1 + None\n"

" File \"<stdin>\", line 1\n"

" 1 + None\n"

" ~~^~~~~~\n"

"TypeError: unsupported operand type(s) for +: 'int' and 'NoneType'"

#: ../../library/doctest.rst:564

msgid ""

"Since the lines showing the position of the error come before the exception "

"type and detail, they are not checked by doctest. For example, the "

"following test would pass, even though it puts the ``^`` marker in the wrong "

"location::"

msgstr ""

#: ../../library/doctest.rst:568

msgid ""

">>> 1 + None\n"

" File \"<stdin>\", line 1\n"

" 1 + None\n"

" ^~~~~~~~\n"

"TypeError: unsupported operand type(s) for +: 'int' and 'NoneType'"

msgstr ""

">>> 1 + None\n"

" File \"<stdin>\", line 1\n"

" 1 + None\n"

" ^~~~~~~~\n"

"TypeError: unsupported operand type(s) for +: 'int' and 'NoneType'"

#: ../../library/doctest.rst:579

msgid "Option Flags"

msgstr "可選旗標"

#: ../../library/doctest.rst:581

msgid ""

"A number of option flags control various aspects of doctest's behavior. "

"Symbolic names for the flags are supplied as module constants, which can be :"

"ref:`bitwise ORed <bitwise>` together and passed to various functions. The "

"names can also be used in :ref:`doctest directives <doctest-directives>`, "

"and may be passed to the doctest command line interface via the ``-o`` "

"option."

msgstr ""

#: ../../library/doctest.rst:587

msgid ""

"The first group of options define test semantics, controlling aspects of how "

"doctest decides whether actual output matches an example's expected output:"

msgstr ""

#: ../../library/doctest.rst:593

msgid ""

"By default, if an expected output block contains just ``1``, an actual "

"output block containing just ``1`` or just ``True`` is considered to be a "

"match, and similarly for ``0`` versus ``False``. When :const:"

"`DONT_ACCEPT_TRUE_FOR_1` is specified, neither substitution is allowed. The "

"default behavior caters to that Python changed the return type of many "

"functions from integer to boolean; doctests expecting \"little integer\" "

"output still work in these cases. This option will probably go away, but "

"not for several years."

msgstr ""

#: ../../library/doctest.rst:605

msgid ""

"By default, if an expected output block contains a line containing only the "

"string ``<BLANKLINE>``, then that line will match a blank line in the actual "

"output. Because a genuinely blank line delimits the expected output, this "

"is the only way to communicate that a blank line is expected. When :const:"

"`DONT_ACCEPT_BLANKLINE` is specified, this substitution is not allowed."

msgstr ""

#: ../../library/doctest.rst:614

msgid ""

"When specified, all sequences of whitespace (blanks and newlines) are "

"treated as equal. Any sequence of whitespace within the expected output "

"will match any sequence of whitespace within the actual output. By default, "

"whitespace must match exactly. :const:`NORMALIZE_WHITESPACE` is especially "

"useful when a line of expected output is very long, and you want to wrap it "

"across multiple lines in your source."

msgstr ""

#: ../../library/doctest.rst:625

msgid ""

"When specified, an ellipsis marker (``...``) in the expected output can "

"match any substring in the actual output. This includes substrings that "

"span line boundaries, and empty substrings, so it's best to keep usage of "

"this simple. Complicated uses can lead to the same kinds of \"oops, it "

"matched too much!\" surprises that ``.*`` is prone to in regular expressions."

msgstr ""

#: ../../library/doctest.rst:634

msgid ""

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

msgstr ""

#: ../../library/doctest.rst:638

msgid ""

"For example, an example expecting ``ValueError: 42`` will pass if the actual "

"exception raised is ``ValueError: 3*14``, but will fail if, say, a :exc:"

"`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:"

msgstr ""

#: ../../library/doctest.rst:646

msgid ""

">>> raise Exception('message')\n"

"Traceback (most recent call last):\n"

"Exception: message\n"

"\n"

">>> raise Exception('message')\n"

"Traceback (most recent call last):\n"

"builtins.Exception: message\n"

"\n"

">>> raise Exception('message')\n"

"Traceback (most recent call last):\n"

"__main__.Exception: message"

msgstr ""