unittest.po

# Copyright (C) 2001-2024, Python Software Foundation
# This file is distributed under the same license as the Python package.
#
# Translators:
# Liang-Bo Wang <me@liang2.tw>, 2016
# Liang-Bo Wang <me@liang2.tw>, 2016
# Jason <chairco@gmail.com>, 2016
msgid ""
msgstr ""
"Project-Id-Version: Python 3.13\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2024-09-23 07:52+0800\n"
"PO-Revision-Date: 2022-10-16 06:03+0800\n"
"Last-Translator: Adrian Liaw <adrianliaw2000@gmail.com>\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"
"X-Generator: Poedit 3.1.1\n"

#: ../../library/unittest.rst:2
msgid ":mod:`!unittest` --- Unit testing framework"
msgstr ":mod:`!unittest` --- 單元測試框架"

#: ../../library/unittest.rst:12
msgid "**Source code:** :source:`Lib/unittest/__init__.py`"
msgstr "**原始碼：**\\ :source:`Lib/unittest/__init__.py`"

#: ../../library/unittest.rst:16
msgid ""
"(If you are already familiar with the basic concepts of testing, you might "
"want to skip to :ref:`the list of assert methods <assert-methods>`.)"
msgstr ""
"（假如你已經熟悉相關基礎的測試概念，你可能會希望跳過以下段落，直接參考 :ref:"
"`assert 方法清單 <assert-methods>`。）"

#: ../../library/unittest.rst:19
msgid ""
"The :mod:`unittest` unit testing framework was originally inspired by JUnit "
"and has a similar flavor as major unit testing frameworks in other "
"languages.  It supports test automation, sharing of setup and shutdown code "
"for tests, aggregation of tests into collections, and independence of the "
"tests from the reporting framework."
msgstr ""
":mod:`unittest` 原生的單元測試框架最初由 JUnit 開發，和其他程式語言相似有主要"
"的單元測試框架。支援自動化測試，對測試分享安裝與關閉程式碼，集合所有匯總的測"
"試，並且獨立各個測試報告框架。"

#: ../../library/unittest.rst:25
msgid ""
"To achieve this, :mod:`unittest` supports some important concepts in an "
"object-oriented way:"
msgstr ":mod:`unittest` 用來作為實現支援一些重要的物件導向方法的概念："

#: ../../library/unittest.rst:28
msgid "test fixture"
msgstr "test fixture"

#: ../../library/unittest.rst:29
msgid ""
"A :dfn:`test fixture` represents the preparation needed to perform one or "
"more tests, and any associated cleanup actions.  This may involve, for "
"example, creating temporary or proxy databases, directories, or starting a "
"server process."
msgstr ""
"一個 :dfn:`test fixture` 代表執行一個或多個測試所需要的準備，以及其他相關清理"
"操作，例如可以是建立臨時性的或是代理用 (proxy) 資料庫、目錄、或是啟動一個伺服"
"器程序。"

#: ../../library/unittest.rst:34
msgid "test case"
msgstr "test case（測試用例）"

#: ../../library/unittest.rst:35
msgid ""
"A :dfn:`test case` is the individual unit of testing.  It checks for a "
"specific response to a particular set of inputs.  :mod:`unittest` provides a "
"base class, :class:`TestCase`, which may be used to create new test cases."
msgstr ""
"一個 :dfn:`test case` 是一個獨立的單元測試。這是用來確認一個特定設定的輸入的"
"特殊回饋。 :mod:`unittest` 提供一個基礎類別，類別 :class:`TestCase`，可以用來"
"建立一個新的測試條例。"

#: ../../library/unittest.rst:39
msgid "test suite"
msgstr "test suite（測試套件）"

#: ../../library/unittest.rst:40
msgid ""
"A :dfn:`test suite` is a collection of test cases, test suites, or both.  It "
"is used to aggregate tests that should be executed together."
msgstr ""
":dfn:`test suite` 是一個搜集測試條例，測試套件，或是兩者皆有。它需要一起被執"
"行並用來匯總測試。"

#: ../../library/unittest.rst:43
msgid "test runner"
msgstr "test runner（測試執行器）"

#: ../../library/unittest.rst:44
msgid ""
"A :dfn:`test runner` is a component which orchestrates the execution of "
"tests and provides the outcome to the user.  The runner may use a graphical "
"interface, a textual interface, or return a special value to indicate the "
"results of executing the tests."
msgstr ""
":dfn:`test runner` 是一個編排測試執行與提供結果給使用者的一個元件。執行器可以"
"使用圖形化介面，文字介面或是回傳一個特別值用來標示出執行測試的結果。"

#: ../../library/unittest.rst:52
msgid "Module :mod:`doctest`"
msgstr ":mod:`doctest` 模組"

#: ../../library/unittest.rst:53
msgid "Another test-support module with a very different flavor."
msgstr "另一個執行測試的模組，但使用不一樣的測試方法與規範。"

#: ../../library/unittest.rst:55
msgid ""
"`Simple Smalltalk Testing: With Patterns <https://web.archive.org/"
"web/20150315073817/http://www.xprogramming.com/testfram.htm>`_"
msgstr ""
"`Simple Smalltalk Testing: With Patterns <https://web.archive.org/"
"web/20150315073817/http://www.xprogramming.com/testfram.htm>`_"

#: ../../library/unittest.rst:56
msgid ""
"Kent Beck's original paper on testing frameworks using the pattern shared "
"by :mod:`unittest`."
msgstr "Kent Beck 的原始論文討論使用 :mod:`unittest` 這樣模式的測試框架。"

#: ../../library/unittest.rst:59
msgid "`pytest <https://docs.pytest.org/>`_"
msgstr "`pytest <https://docs.pytest.org/>`_"

#: ../../library/unittest.rst:60
msgid ""
"Third-party unittest framework with a lighter-weight syntax for writing "
"tests.  For example, ``assert func(10) == 42``."
msgstr ""
"第三方的單元測試框架，但在撰寫測試時使用更輕量的語法。例如： ``assert "
"func(10) == 42``。"

#: ../../library/unittest.rst:63
msgid ""
"`The Python Testing Tools Taxonomy <https://wiki.python.org/moin/"
"PythonTestingToolsTaxonomy>`_"
msgstr ""
"`The Python Testing Tools Taxonomy <https://wiki.python.org/moin/"
"PythonTestingToolsTaxonomy>`_"

#: ../../library/unittest.rst:64
msgid ""
"An extensive list of Python testing tools including functional testing "
"frameworks and mock object libraries."
msgstr ""
"一份詳細的 Python 測試工具列表，包含 functional testing 框架和mock object 函"
"式庫。"

#: ../../library/unittest.rst:67
msgid ""
"`Testing in Python Mailing List <http://lists.idyll.org/listinfo/testing-in-"
"python>`_"
msgstr ""
"`Testing in Python Mailing List <http://lists.idyll.org/listinfo/testing-in-"
"python>`_"

#: ../../library/unittest.rst:68
msgid ""
"A special-interest-group for discussion of testing, and testing tools, in "
"Python."
msgstr "一個專門興趣的群組用來討論 Python 中的測試方式與測試工具。"

#: ../../library/unittest.rst:71
msgid ""
"The script :file:`Tools/unittestgui/unittestgui.py` in the Python source "
"distribution is a GUI tool for test discovery and execution.  This is "
"intended largely for ease of use for those new to unit testing.  For "
"production environments it is recommended that tests be driven by a "
"continuous integration system such as `Buildbot <https://buildbot.net/>`_, "
"`Jenkins <https://www.jenkins.io/>`_, `GitHub Actions <https://github.com/"
"features/actions>`_, or `AppVeyor <https://www.appveyor.com/>`_."
msgstr ""

#: ../../library/unittest.rst:83
msgid "Basic example"
msgstr "簡單範例"

#: ../../library/unittest.rst:85
msgid ""
"The :mod:`unittest` module provides a rich set of tools for constructing and "
"running tests.  This section demonstrates that a small subset of the tools "
"suffice to meet the needs of most users."
msgstr ""
":mod:`unittest` 模組提供一系列豐富的工具用來建構與執行測試。本節將展示這一系"
"列工具中一部份，它們已能滿足大部份使用者需求。"

#: ../../library/unittest.rst:89
msgid "Here is a short script to test three string methods::"
msgstr "這是一段簡短的腳本用來測試 3 個字串方法： ::"

#: ../../library/unittest.rst:91
msgid ""
"import unittest\n"
"\n"
"class TestStringMethods(unittest.TestCase):\n"
"\n"
"    def test_upper(self):\n"
"        self.assertEqual('foo'.upper(), 'FOO')\n"
"\n"
"    def test_isupper(self):\n"
"        self.assertTrue('FOO'.isupper())\n"
"        self.assertFalse('Foo'.isupper())\n"
"\n"
"    def test_split(self):\n"
"        s = 'hello world'\n"
"        self.assertEqual(s.split(), ['hello', 'world'])\n"
"        # check that s.split fails when the separator is not a string\n"
"        with self.assertRaises(TypeError):\n"
"            s.split(2)\n"
"\n"
"if __name__ == '__main__':\n"
"    unittest.main()"
msgstr ""

#: ../../library/unittest.rst:113
msgid ""
"A testcase is created by subclassing :class:`unittest.TestCase`.  The three "
"individual tests are defined with methods whose names start with the letters "
"``test``.  This naming convention informs the test runner about which "
"methods represent tests."
msgstr ""
"測試用例 (testcase) 可以透過繼承 :class:`unittest.TestCase` 類別來建立。這裡"
"定義了三個獨立的物件方法，名稱皆以 ``test`` 開頭。這樣的命名方式能告知 test "
"runner 哪些物件方法為定義的測試。"

#: ../../library/unittest.rst:118
msgid ""
"The crux of each test is a call to :meth:`~TestCase.assertEqual` to check "
"for an expected result; :meth:`~TestCase.assertTrue` or :meth:`~TestCase."
"assertFalse` to verify a condition; or :meth:`~TestCase.assertRaises` to "
"verify that a specific exception gets raised.  These methods are used "
"instead of the :keyword:`assert` statement so the test runner can accumulate "
"all test results and produce a report."
msgstr ""
"每個測試的關鍵為呼叫 :meth:`~TestCase.assertEqual` 來確認是否為期望的結果； :"
"meth:`~TestCase.assertTrue` 或是 :meth:`~TestCase.assertFalse` 用來驗證一個條"
"件式； :meth:`~TestCase.assertRaises` 用來驗證是否觸發一個特定的 exception。"
"使用這些物件方法來取代 :keyword:`assert` 陳述句，將能使 test runner 收集所有"
"的測試結果並產生一個報表。"

#: ../../library/unittest.rst:125
msgid ""
"The :meth:`~TestCase.setUp` and :meth:`~TestCase.tearDown` methods allow you "
"to define instructions that will be executed before and after each test "
"method. They are covered in more detail in the section :ref:`organizing-"
"tests`."
msgstr ""

#: ../../library/unittest.rst:129
msgid ""
"The final block shows a simple way to run the tests. :func:`unittest.main` "
"provides a command-line interface to the test script.  When run from the "
"command line, the above script produces an output that looks like this::"
msgstr ""
"最後將顯示一個簡單的方法去執行測試 :func:`unittest.main` 提供一個命令執行列介"
"面測試腳本。當透過命令執行列執行，輸出結果將會像是： ::"

#: ../../library/unittest.rst:133
msgid ""
"...\n"
"----------------------------------------------------------------------\n"
"Ran 3 tests in 0.000s\n"
"\n"
"OK"
msgstr ""
"...\n"
"----------------------------------------------------------------------\n"
"Ran 3 tests in 0.000s\n"
"\n"
"OK"

#: ../../library/unittest.rst:139
msgid ""
"Passing the ``-v`` option to your test script will instruct :func:`unittest."
"main` to enable a higher level of verbosity, and produce the following "
"output::"
msgstr ""
"在測試時加入 ``-v`` 選項將指示 :func:`unittest.main` 提高 verbosity 層級，產"
"生以下的輸出： ::"

#: ../../library/unittest.rst:142
msgid ""
"test_isupper (__main__.TestStringMethods.test_isupper) ... ok\n"
"test_split (__main__.TestStringMethods.test_split) ... ok\n"
"test_upper (__main__.TestStringMethods.test_upper) ... ok\n"
"\n"
"----------------------------------------------------------------------\n"
"Ran 3 tests in 0.001s\n"
"\n"
"OK"
msgstr ""
"test_isupper (__main__.TestStringMethods.test_isupper) ... ok\n"
"test_split (__main__.TestStringMethods.test_split) ... ok\n"
"test_upper (__main__.TestStringMethods.test_upper) ... ok\n"
"\n"
"----------------------------------------------------------------------\n"
"Ran 3 tests in 0.001s\n"
"\n"
"OK"

#: ../../library/unittest.rst:151
msgid ""
"The above examples show the most commonly used :mod:`unittest` features "
"which are sufficient to meet many everyday testing needs.  The remainder of "
"the documentation explores the full feature set from first principles."
msgstr ""
"以上的例子顯示大多數使用 :mod:`unittest` 特徵足以滿足大多數日常測試的需求。接"
"下來第一部分文件的剩餘部分將繼續探索完整特徵設定。"

#: ../../library/unittest.rst:155
msgid ""
"The behavior of returning a value from a test method (other than the default "
"``None`` value), is now deprecated."
msgstr ""

#: ../../library/unittest.rst:163
msgid "Command-Line Interface"
msgstr "命令執行列介面 (Command-Line Interface)"

#: ../../library/unittest.rst:165
msgid ""
"The unittest module can be used from the command line to run tests from "
"modules, classes or even individual test methods::"
msgstr ""
"單元測試模組可以透過命令執行列執行測試模組，物件甚至個別的測試方法： ::"

#: ../../library/unittest.rst:168
msgid ""
"python -m unittest test_module1 test_module2\n"
"python -m unittest test_module.TestClass\n"
"python -m unittest test_module.TestClass.test_method"
msgstr ""
"python -m unittest test_module1 test_module2\n"
"python -m unittest test_module.TestClass\n"
"python -m unittest test_module.TestClass.test_method"

#: ../../library/unittest.rst:172
msgid ""
"You can pass in a list with any combination of module names, and fully "
"qualified class or method names."
msgstr "你可以通過一個串列與任何模組名稱的組合，完全符合類別與方法的名稱。"

#: ../../library/unittest.rst:175
msgid "Test modules can be specified by file path as well::"
msgstr "測試模組可以根據檔案路徑指定： ::"

#: ../../library/unittest.rst:177
msgid "python -m unittest tests/test_something.py"
msgstr "python -m unittest tests/test_something.py"

#: ../../library/unittest.rst:179
msgid ""
"This allows you to use the shell filename completion to specify the test "
"module. The file specified must still be importable as a module. The path is "
"converted to a module name by removing the '.py' and converting path "
"separators into '.'. If you want to execute a test file that isn't "
"importable as a module you should execute the file directly instead."
msgstr ""
"這允許你使用 shell 檔案名稱補完功能 (filename completion) 來指定測試模組。給"
"定的檔案路徑必須亦能被當作模組 import。此路徑轉換為模組名稱的方式為移除 '."
"py' 並將路徑分隔符 (path separator) 轉換成 '.'。 假如你的測試檔案無法被 "
"import 成模組，你應該直接執行該測試檔案。"

#: ../../library/unittest.rst:185
msgid ""
"You can run tests with more detail (higher verbosity) by passing in the -v "
"flag::"
msgstr ""
"通過增加 -v 的旗標數，可以在你執行測試時得到更多細節（更高的 verbosity）： ::"

#: ../../library/unittest.rst:187
msgid "python -m unittest -v test_module"
msgstr "python -m unittest -v test_module"

#: ../../library/unittest.rst:189
msgid ""
"When executed without arguments :ref:`unittest-test-discovery` is started::"
msgstr "若執行時不代任何引數，將執行 :ref:`unittest-test-discovery`： ::"

#: ../../library/unittest.rst:191
msgid "python -m unittest"
msgstr "python -m unittest"

#: ../../library/unittest.rst:193
msgid "For a list of all the command-line options::"
msgstr "列出所有命令列選項： ::"

#: ../../library/unittest.rst:195
msgid "python -m unittest -h"
msgstr "python -m unittest -h"

#: ../../library/unittest.rst:197
msgid ""
"In earlier versions it was only possible to run individual test methods and "
"not modules or classes."
msgstr "在早期的版本可以個別執行測試方法和不需要模組或是類別。"

#: ../../library/unittest.rst:203
msgid "Command-line options"
msgstr "命令列模式選項"

#: ../../library/unittest.rst:205
msgid ":program:`unittest` supports these command-line options:"
msgstr ":program:`unittest` 支援以下命令列選項："

#: ../../library/unittest.rst:211
msgid ""
"The standard output and standard error streams are buffered during the test "
"run. Output during a passing test is discarded. Output is echoed normally on "
"test fail or error and is added to the failure messages."
msgstr ""
"Standard output 與 standard error stream 將在測試執行被緩衝 (buffer)。這些輸"
"出在測試通過時被丟棄。若是測試錯誤或失則，這些輸出將會正常地被印出，並且被加"
"入至錯誤訊息中。"

#: ../../library/unittest.rst:217
msgid ""
":kbd:`Control-C` during the test run waits for the current test to end and "
"then reports all the results so far. A second :kbd:`Control-C` raises the "
"normal :exc:`KeyboardInterrupt` exception."
msgstr ""
":kbd:`Control-C` 測試執行過程中等待正確的測試結果並回報目前為止所有的測試結"
"果。第二個 :kbd:`Control-C` 拋出一般例外 :exc:`KeyboardInterrupt`。"

#: ../../library/unittest.rst:221
msgid ""
"See `Signal Handling`_ for the functions that provide this functionality."
msgstr "參照 `Signal Handling`_ 針對函式提供的功能。"

#: ../../library/unittest.rst:225
msgid "Stop the test run on the first error or failure."
msgstr "在第一次錯誤或是失敗停止執行測試。"

#: ../../library/unittest.rst:229
msgid ""
"Only run test methods and classes that match the pattern or substring. This "
"option may be used multiple times, in which case all test cases that match "
"any of the given patterns are included."
msgstr ""

#: ../../library/unittest.rst:233
msgid ""
"Patterns that contain a wildcard character (``*``) are matched against the "
"test name using :meth:`fnmatch.fnmatchcase`; otherwise simple case-sensitive "
"substring matching is used."
msgstr ""

#: ../../library/unittest.rst:237
msgid ""
"Patterns are matched against the fully qualified test method name as "
"imported by the test loader."
msgstr ""

#: ../../library/unittest.rst:240
msgid ""
"For example, ``-k foo`` matches ``foo_tests.SomeTest.test_something``, "
"``bar_tests.SomeTest.test_foo``, but not ``bar_tests.FooTest."
"test_something``."
msgstr ""

#: ../../library/unittest.rst:245
msgid "Show local variables in tracebacks."
msgstr "透過 traceback 顯示本地變數。"

#: ../../library/unittest.rst:249
msgid "Show the N slowest test cases (N=0 for all)."
msgstr ""

#: ../../library/unittest.rst:251
msgid "The command-line options ``-b``, ``-c`` and ``-f`` were added."
msgstr "增加命令列模式選項 ``-b`` 、 ``-c`` 與 ``-f``。"

#: ../../library/unittest.rst:254
msgid "The command-line option ``--locals``."
msgstr "命令列選項 ``--locals``。"

#: ../../library/unittest.rst:257
msgid "The command-line option ``-k``."
msgstr "命令列選項 ``-k``。"

#: ../../library/unittest.rst:260
msgid "The command-line option ``--durations``."
msgstr "命令列選項 ``--durations``。"

#: ../../library/unittest.rst:263
msgid ""
"The command line can also be used for test discovery, for running all of the "
"tests in a project or just a subset."
msgstr ""
"對執行所有的專案或是一個子集合測試，命令列模式可以可以被用來做測試探索。"

#: ../../library/unittest.rst:269
msgid "Test Discovery"
msgstr "Test Discovery（測試探索）"

#: ../../library/unittest.rst:273
msgid ""
"Unittest supports simple test discovery. In order to be compatible with test "
"discovery, all of the test files must be :ref:`modules <tut-modules>` or :"
"ref:`packages <tut-packages>` importable from the top-level directory of the "
"project (this means that their filenames must be valid :ref:`identifiers "
"<identifiers>`)."
msgstr ""
"單元測試支援簡單的 test discovery（測試探索）。為了相容於測試探索，所有的測試"
"檔案都要是\\ :ref:`模組 <tut-modules>`\\ 或是\\ :ref:`套件 <tut-packages>`，"
"並能從專案的最上層目錄中 import（代表它們的檔案名稱必須是有效的 :ref:"
"`identifiers <identifiers>`\\ ）。"

#: ../../library/unittest.rst:279
msgid ""
"Test discovery is implemented in :meth:`TestLoader.discover`, but can also "
"be used from the command line. The basic command-line usage is::"
msgstr ""
"Test discovery（測試探索）實作在 :meth:`TestLoader.discover`，但也可以被用於"
"命令列模式。基本的命令列模式用法如下： ::"

#: ../../library/unittest.rst:282
msgid ""
"cd project_directory\n"
"python -m unittest discover"
msgstr ""
"cd project_directory\n"
"python -m unittest discover"

#: ../../library/unittest.rst:287
msgid ""
"As a shortcut, ``python -m unittest`` is the equivalent of ``python -m "
"unittest discover``. If you want to pass arguments to test discovery the "
"``discover`` sub-command must be used explicitly."
msgstr ""
"``python -m unittest`` 作為捷徑，其功能相當於 ``python -m unittest "
"discover``。假如你想傳遞引數至探索測試的話，一定要明確地加入 ``discover`` 子"
"指令。"

#: ../../library/unittest.rst:291
msgid "The ``discover`` sub-command has the following options:"
msgstr "``discover`` 子命令有以下幾個選項："

#: ../../library/unittest.rst:297
msgid "Verbose output"
msgstr "詳細 (verbose) 輸出"

#: ../../library/unittest.rst:301
msgid "Directory to start discovery (``.`` default)"
msgstr "開始尋找的資料夾（預設為 ``.``\\ ）"

#: ../../library/unittest.rst:305
msgid "Pattern to match test files (``test*.py`` default)"
msgstr "匹配測試檔案的模式（預設為 ``test*.py``\\ ）"

#: ../../library/unittest.rst:309
msgid "Top level directory of project (defaults to start directory)"
msgstr "專案的最高階層目錄（預設為開始的資料夾）"

#: ../../library/unittest.rst:311
msgid ""
"The :option:`-s`, :option:`-p`, and :option:`-t` options can be passed in as "
"positional arguments in that order. The following two command lines are "
"equivalent::"
msgstr ""
":option:`-s`, :option:`-p`, 和 :option:`-t` 選項依照傳遞位置作為引數排序順"
"序。以下兩個命令列被視為等價： ::"

#: ../../library/unittest.rst:315
msgid ""
"python -m unittest discover -s project_directory -p \"*_test.py\"\n"
"python -m unittest discover project_directory \"*_test.py\""
msgstr ""
"python -m unittest discover -s project_directory -p \"*_test.py\"\n"
"python -m unittest discover project_directory \"*_test.py\""

#: ../../library/unittest.rst:318
msgid ""
"As well as being a path it is possible to pass a package name, for example "
"``myproject.subpackage.test``, as the start directory. The package name you "
"supply will then be imported and its location on the filesystem will be used "
"as the start directory."
msgstr ""

#: ../../library/unittest.rst:325
msgid ""
"Test discovery loads tests by importing them. Once test discovery has found "
"all the test files from the start directory you specify it turns the paths "
"into package names to import. For example :file:`foo/bar/baz.py` will be "
"imported as ``foo.bar.baz``."
msgstr ""

#: ../../library/unittest.rst:330
msgid ""
"If you have a package installed globally and attempt test discovery on a "
"different copy of the package then the import *could* happen from the wrong "
"place. If this happens test discovery will warn you and exit."
msgstr ""

#: ../../library/unittest.rst:334
msgid ""
"If you supply the start directory as a package name rather than a path to a "
"directory then discover assumes that whichever location it imports from is "
"the location you intended, so you will not get the warning."
msgstr ""

#: ../../library/unittest.rst:339
msgid ""
"Test modules and packages can customize test loading and discovery by "
"through the `load_tests protocol`_."
msgstr ""

#: ../../library/unittest.rst:342
msgid ""
"Test discovery supports :term:`namespace packages <namespace package>` for "
"the start directory. Note that you need to specify the top level directory "
"too (e.g. ``python -m unittest discover -s root/namespace -t root``)."
msgstr ""

#: ../../library/unittest.rst:348
msgid ""
":mod:`unittest` dropped the :term:`namespace packages <namespace package>` "
"support in Python 3.11. It has been broken since Python 3.7. Start directory "
"and subdirectories containing tests must be regular package that have "
"``__init__.py`` file."
msgstr ""

#: ../../library/unittest.rst:354
msgid ""
"Directories containing start directory still can be a namespace package. In "
"this case, you need to specify start directory as dotted package name, and "
"target directory explicitly. For example::"
msgstr ""

#: ../../library/unittest.rst:358
msgid ""
"# proj/  <-- current directory\n"
"#   namespace/\n"
"#     mypkg/\n"
"#       __init__.py\n"
"#       test_mypkg.py\n"
"\n"
"python -m unittest discover -s namespace.mypkg -t ."
msgstr ""
"# proj/  <-- current directory\n"
"#   namespace/\n"
"#     mypkg/\n"
"#       __init__.py\n"
"#       test_mypkg.py\n"
"\n"
"python -m unittest discover -s namespace.mypkg -t ."

#: ../../library/unittest.rst:370
msgid "Organizing test code"
msgstr ""

#: ../../library/unittest.rst:372
msgid ""
"The basic building blocks of unit testing are :dfn:`test cases` --- single "
"scenarios that must be set up and checked for correctness.  In :mod:"
"`unittest`, test cases are represented by :class:`unittest.TestCase` "
"instances. To make your own test cases you must write subclasses of :class:"
"`TestCase` or use :class:`FunctionTestCase`."
msgstr ""

#: ../../library/unittest.rst:378
msgid ""
"The testing code of a :class:`TestCase` instance should be entirely self "
"contained, such that it can be run either in isolation or in arbitrary "
"combination with any number of other test cases."
msgstr ""

#: ../../library/unittest.rst:382
msgid ""
"The simplest :class:`TestCase` subclass will simply implement a test method "
"(i.e. a method whose name starts with ``test``) in order to perform specific "
"testing code::"
msgstr ""

#: ../../library/unittest.rst:386
msgid ""
"import unittest\n"
"\n"
"class DefaultWidgetSizeTestCase(unittest.TestCase):\n"
"    def test_default_widget_size(self):\n"
"        widget = Widget('The widget')\n"
"        self.assertEqual(widget.size(), (50, 50))"
msgstr ""
"import unittest\n"
"\n"
"class DefaultWidgetSizeTestCase(unittest.TestCase):\n"
"    def test_default_widget_size(self):\n"
"        widget = Widget('The widget')\n"
"        self.assertEqual(widget.size(), (50, 50))"

#: ../../library/unittest.rst:393
msgid ""
"Note that in order to test something, we use one of the :ref:`assert\\* "
"methods <assert-methods>` provided by the :class:`TestCase` base class.  If "
"the test fails, an exception will be raised with an explanatory message, "
"and :mod:`unittest` will identify the test case as a :dfn:`failure`.  Any "
"other exceptions will be treated as :dfn:`errors`."
msgstr ""

#: ../../library/unittest.rst:399
msgid ""
"Tests can be numerous, and their set-up can be repetitive.  Luckily, we can "
"factor out set-up code by implementing a method called :meth:`~TestCase."
"setUp`, which the testing framework will automatically call for every single "
"test we run::"
msgstr ""

#: ../../library/unittest.rst:404
msgid ""
"import unittest\n"
"\n"
"class WidgetTestCase(unittest.TestCase):\n"
"    def setUp(self):\n"
"        self.widget = Widget('The widget')\n"
"\n"
"    def test_default_widget_size(self):\n"
"        self.assertEqual(self.widget.size(), (50,50),\n"
"                         'incorrect default size')\n"
"\n"
"    def test_widget_resize(self):\n"
"        self.widget.resize(100,150)\n"
"        self.assertEqual(self.widget.size(), (100,150),\n"
"                         'wrong size after resize')"
msgstr ""
"import unittest\n"
"\n"
"class WidgetTestCase(unittest.TestCase):\n"
"    def setUp(self):\n"
"        self.widget = Widget('The widget')\n"
"\n"
"    def test_default_widget_size(self):\n"
"        self.assertEqual(self.widget.size(), (50,50),\n"
"                         'incorrect default size')\n"
"\n"
"    def test_widget_resize(self):\n"
"        self.widget.resize(100,150)\n"
"        self.assertEqual(self.widget.size(), (100,150),\n"
"                         'wrong size after resize')"

#: ../../library/unittest.rst:420
msgid ""
"The order in which the various tests will be run is determined by sorting "
"the test method names with respect to the built-in ordering for strings."
msgstr ""

#: ../../library/unittest.rst:424
msgid ""
"If the :meth:`~TestCase.setUp` method raises an exception while the test is "
"running, the framework will consider the test to have suffered an error, and "
"the test method will not be executed."
msgstr ""

#: ../../library/unittest.rst:428
msgid ""
"Similarly, we can provide a :meth:`~TestCase.tearDown` method that tidies up "
"after the test method has been run::"
msgstr ""

#: ../../library/unittest.rst:431
msgid ""
"import unittest\n"
"\n"
"class WidgetTestCase(unittest.TestCase):\n"
"    def setUp(self):\n"
"        self.widget = Widget('The widget')\n"
"\n"
"    def tearDown(self):\n"
"        self.widget.dispose()"
msgstr ""
"import unittest\n"
"\n"
"class WidgetTestCase(unittest.TestCase):\n"
"    def setUp(self):\n"
"        self.widget = Widget('The widget')\n"
"\n"
"    def tearDown(self):\n"
"        self.widget.dispose()"

#: ../../library/unittest.rst:440
msgid ""
"If :meth:`~TestCase.setUp` succeeded, :meth:`~TestCase.tearDown` will be run "
"whether the test method succeeded or not."
msgstr ""

#: ../../library/unittest.rst:443
msgid ""
"Such a working environment for the testing code is called a :dfn:`test "
"fixture`.  A new TestCase instance is created as a unique test fixture used "
"to execute each individual test method.  Thus :meth:`~TestCase.setUp`, :meth:"
"`~TestCase.tearDown`, and :meth:`~TestCase.__init__` will be called once per "
"test."
msgstr ""

#: ../../library/unittest.rst:449
msgid ""
"It is recommended that you use TestCase implementations to group tests "
"together according to the features they test.  :mod:`unittest` provides a "
"mechanism for this: the :dfn:`test suite`, represented by :mod:`unittest`'s :"
"class:`TestSuite` class.  In most cases, calling :func:`unittest.main` will "
"do the right thing and collect all the module's test cases for you and "
"execute them."
msgstr ""

#: ../../library/unittest.rst:456
msgid ""
"However, should you want to customize the building of your test suite, you "
"can do it yourself::"
msgstr ""

#: ../../library/unittest.rst:459
msgid ""
"def suite():\n"
"    suite = unittest.TestSuite()\n"
"    suite.addTest(WidgetTestCase('test_default_widget_size'))\n"
"    suite.addTest(WidgetTestCase('test_widget_resize'))\n"
"    return suite\n"
"\n"
"if __name__ == '__main__':\n"
"    runner = unittest.TextTestRunner()\n"
"    runner.run(suite())"
msgstr ""
"def suite():\n"
"    suite = unittest.TestSuite()\n"
"    suite.addTest(WidgetTestCase('test_default_widget_size'))\n"
"    suite.addTest(WidgetTestCase('test_widget_resize'))\n"
"    return suite\n"
"\n"
"if __name__ == '__main__':\n"
"    runner = unittest.TextTestRunner()\n"
"    runner.run(suite())"

#: ../../library/unittest.rst:469
msgid ""
"You can place the definitions of test cases and test suites in the same "
"modules as the code they are to test (such as :file:`widget.py`), but there "
"are several advantages to placing the test code in a separate module, such "
"as :file:`test_widget.py`:"
msgstr ""

#: ../../library/unittest.rst:474
msgid "The test module can be run standalone from the command line."
msgstr ""

#: ../../library/unittest.rst:476
msgid "The test code can more easily be separated from shipped code."
msgstr ""

#: ../../library/unittest.rst:478
msgid ""
"There is less temptation to change test code to fit the code it tests "
"without a good reason."
msgstr ""

#: ../../library/unittest.rst:481
msgid ""
"Test code should be modified much less frequently than the code it tests."
msgstr ""

#: ../../library/unittest.rst:483
msgid "Tested code can be refactored more easily."
msgstr ""

#: ../../library/unittest.rst:485
msgid ""
"Tests for modules written in C must be in separate modules anyway, so why "
"not be consistent?"
msgstr ""

#: ../../library/unittest.rst:488
msgid ""
"If the testing strategy changes, there is no need to change the source code."
msgstr ""

#: ../../library/unittest.rst:494
msgid "Re-using old test code"
msgstr ""

#: ../../library/unittest.rst:496
msgid ""
"Some users will find that they have existing test code that they would like "
"to run from :mod:`unittest`, without converting every old test function to "
"a :class:`TestCase` subclass."
msgstr ""

#: ../../library/unittest.rst:500
msgid ""
"For this reason, :mod:`unittest` provides a :class:`FunctionTestCase` class. "
"This subclass of :class:`TestCase` can be used to wrap an existing test "
"function.  Set-up and tear-down functions can also be provided."
msgstr ""

#: ../../library/unittest.rst:504
msgid "Given the following test function::"
msgstr ""

#: ../../library/unittest.rst:506
msgid ""
"def testSomething():\n"
"    something = makeSomething()\n"
"    assert something.name is not None\n"
"    # ..."
msgstr ""
"def testSomething():\n"
"    something = makeSomething()\n"
"    assert something.name is not None\n"
"    # ..."

#: ../../library/unittest.rst:511
msgid ""
"one can create an equivalent test case instance as follows, with optional "
"set-up and tear-down methods::"
msgstr ""

#: ../../library/unittest.rst:514
msgid ""
"testcase = unittest.FunctionTestCase(testSomething,\n"
"                                     setUp=makeSomethingDB,\n"
"                                     tearDown=deleteSomethingDB)"
msgstr ""
"testcase = unittest.FunctionTestCase(testSomething,\n"
"                                     setUp=makeSomethingDB,\n"
"                                     tearDown=deleteSomethingDB)"

#: ../../library/unittest.rst:520
msgid ""
"Even though :class:`FunctionTestCase` can be used to quickly convert an "
"existing test base over to a :mod:`unittest`\\ -based system, this approach "
"is not recommended.  Taking the time to set up proper :class:`TestCase` "
"subclasses will make future test refactorings infinitely easier."
msgstr ""

#: ../../library/unittest.rst:525
msgid ""
"In some cases, the existing tests may have been written using the :mod:"
"`doctest` module.  If so, :mod:`doctest` provides a :class:`DocTestSuite` "
"class that can automatically build :class:`unittest.TestSuite` instances "
"from the existing :mod:`doctest`\\ -based tests."
msgstr ""

#: ../../library/unittest.rst:534
msgid "Skipping tests and expected failures"
msgstr ""

#: ../../library/unittest.rst:538
msgid ""
"Unittest supports skipping individual test methods and even whole classes of "
"tests.  In addition, it supports marking a test as an \"expected failure,\" "
"a test that is broken and will fail, but shouldn't be counted as a failure "
"on a :class:`TestResult`."
msgstr ""

#: ../../library/unittest.rst:543
msgid ""
"Skipping a test is simply a matter of using the :func:`skip` :term:"
"`decorator` or one of its conditional variants, calling :meth:`TestCase."
"skipTest` within a :meth:`~TestCase.setUp` or test method, or raising :exc:"
"`SkipTest` directly."
msgstr ""

#: ../../library/unittest.rst:547
msgid "Basic skipping looks like this::"
msgstr ""

#: ../../library/unittest.rst:549
msgid ""
"class MyTestCase(unittest.TestCase):\n"
"\n"
"    @unittest.skip(\"demonstrating skipping\")\n"
"    def test_nothing(self):\n"
"        self.fail(\"shouldn't happen\")\n"
"\n"
"    @unittest.skipIf(mylib.__version__ < (1, 3),\n"
"                     \"not supported in this library version\")\n"
"    def test_format(self):\n"
"        # Tests that work for only a certain version of the library.\n"
"        pass\n"
"\n"
"    @unittest.skipUnless(sys.platform.startswith(\"win\"), \"requires "
"Windows\")\n"
"    def test_windows_support(self):\n"
"        # windows specific testing code\n"
"        pass\n"
"\n"
"    def test_maybe_skipped(self):\n"
"        if not external_resource_available():\n"
"            self.skipTest(\"external resource not available\")\n"
"        # test code that depends on the external resource\n"
"        pass"
msgstr ""

#: ../../library/unittest.rst:572
msgid "This is the output of running the example above in verbose mode::"
msgstr ""

#: ../../library/unittest.rst:574
msgid ""
"test_format (__main__.MyTestCase.test_format) ... skipped 'not supported in "
"this library version'\n"
"test_nothing (__main__.MyTestCase.test_nothing) ... skipped 'demonstrating "
"skipping'\n"
"test_maybe_skipped (__main__.MyTestCase.test_maybe_skipped) ... skipped "
"'external resource not available'\n"
"test_windows_support (__main__.MyTestCase.test_windows_support) ... skipped "
"'requires Windows'\n"
"\n"
"----------------------------------------------------------------------\n"
"Ran 4 tests in 0.005s\n"
"\n"
"OK (skipped=4)"
msgstr ""

#: ../../library/unittest.rst:584
msgid "Classes can be skipped just like methods::"
msgstr ""

#: ../../library/unittest.rst:586
msgid ""
"@unittest.skip(\"showing class skipping\")\n"
"class MySkippedTestCase(unittest.TestCase):\n"
"    def test_not_run(self):\n"
"        pass"
msgstr ""

#: ../../library/unittest.rst:591
msgid ""
":meth:`TestCase.setUp` can also skip the test.  This is useful when a "
"resource that needs to be set up is not available."
msgstr ""

#: ../../library/unittest.rst:594
msgid "Expected failures use the :func:`expectedFailure` decorator. ::"
msgstr ""

#: ../../library/unittest.rst:596
msgid ""
"class ExpectedFailureTestCase(unittest.TestCase):\n"
"    @unittest.expectedFailure\n"
"    def test_fail(self):\n"
"        self.assertEqual(1, 0, \"broken\")"
msgstr ""
"class ExpectedFailureTestCase(unittest.TestCase):\n"
"    @unittest.expectedFailure\n"
"    def test_fail(self):\n"
"        self.assertEqual(1, 0, \"broken\")"

#: ../../library/unittest.rst:601
msgid ""
"It's easy to roll your own skipping decorators by making a decorator that "
"calls :func:`skip` on the test when it wants it to be skipped.  This "
"decorator skips the test unless the passed object has a certain attribute::"
msgstr ""

#: ../../library/unittest.rst:605
msgid ""
"def skipUnlessHasattr(obj, attr):\n"
"    if hasattr(obj, attr):\n"
"        return lambda func: func\n"
"    return unittest.skip(\"{!r} doesn't have {!r}\".format(obj, attr))"
msgstr ""
"def skipUnlessHasattr(obj, attr):\n"
"    if hasattr(obj, attr):\n"
"        return lambda func: func\n"
"    return unittest.skip(\"{!r} doesn't have {!r}\".format(obj, attr))"

#: ../../library/unittest.rst:610
msgid ""
"The following decorators and exception implement test skipping and expected "
"failures:"
msgstr ""

#: ../../library/unittest.rst:614
msgid ""
"Unconditionally skip the decorated test.  *reason* should describe why the "
"test is being skipped."
msgstr ""

#: ../../library/unittest.rst:619
msgid "Skip the decorated test if *condition* is true."
msgstr ""

#: ../../library/unittest.rst:623
msgid "Skip the decorated test unless *condition* is true."
msgstr ""

#: ../../library/unittest.rst:627
msgid ""
"Mark the test as an expected failure or error.  If the test fails or errors "
"in the test function itself (rather than in one of the :dfn:`test fixture` "
"methods) then it will be considered a success.  If the test passes, it will "
"be considered a failure."
msgstr ""

#: ../../library/unittest.rst:634
msgid "This exception is raised to skip a test."
msgstr ""

#: ../../library/unittest.rst:636
msgid ""
"Usually you can use :meth:`TestCase.skipTest` or one of the skipping "
"decorators instead of raising this directly."
msgstr ""

#: ../../library/unittest.rst:639
msgid ""
"Skipped tests will not have :meth:`~TestCase.setUp` or :meth:`~TestCase."
"tearDown` run around them. Skipped classes will not have :meth:`~TestCase."
"setUpClass` or :meth:`~TestCase.tearDownClass` run. Skipped modules will not "
"have :func:`setUpModule` or :func:`tearDownModule` run."
msgstr ""

#: ../../library/unittest.rst:647
msgid "Distinguishing test iterations using subtests"
msgstr ""

#: ../../library/unittest.rst:651
msgid ""
"When there are very small differences among your tests, for instance some "
"parameters, unittest allows you to distinguish them inside the body of a "
"test method using the :meth:`~TestCase.subTest` context manager."
msgstr ""

#: ../../library/unittest.rst:655
msgid "For example, the following test::"
msgstr "舉例來說，以下測試： ::"

#: ../../library/unittest.rst:657
msgid ""
"class NumbersTest(unittest.TestCase):\n"
"\n"
"    def test_even(self):\n"
"        \"\"\"\n"
"        Test that numbers between 0 and 5 are all even.\n"
"        \"\"\"\n"
"        for i in range(0, 6):\n"
"            with self.subTest(i=i):\n"
"                self.assertEqual(i % 2, 0)"
msgstr ""

#: ../../library/unittest.rst:667
msgid "will produce the following output::"
msgstr "會有以下輸出： ::"

#: ../../library/unittest.rst:669
msgid ""
"======================================================================\n"
"FAIL: test_even (__main__.NumbersTest.test_even) (i=1)\n"
"Test that numbers between 0 and 5 are all even.\n"
"----------------------------------------------------------------------\n"
"Traceback (most recent call last):\n"
"  File \"subtests.py\", line 11, in test_even\n"
"    self.assertEqual(i % 2, 0)\n"
"    ^^^^^^^^^^^^^^^^^^^^^^^^^^\n"
"AssertionError: 1 != 0\n"
"\n"
"======================================================================\n"
"FAIL: test_even (__main__.NumbersTest.test_even) (i=3)\n"
"Test that numbers between 0 and 5 are all even.\n"
"----------------------------------------------------------------------\n"
"Traceback (most recent call last):\n"
"  File \"subtests.py\", line 11, in test_even\n"
"    self.assertEqual(i % 2, 0)\n"
"    ^^^^^^^^^^^^^^^^^^^^^^^^^^\n"
"AssertionError: 1 != 0\n"
"\n"
"======================================================================\n"
"FAIL: test_even (__main__.NumbersTest.test_even) (i=5)\n"
"Test that numbers between 0 and 5 are all even.\n"
"----------------------------------------------------------------------\n"
"Traceback (most recent call last):\n"
"  File \"subtests.py\", line 11, in test_even\n"
"    self.assertEqual(i % 2, 0)\n"
"    ^^^^^^^^^^^^^^^^^^^^^^^^^^\n"
"AssertionError: 1 != 0"
msgstr ""
"======================================================================\n"
"FAIL: test_even (__main__.NumbersTest.test_even) (i=1)\n"
"Test that numbers between 0 and 5 are all even.\n"
"----------------------------------------------------------------------\n"
"Traceback (most recent call last):\n"
"  File \"subtests.py\", line 11, in test_even\n"
"    self.assertEqual(i % 2, 0)\n"
"    ^^^^^^^^^^^^^^^^^^^^^^^^^^\n"
"AssertionError: 1 != 0\n"
"\n"
"======================================================================\n"
"FAIL: test_even (__main__.NumbersTest.test_even) (i=3)\n"
"Test that numbers between 0 and 5 are all even.\n"
"----------------------------------------------------------------------\n"
"Traceback (most recent call last):\n"
"  File \"subtests.py\", line 11, in test_even\n"
"    self.assertEqual(i % 2, 0)\n"
"    ^^^^^^^^^^^^^^^^^^^^^^^^^^\n"
"AssertionError: 1 != 0\n"
"\n"
"======================================================================\n"
"FAIL: test_even (__main__.NumbersTest.test_even) (i=5)\n"
"Test that numbers between 0 and 5 are all even.\n"
"----------------------------------------------------------------------\n"
"Traceback (most recent call last):\n"
"  File \"subtests.py\", line 11, in test_even\n"
"    self.assertEqual(i % 2, 0)\n"
"    ^^^^^^^^^^^^^^^^^^^^^^^^^^\n"
"AssertionError: 1 != 0"

#: ../../library/unittest.rst:699
msgid ""
"Without using a subtest, execution would stop after the first failure, and "
"the error would be less easy to diagnose because the value of ``i`` wouldn't "
"be displayed::"
msgstr ""

#: ../../library/unittest.rst:703
msgid ""
"======================================================================\n"
"FAIL: test_even (__main__.NumbersTest.test_even)\n"
"----------------------------------------------------------------------\n"
"Traceback (most recent call last):\n"
"  File \"subtests.py\", line 32, in test_even\n"
"    self.assertEqual(i % 2, 0)\n"
"AssertionError: 1 != 0"
msgstr ""
"======================================================================\n"
"FAIL: test_even (__main__.NumbersTest.test_even)\n"
"----------------------------------------------------------------------\n"
"Traceback (most recent call last):\n"
"  File \"subtests.py\", line 32, in test_even\n"
"    self.assertEqual(i % 2, 0)\n"
"AssertionError: 1 != 0"

#: ../../library/unittest.rst:715
msgid "Classes and functions"
msgstr "類別與函式"

#: ../../library/unittest.rst:717
msgid "This section describes in depth the API of :mod:`unittest`."
msgstr ""

#: ../../library/unittest.rst:723
msgid "Test cases"
msgstr ""

#: ../../library/unittest.rst:727
msgid ""
"Instances of the :class:`TestCase` class represent the logical test units in "
"the :mod:`unittest` universe.  This class is intended to be used as a base "
"class, with specific tests being implemented by concrete subclasses.  This "
"class implements the interface needed by the test runner to allow it to "
"drive the tests, and methods that the test code can use to check for and "
"report various kinds of failure."
msgstr ""

#: ../../library/unittest.rst:734
msgid ""
"Each instance of :class:`TestCase` will run a single base method: the method "
"named *methodName*. In most uses of :class:`TestCase`, you will neither "
"change the *methodName* nor reimplement the default ``runTest()`` method."
msgstr ""

#: ../../library/unittest.rst:739
msgid ""
":class:`TestCase` can be instantiated successfully without providing a "
"*methodName*. This makes it easier to experiment with :class:`TestCase` from "
"the interactive interpreter."
msgstr ""

#: ../../library/unittest.rst:744
msgid ""
":class:`TestCase` instances provide three groups of methods: one group used "
"to run the test, another used by the test implementation to check conditions "
"and report failures, and some inquiry methods allowing information about the "
"test itself to be gathered."
msgstr ""

#: ../../library/unittest.rst:749
msgid "Methods in the first group (running the test) are:"
msgstr ""

#: ../../library/unittest.rst:753
msgid ""
"Method called to prepare the test fixture.  This is called immediately "
"before calling the test method; other than :exc:`AssertionError` or :exc:"
"`SkipTest`, any exception raised by this method will be considered an error "
"rather than a test failure. The default implementation does nothing."
msgstr ""

#: ../../library/unittest.rst:761
msgid ""
"Method called immediately after the test method has been called and the "
"result recorded.  This is called even if the test method raised an "
"exception, so the implementation in subclasses may need to be particularly "
"careful about checking internal state.  Any exception, other than :exc:"
"`AssertionError` or :exc:`SkipTest`, raised by this method will be "
"considered an additional error rather than a test failure (thus increasing "
"the total number of reported errors). This method will only be called if "
"the :meth:`setUp` succeeds, regardless of the outcome of the test method. "
"The default implementation does nothing."
msgstr ""

#: ../../library/unittest.rst:774
msgid ""
"A class method called before tests in an individual class are run. "
"``setUpClass`` is called with the class as the only argument and must be "
"decorated as a :func:`classmethod`::"
msgstr ""

#: ../../library/unittest.rst:778
msgid ""
"@classmethod\n"
"def setUpClass(cls):\n"
"    ..."
msgstr ""
"@classmethod\n"
"def setUpClass(cls):\n"
"    ..."

#: ../../library/unittest.rst:782 ../../library/unittest.rst:797
msgid "See `Class and Module Fixtures`_ for more details."
msgstr "更多細節請見 `Class and Module Fixtures`_。"

#: ../../library/unittest.rst:789
msgid ""
"A class method called after tests in an individual class have run. "
"``tearDownClass`` is called with the class as the only argument and must be "
"decorated as a :meth:`classmethod`::"
msgstr ""

#: ../../library/unittest.rst:793
msgid ""
"@classmethod\n"
"def tearDownClass(cls):\n"
"    ..."
msgstr ""
"@classmethod\n"
"def tearDownClass(cls):\n"
"    ..."

#: ../../library/unittest.rst:804
msgid ""
"Run the test, collecting the result into the :class:`TestResult` object "
"passed as *result*.  If *result* is omitted or ``None``, a temporary result "
"object is created (by calling the :meth:`defaultTestResult` method) and "
"used. The result object is returned to :meth:`run`'s caller."
msgstr ""

#: ../../library/unittest.rst:810
msgid ""
"The same effect may be had by simply calling the :class:`TestCase` instance."
msgstr ""

#: ../../library/unittest.rst:813
msgid ""
"Previous versions of ``run`` did not return the result. Neither did calling "
"an instance."
msgstr ""

#: ../../library/unittest.rst:819
msgid ""
"Calling this during a test method or :meth:`setUp` skips the current test.  "
"See :ref:`unittest-skipping` for more information."
msgstr ""

#: ../../library/unittest.rst:827
msgid ""
"Return a context manager which executes the enclosed code block as a "
"subtest.  *msg* and *params* are optional, arbitrary values which are "
"displayed whenever a subtest fails, allowing you to identify them clearly."
msgstr ""

#: ../../library/unittest.rst:832
msgid ""
"A test case can contain any number of subtest declarations, and they can be "
"arbitrarily nested."
msgstr ""

#: ../../library/unittest.rst:835
msgid "See :ref:`subtests` for more information."
msgstr "更多資訊請見 :ref:`subtests`。"

#: ../../library/unittest.rst:842
msgid ""
"Run the test without collecting the result.  This allows exceptions raised "
"by the test to be propagated to the caller, and can be used to support "
"running tests under a debugger."
msgstr ""

#: ../../library/unittest.rst:848
msgid ""
"The :class:`TestCase` class provides several assert methods to check for and "
"report failures.  The following table lists the most commonly used methods "
"(see the tables below for more assert methods):"
msgstr ""

#: ../../library/unittest.rst:853 ../../library/unittest.rst:974
#: ../../library/unittest.rst:1188 ../../library/unittest.rst:1312
msgid "Method"
msgstr "方法"

#: ../../library/unittest.rst:853 ../../library/unittest.rst:974
#: ../../library/unittest.rst:1188
msgid "Checks that"
msgstr ""

#: ../../library/unittest.rst:853 ../../library/unittest.rst:974
#: ../../library/unittest.rst:1188 ../../library/unittest.rst:1312
msgid "New in"
msgstr ""

#: ../../library/unittest.rst:855
msgid ":meth:`assertEqual(a, b) <TestCase.assertEqual>`"
msgstr ":meth:`assertEqual(a, b) <TestCase.assertEqual>`"

#: ../../library/unittest.rst:855
msgid "``a == b``"
msgstr "``a == b``"

#: ../../library/unittest.rst:858
msgid ":meth:`assertNotEqual(a, b) <TestCase.assertNotEqual>`"
msgstr ":meth:`assertNotEqual(a, b) <TestCase.assertNotEqual>`"

#: ../../library/unittest.rst:858
msgid "``a != b``"
msgstr "``a != b``"

#: ../../library/unittest.rst:861
msgid ":meth:`assertTrue(x) <TestCase.assertTrue>`"
msgstr ":meth:`assertTrue(x) <TestCase.assertTrue>`"

#: ../../library/unittest.rst:861
msgid "``bool(x) is True``"
msgstr "``bool(x) is True``"

#: ../../library/unittest.rst:864
msgid ":meth:`assertFalse(x) <TestCase.assertFalse>`"
msgstr ":meth:`assertFalse(x) <TestCase.assertFalse>`"

#: ../../library/unittest.rst:864
msgid "``bool(x) is False``"
msgstr "``bool(x) is False``"

#: ../../library/unittest.rst:867
msgid ":meth:`assertIs(a, b) <TestCase.assertIs>`"
msgstr ":meth:`assertIs(a, b) <TestCase.assertIs>`"

#: ../../library/unittest.rst:867
msgid "``a is b``"
msgstr "``a is b``"

#: ../../library/unittest.rst:867 ../../library/unittest.rst:870
#: ../../library/unittest.rst:873 ../../library/unittest.rst:876
#: ../../library/unittest.rst:879 ../../library/unittest.rst:882
#: ../../library/unittest.rst:979 ../../library/unittest.rst:1196
#: ../../library/unittest.rst:1199 ../../library/unittest.rst:1202
#: ../../library/unittest.rst:1205 ../../library/unittest.rst:1208
#: ../../library/unittest.rst:1314 ../../library/unittest.rst:1317
#: ../../library/unittest.rst:1320 ../../library/unittest.rst:1323
#: ../../library/unittest.rst:1326 ../../library/unittest.rst:1329
msgid "3.1"
msgstr "3.1"

#: ../../library/unittest.rst:870
msgid ":meth:`assertIsNot(a, b) <TestCase.assertIsNot>`"
msgstr ":meth:`assertIsNot(a, b) <TestCase.assertIsNot>`"

#: ../../library/unittest.rst:870
msgid "``a is not b``"
msgstr "``a is not b``"

#: ../../library/unittest.rst:873
msgid ":meth:`assertIsNone(x) <TestCase.assertIsNone>`"
msgstr ":meth:`assertIsNone(x) <TestCase.assertIsNone>`"

#: ../../library/unittest.rst:873
msgid "``x is None``"
msgstr "``x is None``"

#: ../../library/unittest.rst:876
msgid ":meth:`assertIsNotNone(x) <TestCase.assertIsNotNone>`"
msgstr ":meth:`assertIsNotNone(x) <TestCase.assertIsNotNone>`"

#: ../../library/unittest.rst:876
msgid "``x is not None``"
msgstr "``x is not None``"

#: ../../library/unittest.rst:879
msgid ":meth:`assertIn(a, b) <TestCase.assertIn>`"
msgstr ":meth:`assertIn(a, b) <TestCase.assertIn>`"

#: ../../library/unittest.rst:879
msgid "``a in b``"
msgstr "``a in b``"

#: ../../library/unittest.rst:882
msgid ":meth:`assertNotIn(a, b) <TestCase.assertNotIn>`"
msgstr ":meth:`assertNotIn(a, b) <TestCase.assertNotIn>`"

#: ../../library/unittest.rst:882
msgid "``a not in b``"
msgstr "``a not in b``"

#: ../../library/unittest.rst:885
msgid ":meth:`assertIsInstance(a, b) <TestCase.assertIsInstance>`"
msgstr ":meth:`assertIsInstance(a, b) <TestCase.assertIsInstance>`"

#: ../../library/unittest.rst:885
msgid "``isinstance(a, b)``"
msgstr "``isinstance(a, b)``"

#: ../../library/unittest.rst:885 ../../library/unittest.rst:888
#: ../../library/unittest.rst:982 ../../library/unittest.rst:985
#: ../../library/unittest.rst:1211 ../../library/unittest.rst:1214
msgid "3.2"
msgstr "3.2"

#: ../../library/unittest.rst:888
msgid ":meth:`assertNotIsInstance(a, b) <TestCase.assertNotIsInstance>`"
msgstr ":meth:`assertNotIsInstance(a, b) <TestCase.assertNotIsInstance>`"

#: ../../library/unittest.rst:888
msgid "``not isinstance(a, b)``"
msgstr "``not isinstance(a, b)``"

#: ../../library/unittest.rst:892
msgid ""
"All the assert methods accept a *msg* argument that, if specified, is used "
"as the error message on failure (see also :data:`longMessage`). Note that "
"the *msg* keyword argument can be passed to :meth:`assertRaises`, :meth:"
"`assertRaisesRegex`, :meth:`assertWarns`, :meth:`assertWarnsRegex` only when "
"they are used as a context manager."
msgstr ""

#: ../../library/unittest.rst:900
msgid ""
"Test that *first* and *second* are equal.  If the values do not compare "
"equal, the test will fail."
msgstr ""

#: ../../library/unittest.rst:903
msgid ""
"In addition, if *first* and *second* are the exact same type and one of "
"list, tuple, dict, set, frozenset or str or any type that a subclass "
"registers with :meth:`addTypeEqualityFunc` the type-specific equality "
"function will be called in order to generate a more useful default error "
"message (see also the :ref:`list of type-specific methods <type-specific-"
"methods>`)."
msgstr ""

#: ../../library/unittest.rst:910
msgid "Added the automatic calling of type-specific equality function."
msgstr ""

#: ../../library/unittest.rst:913
msgid ""
":meth:`assertMultiLineEqual` added as the default type equality function for "
"comparing strings."
msgstr ""

#: ../../library/unittest.rst:920
msgid ""
"Test that *first* and *second* are not equal.  If the values do compare "
"equal, the test will fail."
msgstr ""

#: ../../library/unittest.rst:926
msgid "Test that *expr* is true (or false)."
msgstr ""

#: ../../library/unittest.rst:928
msgid ""
"Note that this is equivalent to ``bool(expr) is True`` and not to ``expr is "
"True`` (use ``assertIs(expr, True)`` for the latter).  This method should "
"also be avoided when more specific methods are available (e.g. "
"``assertEqual(a, b)`` instead of ``assertTrue(a == b)``), because they "
"provide a better error message in case of failure."
msgstr ""

#: ../../library/unittest.rst:938
msgid "Test that *first* and *second* are (or are not) the same object."
msgstr ""

#: ../../library/unittest.rst:946
msgid "Test that *expr* is (or is not) ``None``."
msgstr ""

#: ../../library/unittest.rst:954
msgid "Test that *member* is (or is not) in *container*."
msgstr ""

#: ../../library/unittest.rst:962
msgid ""
"Test that *obj* is (or is not) an instance of *cls* (which can be a class or "
"a tuple of classes, as supported by :func:`isinstance`). To check for the "
"exact type, use :func:`assertIs(type(obj), cls) <assertIs>`."
msgstr ""

#: ../../library/unittest.rst:970
msgid ""
"It is also possible to check the production of exceptions, warnings, and log "
"messages using the following methods:"
msgstr ""

#: ../../library/unittest.rst:976
msgid ":meth:`assertRaises(exc, fun, *args, **kwds) <TestCase.assertRaises>`"
msgstr ":meth:`assertRaises(exc, fun, *args, **kwds) <TestCase.assertRaises>`"

#: ../../library/unittest.rst:976
msgid "``fun(*args, **kwds)`` raises *exc*"
msgstr "``fun(*args, **kwds)`` 會引發 *exc*"

#: ../../library/unittest.rst:979
msgid ""
":meth:`assertRaisesRegex(exc, r, fun, *args, **kwds) <TestCase."
"assertRaisesRegex>`"
msgstr ""
":meth:`assertRaisesRegex(exc, r, fun, *args, **kwds) <TestCase."
"assertRaisesRegex>`"

#: ../../library/unittest.rst:979
msgid "``fun(*args, **kwds)`` raises *exc* and the message matches regex *r*"
msgstr ""

#: ../../library/unittest.rst:982
msgid ":meth:`assertWarns(warn, fun, *args, **kwds) <TestCase.assertWarns>`"
msgstr ":meth:`assertWarns(warn, fun, *args, **kwds) <TestCase.assertWarns>`"

#: ../../library/unittest.rst:982
msgid "``fun(*args, **kwds)`` raises *warn*"
msgstr "``fun(*args, **kwds)`` 會引發 *warn*"

#: ../../library/unittest.rst:985
msgid ""
":meth:`assertWarnsRegex(warn, r, fun, *args, **kwds) <TestCase."
"assertWarnsRegex>`"
msgstr ""

#: ../../library/unittest.rst:985
msgid "``fun(*args, **kwds)`` raises *warn* and the message matches regex *r*"
msgstr ""

#: ../../library/unittest.rst:988
msgid ":meth:`assertLogs(logger, level) <TestCase.assertLogs>`"
msgstr ":meth:`assertLogs(logger, level) <TestCase.assertLogs>`"

#: ../../library/unittest.rst:988
msgid "The ``with`` block logs on *logger* with minimum *level*"
msgstr ""

#: ../../library/unittest.rst:988
msgid "3.4"
msgstr "3.4"

#: ../../library/unittest.rst:991
msgid ":meth:`assertNoLogs(logger, level) <TestCase.assertNoLogs>`"
msgstr ":meth:`assertNoLogs(logger, level) <TestCase.assertNoLogs>`"

#: ../../library/unittest.rst:991
msgid "The ``with`` block does not log on"
msgstr ""

#: ../../library/unittest.rst:992
msgid "*logger* with minimum *level*"
msgstr ""

#: ../../library/unittest.rst:991
msgid "3.10"
msgstr "3.10"

#: ../../library/unittest.rst:998
msgid ""
"Test that an exception is raised when *callable* is called with any "
"positional or keyword arguments that are also passed to :meth:"
"`assertRaises`.  The test passes if *exception* is raised, is an error if "
"another exception is raised, or fails if no exception is raised. To catch "
"any of a group of exceptions, a tuple containing the exception classes may "
"be passed as *exception*."
msgstr ""

#: ../../library/unittest.rst:1005
msgid ""
"If only the *exception* and possibly the *msg* arguments are given, return a "
"context manager so that the code under test can be written inline rather "
"than as a function::"
msgstr ""

#: ../../library/unittest.rst:1009
msgid ""
"with self.assertRaises(SomeException):\n"
"    do_something()"
msgstr ""
"with self.assertRaises(SomeException):\n"
"    do_something()"

#: ../../library/unittest.rst:1012
msgid ""
"When used as a context manager, :meth:`assertRaises` accepts the additional "
"keyword argument *msg*."
msgstr ""

#: ../../library/unittest.rst:1015
msgid ""
"The context manager will store the caught exception object in its :attr:"
"`exception` attribute.  This can be useful if the intention is to perform "
"additional checks on the exception raised::"
msgstr ""

#: ../../library/unittest.rst:1019
msgid ""
"with self.assertRaises(SomeException) as cm:\n"
"    do_something()\n"
"\n"
"the_exception = cm.exception\n"
"self.assertEqual(the_exception.error_code, 3)"
msgstr ""
"with self.assertRaises(SomeException) as cm:\n"
"    do_something()\n"
"\n"
"the_exception = cm.exception\n"
"self.assertEqual(the_exception.error_code, 3)"

#: ../../library/unittest.rst:1025
msgid "Added the ability to use :meth:`assertRaises` as a context manager."
msgstr "新增 :meth:`assertRaises` 可作為情境管理器使用的能力。"

#: ../../library/unittest.rst:1028
msgid "Added the :attr:`exception` attribute."
msgstr "新增 :attr:`exception` 屬性。"

#: ../../library/unittest.rst:1031 ../../library/unittest.rst:1057
#: ../../library/unittest.rst:1098 ../../library/unittest.rst:1121
msgid "Added the *msg* keyword argument when used as a context manager."
msgstr "新增作為情境管理器使用時的 *msg* 引數。"

#: ../../library/unittest.rst:1038
msgid ""
"Like :meth:`assertRaises` but also tests that *regex* matches on the string "
"representation of the raised exception.  *regex* may be a regular expression "
"object or a string containing a regular expression suitable for use by :func:"
"`re.search`.  Examples::"
msgstr ""

#: ../../library/unittest.rst:1043
msgid ""
"self.assertRaisesRegex(ValueError, \"invalid literal for.*XYZ'$\",\n"
"                       int, 'XYZ')"
msgstr ""
"self.assertRaisesRegex(ValueError, \"invalid literal for.*XYZ'$\",\n"
"                       int, 'XYZ')"

#: ../../library/unittest.rst:1046 ../../library/unittest.rst:1114
msgid "or::"
msgstr "或是： ::"

#: ../../library/unittest.rst:1048
msgid ""
"with self.assertRaisesRegex(ValueError, 'literal'):\n"
"   int('XYZ')"
msgstr ""
"with self.assertRaisesRegex(ValueError, 'literal'):\n"
"   int('XYZ')"

#: ../../library/unittest.rst:1051
msgid "Added under the name ``assertRaisesRegexp``."
msgstr "以 ``assertRaisesRegexp`` 為名新增。"

#: ../../library/unittest.rst:1054
msgid "Renamed to :meth:`assertRaisesRegex`."
msgstr "重新命名為 :meth:`assertRaisesRegex`。"

#: ../../library/unittest.rst:1064
msgid ""
"Test that a warning is triggered when *callable* is called with any "
"positional or keyword arguments that are also passed to :meth:"
"`assertWarns`.  The test passes if *warning* is triggered and fails if it "
"isn't.  Any exception is an error. To catch any of a group of warnings, a "
"tuple containing the warning classes may be passed as *warnings*."
msgstr ""

#: ../../library/unittest.rst:1071
msgid ""
"If only the *warning* and possibly the *msg* arguments are given, return a "
"context manager so that the code under test can be written inline rather "
"than as a function::"
msgstr ""

#: ../../library/unittest.rst:1075
msgid ""
"with self.assertWarns(SomeWarning):\n"
"    do_something()"
msgstr ""
"with self.assertWarns(SomeWarning):\n"
"    do_something()"

#: ../../library/unittest.rst:1078
msgid ""
"When used as a context manager, :meth:`assertWarns` accepts the additional "
"keyword argument *msg*."
msgstr ""

#: ../../library/unittest.rst:1081
msgid ""
"The context manager will store the caught warning object in its :attr:"
"`warning` attribute, and the source line which triggered the warnings in "
"the :attr:`filename` and :attr:`lineno` attributes. This can be useful if "
"the intention is to perform additional checks on the warning caught::"
msgstr ""

#: ../../library/unittest.rst:1087
msgid ""
"with self.assertWarns(SomeWarning) as cm:\n"
"    do_something()\n"
"\n"
"self.assertIn('myfile.py', cm.filename)\n"
"self.assertEqual(320, cm.lineno)"
msgstr ""
"with self.assertWarns(SomeWarning) as cm:\n"
"    do_something()\n"
"\n"
"self.assertIn('myfile.py', cm.filename)\n"
"self.assertEqual(320, cm.lineno)"

#: ../../library/unittest.rst:1093
msgid ""
"This method works regardless of the warning filters in place when it is "
"called."
msgstr ""

#: ../../library/unittest.rst:1105
msgid ""
"Like :meth:`assertWarns` but also tests that *regex* matches on the message "
"of the triggered warning.  *regex* may be a regular expression object or a "
"string containing a regular expression suitable for use by :func:`re."
"search`.  Example::"
msgstr ""

#: ../../library/unittest.rst:1110
msgid ""
"self.assertWarnsRegex(DeprecationWarning,\n"
"                      r'legacy_function\\(\\) is deprecated',\n"
"                      legacy_function, 'XYZ')"
msgstr ""
"self.assertWarnsRegex(DeprecationWarning,\n"
"                      r'legacy_function\\(\\) is deprecated',\n"
"                      legacy_function, 'XYZ')"

#: ../../library/unittest.rst:1116
msgid ""
"with self.assertWarnsRegex(RuntimeWarning, 'unsafe frobnicating'):\n"
"    frobnicate('/etc/passwd')"
msgstr ""
"with self.assertWarnsRegex(RuntimeWarning, 'unsafe frobnicating'):\n"
"    frobnicate('/etc/passwd')"

#: ../../library/unittest.rst:1126
msgid ""
"A context manager to test that at least one message is logged on the "
"*logger* or one of its children, with at least the given *level*."
msgstr ""

#: ../../library/unittest.rst:1130
msgid ""
"If given, *logger* should be a :class:`logging.Logger` object or a :class:"
"`str` giving the name of a logger.  The default is the root logger, which "
"will catch all messages that were not blocked by a non-propagating "
"descendent logger."
msgstr ""

#: ../../library/unittest.rst:1135 ../../library/unittest.rst:1176
msgid ""
"If given, *level* should be either a numeric logging level or its string "
"equivalent (for example either ``\"ERROR\"`` or :const:`logging.ERROR`).  "
"The default is :const:`logging.INFO`."
msgstr ""

#: ../../library/unittest.rst:1139
msgid ""
"The test passes if at least one message emitted inside the ``with`` block "
"matches the *logger* and *level* conditions, otherwise it fails."
msgstr ""

#: ../../library/unittest.rst:1142
msgid ""
"The object returned by the context manager is a recording helper which keeps "
"tracks of the matching log messages.  It has two attributes:"
msgstr ""

#: ../../library/unittest.rst:1148
msgid ""
"A list of :class:`logging.LogRecord` objects of the matching log messages."
msgstr ""

#: ../../library/unittest.rst:1153
msgid ""
"A list of :class:`str` objects with the formatted output of matching "
"messages."
msgstr ""

#: ../../library/unittest.rst:1156
msgid "Example::"
msgstr "範例： ::"

#: ../../library/unittest.rst:1158
msgid ""
"with self.assertLogs('foo', level='INFO') as cm:\n"
"    logging.getLogger('foo').info('first message')\n"
"    logging.getLogger('foo.bar').error('second message')\n"
"self.assertEqual(cm.output, ['INFO:foo:first message',\n"
"                             'ERROR:foo.bar:second message'])"
msgstr ""
"with self.assertLogs('foo', level='INFO') as cm:\n"
"    logging.getLogger('foo').info('first message')\n"
"    logging.getLogger('foo.bar').error('second message')\n"
"self.assertEqual(cm.output, ['INFO:foo:first message',\n"
"                             'ERROR:foo.bar:second message'])"

#: ../../library/unittest.rst:1168
msgid ""
"A context manager to test that no messages are logged on the *logger* or one "
"of its children, with at least the given *level*."
msgstr ""

#: ../../library/unittest.rst:1172
msgid ""
"If given, *logger* should be a :class:`logging.Logger` object or a :class:"
"`str` giving the name of a logger.  The default is the root logger, which "
"will catch all messages."
msgstr ""

#: ../../library/unittest.rst:1180
msgid ""
"Unlike :meth:`assertLogs`, nothing will be returned by the context manager."
msgstr ""

#: ../../library/unittest.rst:1185
msgid ""
"There are also other methods used to perform more specific checks, such as:"
msgstr ""

#: ../../library/unittest.rst:1190
msgid ":meth:`assertAlmostEqual(a, b) <TestCase.assertAlmostEqual>`"
msgstr ":meth:`assertAlmostEqual(a, b) <TestCase.assertAlmostEqual>`"

#: ../../library/unittest.rst:1190
msgid "``round(a-b, 7) == 0``"
msgstr "``round(a-b, 7) == 0``"

#: ../../library/unittest.rst:1193
msgid ":meth:`assertNotAlmostEqual(a, b) <TestCase.assertNotAlmostEqual>`"
msgstr ":meth:`assertNotAlmostEqual(a, b) <TestCase.assertNotAlmostEqual>`"

#: ../../library/unittest.rst:1193
msgid "``round(a-b, 7) != 0``"
msgstr "``round(a-b, 7) != 0``"

#: ../../library/unittest.rst:1196
msgid ":meth:`assertGreater(a, b) <TestCase.assertGreater>`"
msgstr ":meth:`assertGreater(a, b) <TestCase.assertGreater>`"

#: ../../library/unittest.rst:1196
msgid "``a > b``"
msgstr "``a > b``"

#: ../../library/unittest.rst:1199
msgid ":meth:`assertGreaterEqual(a, b) <TestCase.assertGreaterEqual>`"
msgstr ":meth:`assertGreaterEqual(a, b) <TestCase.assertGreaterEqual>`"

#: ../../library/unittest.rst:1199
msgid "``a >= b``"
msgstr "``a >= b``"

#: ../../library/unittest.rst:1202
msgid ":meth:`assertLess(a, b) <TestCase.assertLess>`"
msgstr ":meth:`assertLess(a, b) <TestCase.assertLess>`"

#: ../../library/unittest.rst:1202
msgid "``a < b``"
msgstr "``a < b``"

#: ../../library/unittest.rst:1205
msgid ":meth:`assertLessEqual(a, b) <TestCase.assertLessEqual>`"
msgstr ":meth:`assertLessEqual(a, b) <TestCase.assertLessEqual>`"

#: ../../library/unittest.rst:1205
msgid "``a <= b``"
msgstr "``a <= b``"

#: ../../library/unittest.rst:1208
msgid ":meth:`assertRegex(s, r) <TestCase.assertRegex>`"
msgstr ":meth:`assertRegex(s, r) <TestCase.assertRegex>`"

#: ../../library/unittest.rst:1208
msgid "``r.search(s)``"
msgstr "``r.search(s)``"

#: ../../library/unittest.rst:1211
msgid ":meth:`assertNotRegex(s, r) <TestCase.assertNotRegex>`"
msgstr ":meth:`assertNotRegex(s, r) <TestCase.assertNotRegex>`"

#: ../../library/unittest.rst:1211
msgid "``not r.search(s)``"
msgstr "``not r.search(s)``"

#: ../../library/unittest.rst:1214
msgid ":meth:`assertCountEqual(a, b) <TestCase.assertCountEqual>`"
msgstr ":meth:`assertCountEqual(a, b) <TestCase.assertCountEqual>`"

#: ../../library/unittest.rst:1214
msgid ""
"*a* and *b* have the same elements in the same number, regardless of their "
"order."
msgstr ""

#: ../../library/unittest.rst:1223
msgid ""
"Test that *first* and *second* are approximately (or not approximately) "
"equal by computing the difference, rounding to the given number of decimal "
"*places* (default 7), and comparing to zero.  Note that these methods round "
"the values to the given number of *decimal places* (i.e. like the :func:"
"`round` function) and not *significant digits*."
msgstr ""

#: ../../library/unittest.rst:1229
msgid ""
"If *delta* is supplied instead of *places* then the difference between "
"*first* and *second* must be less or equal to (or greater than) *delta*."
msgstr ""

#: ../../library/unittest.rst:1232
msgid "Supplying both *delta* and *places* raises a :exc:`TypeError`."
msgstr ""

#: ../../library/unittest.rst:1234
msgid ""
":meth:`assertAlmostEqual` automatically considers almost equal objects that "
"compare equal.  :meth:`assertNotAlmostEqual` automatically fails if the "
"objects compare equal.  Added the *delta* keyword argument."
msgstr ""

#: ../../library/unittest.rst:1245
msgid ""
"Test that *first* is respectively >, >=, < or <= than *second* depending on "
"the method name.  If not, the test will fail::"
msgstr ""

#: ../../library/unittest.rst:1248
msgid ""
">>> self.assertGreaterEqual(3, 4)\n"
"AssertionError: \"3\" unexpectedly not greater than or equal to \"4\""
msgstr ""
">>> self.assertGreaterEqual(3, 4)\n"
"AssertionError: \"3\" unexpectedly not greater than or equal to \"4\""

#: ../../library/unittest.rst:1257
msgid ""
"Test that a *regex* search matches (or does not match) *text*.  In case of "
"failure, the error message will include the pattern and the *text* (or the "
"pattern and the part of *text* that unexpectedly matched).  *regex* may be a "
"regular expression object or a string containing a regular expression "
"suitable for use by :func:`re.search`."
msgstr ""

#: ../../library/unittest.rst:1263
msgid "Added under the name ``assertRegexpMatches``."
msgstr "以 ``assertRegexpMatches`` 為名新增。"

#: ../../library/unittest.rst:1265
msgid ""
"The method ``assertRegexpMatches()`` has been renamed to :meth:`."
"assertRegex`."
msgstr "``assertRegexpMatches()`` 方法已重新命名為 :meth:`.assertRegex`。"

#: ../../library/unittest.rst:1268
msgid ":meth:`.assertNotRegex`."
msgstr ":meth:`.assertNotRegex`。"

#: ../../library/unittest.rst:1274
msgid ""
"Test that sequence *first* contains the same elements as *second*, "
"regardless of their order. When they don't, an error message listing the "
"differences between the sequences will be generated."
msgstr ""

#: ../../library/unittest.rst:1278
msgid ""
"Duplicate elements are *not* ignored when comparing *first* and *second*. It "
"verifies whether each element has the same count in both sequences. "
"Equivalent to: ``assertEqual(Counter(list(first)), Counter(list(second)))`` "
"but works with sequences of unhashable objects as well."
msgstr ""

#: ../../library/unittest.rst:1289
msgid ""
"The :meth:`assertEqual` method dispatches the equality check for objects of "
"the same type to different type-specific methods.  These methods are already "
"implemented for most of the built-in types, but it's also possible to "
"register new methods using :meth:`addTypeEqualityFunc`:"
msgstr ""

#: ../../library/unittest.rst:1296
msgid ""
"Registers a type-specific method called by :meth:`assertEqual` to check if "
"two objects of exactly the same *typeobj* (not subclasses) compare equal.  "
"*function* must take two positional arguments and a third msg=None keyword "
"argument just as :meth:`assertEqual` does.  It must raise :data:`self."
"failureException(msg) <failureException>` when inequality between the first "
"two parameters is detected -- possibly providing useful information and "
"explaining the inequalities in details in the error message."
msgstr ""

#: ../../library/unittest.rst:1307
msgid ""
"The list of type-specific methods automatically used by :meth:`~TestCase."
"assertEqual` are summarized in the following table.  Note that it's usually "
"not necessary to invoke these methods directly."
msgstr ""

#: ../../library/unittest.rst:1312
msgid "Used to compare"
msgstr ""

#: ../../library/unittest.rst:1314
msgid ":meth:`assertMultiLineEqual(a, b) <TestCase.assertMultiLineEqual>`"
msgstr ":meth:`assertMultiLineEqual(a, b) <TestCase.assertMultiLineEqual>`"

#: ../../library/unittest.rst:1314
msgid "strings"
msgstr "字串"

#: ../../library/unittest.rst:1317
msgid ":meth:`assertSequenceEqual(a, b) <TestCase.assertSequenceEqual>`"
msgstr ":meth:`assertSequenceEqual(a, b) <TestCase.assertSequenceEqual>`"

#: ../../library/unittest.rst:1317
msgid "sequences"
msgstr "序列"

#: ../../library/unittest.rst:1320
msgid ":meth:`assertListEqual(a, b) <TestCase.assertListEqual>`"
msgstr ":meth:`assertListEqual(a, b) <TestCase.assertListEqual>`"

#: ../../library/unittest.rst:1320
msgid "lists"
msgstr "串列"

#: ../../library/unittest.rst:1323
msgid ":meth:`assertTupleEqual(a, b) <TestCase.assertTupleEqual>`"
msgstr ":meth:`assertTupleEqual(a, b) <TestCase.assertTupleEqual>`"

#: ../../library/unittest.rst:1323
msgid "tuples"
msgstr "元組"

#: ../../library/unittest.rst:1326
msgid ":meth:`assertSetEqual(a, b) <TestCase.assertSetEqual>`"
msgstr ":meth:`assertSetEqual(a, b) <TestCase.assertSetEqual>`"

#: ../../library/unittest.rst:1326
msgid "sets or frozensets"
msgstr "集合或凍結集合"

#: ../../library/unittest.rst:1329
msgid ":meth:`assertDictEqual(a, b) <TestCase.assertDictEqual>`"
msgstr ":meth:`assertDictEqual(a, b) <TestCase.assertDictEqual>`"

#: ../../library/unittest.rst:1329
msgid "dicts"
msgstr "字典"

#: ../../library/unittest.rst:1337
msgid ""
"Test that the multiline string *first* is equal to the string *second*. When "
"not equal a diff of the two strings highlighting the differences will be "
"included in the error message. This method is used by default when comparing "
"strings with :meth:`assertEqual`."
msgstr ""

#: ../../library/unittest.rst:1347
msgid ""
"Tests that two sequences are equal.  If a *seq_type* is supplied, both "
"*first* and *second* must be instances of *seq_type* or a failure will be "
"raised.  If the sequences are different an error message is constructed that "
"shows the difference between the two."
msgstr ""

#: ../../library/unittest.rst:1352
msgid ""
"This method is not called directly by :meth:`assertEqual`, but it's used to "
"implement :meth:`assertListEqual` and :meth:`assertTupleEqual`."
msgstr ""

#: ../../library/unittest.rst:1362
msgid ""
"Tests that two lists or tuples are equal.  If not, an error message is "
"constructed that shows only the differences between the two.  An error is "
"also raised if either of the parameters are of the wrong type. These methods "
"are used by default when comparing lists or tuples with :meth:`assertEqual`."
msgstr ""

#: ../../library/unittest.rst:1373
msgid ""
"Tests that two sets are equal.  If not, an error message is constructed that "
"lists the differences between the sets.  This method is used by default when "
"comparing sets or frozensets with :meth:`assertEqual`."
msgstr ""

#: ../../library/unittest.rst:1377
msgid ""
"Fails if either of *first* or *second* does not have a :meth:`set."
"difference` method."
msgstr ""

#: ../../library/unittest.rst:1385
msgid ""
"Test that two dictionaries are equal.  If not, an error message is "
"constructed that shows the differences in the dictionaries. This method will "
"be used by default to compare dictionaries in calls to :meth:`assertEqual`."
msgstr ""

#: ../../library/unittest.rst:1396
msgid ""
"Finally the :class:`TestCase` provides the following methods and attributes:"
msgstr ""

#: ../../library/unittest.rst:1401
msgid ""
"Signals a test failure unconditionally, with *msg* or ``None`` for the error "
"message."
msgstr ""

#: ../../library/unittest.rst:1407
msgid ""
"This class attribute gives the exception raised by the test method.  If a "
"test framework needs to use a specialized exception, possibly to carry "
"additional information, it must subclass this exception in order to \"play "
"fair\" with the framework.  The initial value of this attribute is :exc:"
"`AssertionError`."
msgstr ""

#: ../../library/unittest.rst:1416
msgid ""
"This class attribute determines what happens when a custom failure message "
"is passed as the msg argument to an assertXYY call that fails. ``True`` is "
"the default value. In this case, the custom message is appended to the end "
"of the standard failure message. When set to ``False``, the custom message "
"replaces the standard message."
msgstr ""

#: ../../library/unittest.rst:1422
msgid ""
"The class setting can be overridden in individual test methods by assigning "
"an instance attribute, self.longMessage, to ``True`` or ``False`` before "
"calling the assert methods."
msgstr ""

#: ../../library/unittest.rst:1426
msgid "The class setting gets reset before each test call."
msgstr ""

#: ../../library/unittest.rst:1433
msgid ""
"This attribute controls the maximum length of diffs output by assert methods "
"that report diffs on failure. It defaults to 80*8 characters. Assert methods "
"affected by this attribute are :meth:`assertSequenceEqual` (including all "
"the sequence comparison methods that delegate to it), :meth:"
"`assertDictEqual` and :meth:`assertMultiLineEqual`."
msgstr ""

#: ../../library/unittest.rst:1440
msgid ""
"Setting ``maxDiff`` to ``None`` means that there is no maximum length of "
"diffs."
msgstr ""

#: ../../library/unittest.rst:1446
msgid ""
"Testing frameworks can use the following methods to collect information on "
"the test:"
msgstr ""

#: ../../library/unittest.rst:1452
msgid ""
"Return the number of tests represented by this test object.  For :class:"
"`TestCase` instances, this will always be ``1``."
msgstr ""

#: ../../library/unittest.rst:1458
msgid ""
"Return an instance of the test result class that should be used for this "
"test case class (if no other result instance is provided to the :meth:`run` "
"method)."
msgstr ""

#: ../../library/unittest.rst:1462
msgid ""
"For :class:`TestCase` instances, this will always be an instance of :class:"
"`TestResult`; subclasses of :class:`TestCase` should override this as "
"necessary."
msgstr ""

#: ../../library/unittest.rst:1469
msgid ""
"Return a string identifying the specific test case.  This is usually the "
"full name of the test method, including the module and class name."
msgstr ""

#: ../../library/unittest.rst:1475
msgid ""
"Returns a description of the test, or ``None`` if no description has been "
"provided.  The default implementation of this method returns the first line "
"of the test method's docstring, if available, or ``None``."
msgstr ""

#: ../../library/unittest.rst:1480
msgid ""
"In 3.1 this was changed to add the test name to the short description even "
"in the presence of a docstring.  This caused compatibility issues with "
"unittest extensions and adding the test name was moved to the :class:"
"`TextTestResult` in Python 3.2."
msgstr ""

#: ../../library/unittest.rst:1489
msgid ""
"Add a function to be called after :meth:`tearDown` to cleanup resources used "
"during the test. Functions will be called in reverse order to the order they "
"are added (:abbr:`LIFO (last-in, first-out)`).  They are called with any "
"arguments and keyword arguments passed into :meth:`addCleanup` when they are "
"added."
msgstr ""

#: ../../library/unittest.rst:1495
msgid ""
"If :meth:`setUp` fails, meaning that :meth:`tearDown` is not called, then "
"any cleanup functions added will still be called."
msgstr ""

#: ../../library/unittest.rst:1503
msgid ""
"Enter the supplied :term:`context manager`.  If successful, also add its :"
"meth:`~object.__exit__` method as a cleanup function by :meth:`addCleanup` "
"and return the result of the :meth:`~object.__enter__` method."
msgstr ""

#: ../../library/unittest.rst:1513
msgid ""
"This method is called unconditionally after :meth:`tearDown`, or after :meth:"
"`setUp` if :meth:`setUp` raises an exception."
msgstr ""

#: ../../library/unittest.rst:1516
msgid ""
"It is responsible for calling all the cleanup functions added by :meth:"
"`addCleanup`. If you need cleanup functions to be called *prior* to :meth:"
"`tearDown` then you can call :meth:`doCleanups` yourself."
msgstr ""

#: ../../library/unittest.rst:1521
msgid ""
":meth:`doCleanups` pops methods off the stack of cleanup functions one at a "
"time, so it can be called at any time."
msgstr ""

#: ../../library/unittest.rst:1529
msgid ""
"Add a function to be called after :meth:`tearDownClass` to cleanup resources "
"used during the test class. Functions will be called in reverse order to the "
"order they are added (:abbr:`LIFO (last-in, first-out)`). They are called "
"with any arguments and keyword arguments passed into :meth:`addClassCleanup` "
"when they are added."
msgstr ""

#: ../../library/unittest.rst:1535
msgid ""
"If :meth:`setUpClass` fails, meaning that :meth:`tearDownClass` is not "
"called, then any cleanup functions added will still be called."
msgstr ""

#: ../../library/unittest.rst:1543
msgid ""
"Enter the supplied :term:`context manager`.  If successful, also add its :"
"meth:`~object.__exit__` method as a cleanup function by :meth:"
"`addClassCleanup` and return the result of the :meth:`~object.__enter__` "
"method."
msgstr ""

#: ../../library/unittest.rst:1553
msgid ""
"This method is called unconditionally after :meth:`tearDownClass`, or after :"
"meth:`setUpClass` if :meth:`setUpClass` raises an exception."
msgstr ""

#: ../../library/unittest.rst:1556
msgid ""
"It is responsible for calling all the cleanup functions added by :meth:"
"`addClassCleanup`. If you need cleanup functions to be called *prior* to :"
"meth:`tearDownClass` then you can call :meth:`doClassCleanups` yourself."
msgstr ""

#: ../../library/unittest.rst:1561
msgid ""
":meth:`doClassCleanups` pops methods off the stack of cleanup functions one "
"at a time, so it can be called at any time."
msgstr ""

#: ../../library/unittest.rst:1569
msgid ""
"This class provides an API similar to :class:`TestCase` and also accepts "
"coroutines as test functions."
msgstr ""

#: ../../library/unittest.rst:1576
msgid ""
"The *loop_factory* passed to :class:`asyncio.Runner`. Override in subclasses "
"with :class:`asyncio.EventLoop` to avoid using the asyncio policy system."
msgstr ""

#: ../../library/unittest.rst:1584
msgid ""
"Method called to prepare the test fixture. This is called after :meth:"
"`setUp`. This is called immediately before calling the test method; other "
"than :exc:`AssertionError` or :exc:`SkipTest`, any exception raised by this "
"method will be considered an error rather than a test failure. The default "
"implementation does nothing."
msgstr ""

#: ../../library/unittest.rst:1592
msgid ""
"Method called immediately after the test method has been called and the "
"result recorded.  This is called before :meth:`tearDown`. This is called "
"even if the test method raised an exception, so the implementation in "
"subclasses may need to be particularly careful about checking internal "
"state.  Any exception, other than :exc:`AssertionError` or :exc:`SkipTest`, "
"raised by this method will be considered an additional error rather than a "
"test failure (thus increasing the total number of reported errors). This "
"method will only be called if the :meth:`asyncSetUp` succeeds, regardless of "
"the outcome of the test method. The default implementation does nothing."
msgstr ""

#: ../../library/unittest.rst:1604
msgid "This method accepts a coroutine that can be used as a cleanup function."
msgstr ""

#: ../../library/unittest.rst:1608
msgid ""
"Enter the supplied :term:`asynchronous context manager`.  If successful, "
"also add its :meth:`~object.__aexit__` method as a cleanup function by :meth:"
"`addAsyncCleanup` and return the result of the :meth:`~object.__aenter__` "
"method."
msgstr ""

#: ../../library/unittest.rst:1618
msgid ""
"Sets up a new event loop to run the test, collecting the result into the :"
"class:`TestResult` object passed as *result*.  If *result* is omitted or "
"``None``, a temporary result object is created (by calling the :meth:"
"`defaultTestResult` method) and used. The result object is returned to :meth:"
"`run`'s caller. At the end of the test all the tasks in the event loop are "
"cancelled."
msgstr ""

#: ../../library/unittest.rst:1626
msgid "An example illustrating the order::"
msgstr ""

#: ../../library/unittest.rst:1628
msgid ""
"from unittest import IsolatedAsyncioTestCase\n"
"\n"
"events = []\n"
"\n"
"\n"
"class Test(IsolatedAsyncioTestCase):\n"
"\n"
"\n"
"    def setUp(self):\n"
"        events.append(\"setUp\")\n"
"\n"
"    async def asyncSetUp(self):\n"
"        self._async_connection = await AsyncConnection()\n"
"        events.append(\"asyncSetUp\")\n"
"\n"
"    async def test_response(self):\n"
"        events.append(\"test_response\")\n"
"        response = await self._async_connection.get(\"https://example."
"com\")\n"
"        self.assertEqual(response.status_code, 200)\n"
"        self.addAsyncCleanup(self.on_cleanup)\n"
"\n"
"    def tearDown(self):\n"
"        events.append(\"tearDown\")\n"
"\n"
"    async def asyncTearDown(self):\n"
"        await self._async_connection.close()\n"
"        events.append(\"asyncTearDown\")\n"
"\n"
"    async def on_cleanup(self):\n"
"        events.append(\"cleanup\")\n"
"\n"
"if __name__ == \"__main__\":\n"
"    unittest.main()"
msgstr ""
"from unittest import IsolatedAsyncioTestCase\n"
"\n"
"events = []\n"
"\n"
"\n"
"class Test(IsolatedAsyncioTestCase):\n"
"\n"
"\n"
"    def setUp(self):\n"
"        events.append(\"setUp\")\n"
"\n"
"    async def asyncSetUp(self):\n"
"        self._async_connection = await AsyncConnection()\n"
"        events.append(\"asyncSetUp\")\n"
"\n"
"    async def test_response(self):\n"
"        events.append(\"test_response\")\n"
"        response = await self._async_connection.get(\"https://example."
"com\")\n"
"        self.assertEqual(response.status_code, 200)\n"
"        self.addAsyncCleanup(self.on_cleanup)\n"
"\n"
"    def tearDown(self):\n"
"        events.append(\"tearDown\")\n"
"\n"
"    async def asyncTearDown(self):\n"
"        await self._async_connection.close()\n"
"        events.append(\"asyncTearDown\")\n"
"\n"
"    async def on_cleanup(self):\n"
"        events.append(\"cleanup\")\n"
"\n"
"if __name__ == \"__main__\":\n"
"    unittest.main()"

#: ../../library/unittest.rst:1662
msgid ""
"After running the test, ``events`` would contain ``[\"setUp\", "
"\"asyncSetUp\", \"test_response\", \"asyncTearDown\", \"tearDown\", "
"\"cleanup\"]``."
msgstr ""

#: ../../library/unittest.rst:1667
msgid ""
"This class implements the portion of the :class:`TestCase` interface which "
"allows the test runner to drive the test, but does not provide the methods "
"which test code can use to check and report errors.  This is used to create "
"test cases using legacy test code, allowing it to be integrated into a :mod:"
"`unittest`-based test framework."
msgstr ""

#: ../../library/unittest.rst:1677
msgid "Grouping tests"
msgstr ""

#: ../../library/unittest.rst:1681
msgid ""
"This class represents an aggregation of individual test cases and test "
"suites. The class presents the interface needed by the test runner to allow "
"it to be run as any other test case.  Running a :class:`TestSuite` instance "
"is the same as iterating over the suite, running each test individually."
msgstr ""

#: ../../library/unittest.rst:1686
msgid ""
"If *tests* is given, it must be an iterable of individual test cases or "
"other test suites that will be used to build the suite initially. Additional "
"methods are provided to add test cases and suites to the collection later on."
msgstr ""

#: ../../library/unittest.rst:1690
msgid ""
":class:`TestSuite` objects behave much like :class:`TestCase` objects, "
"except they do not actually implement a test.  Instead, they are used to "
"aggregate tests into groups of tests that should be run together. Some "
"additional methods are available to add tests to :class:`TestSuite` "
"instances:"
msgstr ""

#: ../../library/unittest.rst:1698
msgid "Add a :class:`TestCase` or :class:`TestSuite` to the suite."
msgstr ""

#: ../../library/unittest.rst:1703
msgid ""
"Add all the tests from an iterable of :class:`TestCase` and :class:"
"`TestSuite` instances to this test suite."
msgstr ""

#: ../../library/unittest.rst:1706
msgid ""
"This is equivalent to iterating over *tests*, calling :meth:`addTest` for "
"each element."
msgstr ""

#: ../../library/unittest.rst:1709
msgid ":class:`TestSuite` shares the following methods with :class:`TestCase`:"
msgstr ""

#: ../../library/unittest.rst:1714
msgid ""
"Run the tests associated with this suite, collecting the result into the "
"test result object passed as *result*.  Note that unlike :meth:`TestCase."
"run`, :meth:`TestSuite.run` requires the result object to be passed in."
msgstr ""

#: ../../library/unittest.rst:1722
msgid ""
"Run the tests associated with this suite without collecting the result. This "
"allows exceptions raised by the test to be propagated to the caller and can "
"be used to support running tests under a debugger."
msgstr ""

#: ../../library/unittest.rst:1729
msgid ""
"Return the number of tests represented by this test object, including all "
"individual tests and sub-suites."
msgstr ""

#: ../../library/unittest.rst:1735
msgid ""
"Tests grouped by a :class:`TestSuite` are always accessed by iteration. "
"Subclasses can lazily provide tests by overriding :meth:`!__iter__`. Note "
"that this method may be called several times on a single suite (for example "
"when counting tests or comparing for equality) so the tests returned by "
"repeated iterations before :meth:`TestSuite.run` must be the same for each "
"call iteration. After :meth:`TestSuite.run`, callers should not rely on the "
"tests returned by this method unless the caller uses a subclass that "
"overrides :meth:`TestSuite._removeTestAtIndex` to preserve test references."
msgstr ""

#: ../../library/unittest.rst:1745
msgid ""
"In earlier versions the :class:`TestSuite` accessed tests directly rather "
"than through iteration, so overriding :meth:`!__iter__` wasn't sufficient "
"for providing tests."
msgstr ""

#: ../../library/unittest.rst:1750
msgid ""
"In earlier versions the :class:`TestSuite` held references to each :class:"
"`TestCase` after :meth:`TestSuite.run`. Subclasses can restore that behavior "
"by overriding :meth:`TestSuite._removeTestAtIndex`."
msgstr ""

#: ../../library/unittest.rst:1755
msgid ""
"In the typical usage of a :class:`TestSuite` object, the :meth:`run` method "
"is invoked by a :class:`TestRunner` rather than by the end-user test harness."
msgstr ""

#: ../../library/unittest.rst:1760
msgid "Loading and running tests"
msgstr ""

#: ../../library/unittest.rst:1764
msgid ""
"The :class:`TestLoader` class is used to create test suites from classes and "
"modules.  Normally, there is no need to create an instance of this class; "
"the :mod:`unittest` module provides an instance that can be shared as :data:"
"`unittest.defaultTestLoader`.  Using a subclass or instance, however, allows "
"customization of some configurable properties."
msgstr ""

#: ../../library/unittest.rst:1770
msgid ":class:`TestLoader` objects have the following attributes:"
msgstr ""

#: ../../library/unittest.rst:1775
msgid ""
"A list of the non-fatal errors encountered while loading tests. Not reset by "
"the loader at any point. Fatal errors are signalled by the relevant method "
"raising an exception to the caller. Non-fatal errors are also indicated by a "
"synthetic test that will raise the original error when run."
msgstr ""

#: ../../library/unittest.rst:1784
msgid ":class:`TestLoader` objects have the following methods:"
msgstr ""

#: ../../library/unittest.rst:1789
msgid ""
"Return a suite of all test cases contained in the :class:`TestCase`\\ -"
"derived :class:`testCaseClass`."
msgstr ""

#: ../../library/unittest.rst:1792
msgid ""
"A test case instance is created for each method named by :meth:"
"`getTestCaseNames`. By default these are the method names beginning with "
"``test``. If :meth:`getTestCaseNames` returns no methods, but the :meth:"
"`runTest` method is implemented, a single test case is created for that "
"method instead."
msgstr ""

#: ../../library/unittest.rst:1801
msgid ""
"Return a suite of all test cases contained in the given module. This method "
"searches *module* for classes derived from :class:`TestCase` and creates an "
"instance of the class for each test method defined for the class."
msgstr ""

#: ../../library/unittest.rst:1808
msgid ""
"While using a hierarchy of :class:`TestCase`\\ -derived classes can be "
"convenient in sharing fixtures and helper functions, defining test methods "
"on base classes that are not intended to be instantiated directly does not "
"play well with this method.  Doing so, however, can be useful when the "
"fixtures are different and defined in subclasses."
msgstr ""

#: ../../library/unittest.rst:1814
msgid ""
"If a module provides a ``load_tests`` function it will be called to load the "
"tests. This allows modules to customize test loading. This is the "
"`load_tests protocol`_.  The *pattern* argument is passed as the third "
"argument to ``load_tests``."
msgstr ""

#: ../../library/unittest.rst:1819
msgid "Support for ``load_tests`` added."
msgstr ""

#: ../../library/unittest.rst:1822
msgid "Support for a keyword-only argument *pattern* has been added."
msgstr ""

#: ../../library/unittest.rst:1825
msgid ""
"The undocumented and unofficial *use_load_tests* parameter has been removed."
msgstr ""

#: ../../library/unittest.rst:1832
msgid "Return a suite of all test cases given a string specifier."
msgstr ""

#: ../../library/unittest.rst:1834
msgid ""
"The specifier *name* is a \"dotted name\" that may resolve either to a "
"module, a test case class, a test method within a test case class, a :class:"
"`TestSuite` instance, or a callable object which returns a :class:`TestCase` "
"or :class:`TestSuite` instance.  These checks are applied in the order "
"listed here; that is, a method on a possible test case class will be picked "
"up as \"a test method within a test case class\", rather than \"a callable "
"object\"."
msgstr ""

#: ../../library/unittest.rst:1842
msgid ""
"For example, if you have a module :mod:`SampleTests` containing a :class:"
"`TestCase`\\ -derived class :class:`SampleTestCase` with three test methods "
"(:meth:`test_one`, :meth:`test_two`, and :meth:`test_three`), the specifier "
"``'SampleTests.SampleTestCase'`` would cause this method to return a suite "
"which will run all three test methods. Using the specifier ``'SampleTests."
"SampleTestCase.test_two'`` would cause it to return a test suite which will "
"run only the :meth:`test_two` test method. The specifier can refer to "
"modules and packages which have not been imported; they will be imported as "
"a side-effect."
msgstr ""

#: ../../library/unittest.rst:1852
msgid "The method optionally resolves *name* relative to the given *module*."
msgstr ""

#: ../../library/unittest.rst:1854
msgid ""
"If an :exc:`ImportError` or :exc:`AttributeError` occurs while traversing "
"*name* then a synthetic test that raises that error when run will be "
"returned. These errors are included in the errors accumulated by self.errors."
msgstr ""

#: ../../library/unittest.rst:1863
msgid ""
"Similar to :meth:`loadTestsFromName`, but takes a sequence of names rather "
"than a single name.  The return value is a test suite which supports all the "
"tests defined for each name."
msgstr ""

#: ../../library/unittest.rst:1870
msgid ""
"Return a sorted sequence of method names found within *testCaseClass*; this "
"should be a subclass of :class:`TestCase`."
msgstr ""

#: ../../library/unittest.rst:1876
msgid ""
"Find all the test modules by recursing into subdirectories from the "
"specified start directory, and return a TestSuite object containing them. "
"Only test files that match *pattern* will be loaded. (Using shell style "
"pattern matching.) Only module names that are importable (i.e. are valid "
"Python identifiers) will be loaded."
msgstr ""

#: ../../library/unittest.rst:1882
msgid ""
"All test modules must be importable from the top level of the project. If "
"the start directory is not the top level directory then *top_level_dir* must "
"be specified separately."
msgstr ""

#: ../../library/unittest.rst:1886
msgid ""
"If importing a module fails, for example due to a syntax error, then this "
"will be recorded as a single error and discovery will continue.  If the "
"import failure is due to :exc:`SkipTest` being raised, it will be recorded "
"as a skip instead of an error."
msgstr ""

#: ../../library/unittest.rst:1891
msgid ""
"If a package (a directory containing a file named :file:`__init__.py`) is "
"found, the package will be checked for a ``load_tests`` function. If this "
"exists then it will be called ``package.load_tests(loader, tests, "
"pattern)``. Test discovery takes care to ensure that a package is only "
"checked for tests once during an invocation, even if the load_tests function "
"itself calls ``loader.discover``."
msgstr ""

#: ../../library/unittest.rst:1899
msgid ""
"If ``load_tests`` exists then discovery does *not* recurse into the package, "
"``load_tests`` is responsible for loading all tests in the package."
msgstr ""

#: ../../library/unittest.rst:1903
msgid ""
"The pattern is deliberately not stored as a loader attribute so that "
"packages can continue discovery themselves."
msgstr ""

#: ../../library/unittest.rst:1906
msgid ""
"*top_level_dir* is stored internally, and used as a default to any nested "
"calls to ``discover()``. That is, if a package's ``load_tests`` calls "
"``loader.discover()``, it does not need to pass this argument."
msgstr ""

#: ../../library/unittest.rst:1910
msgid "*start_dir* can be a dotted module name as well as a directory."
msgstr ""

#: ../../library/unittest.rst:1914
msgid ""
"Modules that raise :exc:`SkipTest` on import are recorded as skips, not "
"errors."
msgstr ""

#: ../../library/unittest.rst:1918
msgid "*start_dir* can be a :term:`namespace packages <namespace package>`."
msgstr ""

#: ../../library/unittest.rst:1921
msgid ""
"Paths are sorted before being imported so that execution order is the same "
"even if the underlying file system's ordering is not dependent on file name."
msgstr ""

#: ../../library/unittest.rst:1926
msgid ""
"Found packages are now checked for ``load_tests`` regardless of whether "
"their path matches *pattern*, because it is impossible for a package name to "
"match the default pattern."
msgstr ""

#: ../../library/unittest.rst:1931
msgid ""
"*start_dir* can not be a :term:`namespace packages <namespace package>`. It "
"has been broken since Python 3.7 and Python 3.11 officially remove it."
msgstr ""

#: ../../library/unittest.rst:1935
msgid "*top_level_dir* is only stored for the duration of *discover* call."
msgstr ""

#: ../../library/unittest.rst:1939
msgid ""
"The following attributes of a :class:`TestLoader` can be configured either "
"by subclassing or assignment on an instance:"
msgstr ""

#: ../../library/unittest.rst:1945
msgid ""
"String giving the prefix of method names which will be interpreted as test "
"methods.  The default value is ``'test'``."
msgstr ""

#: ../../library/unittest.rst:1948
msgid ""
"This affects :meth:`getTestCaseNames` and all the ``loadTestsFrom*`` methods."
msgstr ""

#: ../../library/unittest.rst:1954
msgid ""
"Function to be used to compare method names when sorting them in :meth:"
"`getTestCaseNames` and all the ``loadTestsFrom*`` methods."
msgstr ""

#: ../../library/unittest.rst:1960
msgid ""
"Callable object that constructs a test suite from a list of tests. No "
"methods on the resulting object are needed.  The default value is the :class:"
"`TestSuite` class."
msgstr ""

#: ../../library/unittest.rst:1964 ../../library/unittest.rst:1977
msgid "This affects all the ``loadTestsFrom*`` methods."
msgstr ""

#: ../../library/unittest.rst:1968
msgid ""
"List of Unix shell-style wildcard test name patterns that test methods have "
"to match to be included in test suites (see ``-k`` option)."
msgstr ""

#: ../../library/unittest.rst:1971
msgid ""
"If this attribute is not ``None`` (the default), all test methods to be "
"included in test suites must match one of the patterns in this list. Note "
"that matches are always performed using :meth:`fnmatch.fnmatchcase`, so "
"unlike patterns passed to the ``-k`` option, simple substring patterns will "
"have to be converted using ``*`` wildcards."
msgstr ""

#: ../../library/unittest.rst:1984
msgid ""
"This class is used to compile information about which tests have succeeded "
"and which have failed."
msgstr ""

#: ../../library/unittest.rst:1987
msgid ""
"A :class:`TestResult` object stores the results of a set of tests.  The :"
"class:`TestCase` and :class:`TestSuite` classes ensure that results are "
"properly recorded; test authors do not need to worry about recording the "
"outcome of tests."
msgstr ""

#: ../../library/unittest.rst:1992
msgid ""
"Testing frameworks built on top of :mod:`unittest` may want access to the :"
"class:`TestResult` object generated by running a set of tests for reporting "
"purposes; a :class:`TestResult` instance is returned by the :meth:"
"`TestRunner.run` method for this purpose."
msgstr ""

#: ../../library/unittest.rst:1997
msgid ""
":class:`TestResult` instances have the following attributes that will be of "
"interest when inspecting the results of running a set of tests:"
msgstr ""

#: ../../library/unittest.rst:2003
msgid ""
"A list containing 2-tuples of :class:`TestCase` instances and strings "
"holding formatted tracebacks. Each tuple represents a test which raised an "
"unexpected exception."
msgstr ""

#: ../../library/unittest.rst:2009
msgid ""
"A list containing 2-tuples of :class:`TestCase` instances and strings "
"holding formatted tracebacks. Each tuple represents a test where a failure "
"was explicitly signalled using the :ref:`assert\\* methods <assert-methods>`."
msgstr ""

#: ../../library/unittest.rst:2015
msgid ""
"A list containing 2-tuples of :class:`TestCase` instances and strings "
"holding the reason for skipping the test."
msgstr ""

#: ../../library/unittest.rst:2022
msgid ""
"A list containing 2-tuples of :class:`TestCase` instances and strings "
"holding formatted tracebacks.  Each tuple represents an expected failure or "
"error of the test case."
msgstr ""

#: ../../library/unittest.rst:2028
msgid ""
"A list containing :class:`TestCase` instances that were marked as expected "
"failures, but succeeded."
msgstr ""

#: ../../library/unittest.rst:2033
msgid ""
"A list containing 2-tuples of test case names and floats representing the "
"elapsed time of each test which was run."
msgstr ""

#: ../../library/unittest.rst:2040
msgid ""
"Set to ``True`` when the execution of tests should stop by :meth:`stop`."
msgstr ""

#: ../../library/unittest.rst:2044
msgid "The total number of tests run so far."
msgstr ""

#: ../../library/unittest.rst:2048
msgid ""
"If set to true, ``sys.stdout`` and ``sys.stderr`` will be buffered in "
"between :meth:`startTest` and :meth:`stopTest` being called. Collected "
"output will only be echoed onto the real ``sys.stdout`` and ``sys.stderr`` "
"if the test fails or errors. Any output is also attached to the failure / "
"error message."
msgstr ""

#: ../../library/unittest.rst:2057
msgid ""
"If set to true :meth:`stop` will be called on the first failure or error, "
"halting the test run."
msgstr ""

#: ../../library/unittest.rst:2064
msgid "If set to true then local variables will be shown in tracebacks."
msgstr ""

#: ../../library/unittest.rst:2070
msgid ""
"Return ``True`` if all tests run so far have passed, otherwise returns "
"``False``."
msgstr ""

#: ../../library/unittest.rst:2073
msgid ""
"Returns ``False`` if there were any :attr:`unexpectedSuccesses` from tests "
"marked with the :func:`expectedFailure` decorator."
msgstr ""

#: ../../library/unittest.rst:2079
msgid ""
"This method can be called to signal that the set of tests being run should "
"be aborted by setting the :attr:`shouldStop` attribute to ``True``. :class:"
"`TestRunner` objects should respect this flag and return without running any "
"additional tests."
msgstr ""

#: ../../library/unittest.rst:2084
msgid ""
"For example, this feature is used by the :class:`TextTestRunner` class to "
"stop the test framework when the user signals an interrupt from the "
"keyboard.  Interactive tools which provide :class:`TestRunner` "
"implementations can use this in a similar manner."
msgstr ""

#: ../../library/unittest.rst:2089
msgid ""
"The following methods of the :class:`TestResult` class are used to maintain "
"the internal data structures, and may be extended in subclasses to support "
"additional reporting requirements.  This is particularly useful in building "
"tools which support interactive reporting while tests are being run."
msgstr ""

#: ../../library/unittest.rst:2097
msgid "Called when the test case *test* is about to be run."
msgstr ""

#: ../../library/unittest.rst:2101
msgid ""
"Called after the test case *test* has been executed, regardless of the "
"outcome."
msgstr ""

#: ../../library/unittest.rst:2106
msgid "Called once before any tests are executed."
msgstr ""

#: ../../library/unittest.rst:2113
msgid "Called once after all tests are executed."
msgstr ""

#: ../../library/unittest.rst:2120
msgid ""
"Called when the test case *test* raises an unexpected exception. *err* is a "
"tuple of the form returned by :func:`sys.exc_info`: ``(type, value, "
"traceback)``."
msgstr ""

#: ../../library/unittest.rst:2124
msgid ""
"The default implementation appends a tuple ``(test, formatted_err)`` to the "
"instance's :attr:`errors` attribute, where *formatted_err* is a formatted "
"traceback derived from *err*."
msgstr ""

#: ../../library/unittest.rst:2131
msgid ""
"Called when the test case *test* signals a failure. *err* is a tuple of the "
"form returned by :func:`sys.exc_info`: ``(type, value, traceback)``."
msgstr ""

#: ../../library/unittest.rst:2134
msgid ""
"The default implementation appends a tuple ``(test, formatted_err)`` to the "
"instance's :attr:`failures` attribute, where *formatted_err* is a formatted "
"traceback derived from *err*."
msgstr ""

#: ../../library/unittest.rst:2141
msgid "Called when the test case *test* succeeds."
msgstr ""

#: ../../library/unittest.rst:2143
msgid "The default implementation does nothing."
msgstr ""

#: ../../library/unittest.rst:2148
msgid ""
"Called when the test case *test* is skipped.  *reason* is the reason the "
"test gave for skipping."
msgstr ""

#: ../../library/unittest.rst:2151
msgid ""
"The default implementation appends a tuple ``(test, reason)`` to the "
"instance's :attr:`skipped` attribute."
msgstr ""

#: ../../library/unittest.rst:2157
msgid ""
"Called when the test case *test* fails or errors, but was marked with the :"
"func:`expectedFailure` decorator."
msgstr ""

#: ../../library/unittest.rst:2160
msgid ""
"The default implementation appends a tuple ``(test, formatted_err)`` to the "
"instance's :attr:`expectedFailures` attribute, where *formatted_err* is a "
"formatted traceback derived from *err*."
msgstr ""

#: ../../library/unittest.rst:2167
msgid ""
"Called when the test case *test* was marked with the :func:`expectedFailure` "
"decorator, but succeeded."
msgstr ""

#: ../../library/unittest.rst:2170
msgid ""
"The default implementation appends the test to the instance's :attr:"
"`unexpectedSuccesses` attribute."
msgstr ""

#: ../../library/unittest.rst:2176
msgid ""
"Called when a subtest finishes.  *test* is the test case corresponding to "
"the test method.  *subtest* is a custom :class:`TestCase` instance "
"describing the subtest."
msgstr ""

#: ../../library/unittest.rst:2180
msgid ""
"If *outcome* is :const:`None`, the subtest succeeded.  Otherwise, it failed "
"with an exception where *outcome* is a tuple of the form returned by :func:"
"`sys.exc_info`: ``(type, value, traceback)``."
msgstr ""

#: ../../library/unittest.rst:2184
msgid ""
"The default implementation does nothing when the outcome is a success, and "
"records subtest failures as normal failures."
msgstr ""

#: ../../library/unittest.rst:2191
msgid ""
"Called when the test case finishes.  *elapsed* is the time represented in "
"seconds, and it includes the execution of cleanup functions."
msgstr ""

#: ../../library/unittest.rst:2198
msgid ""
"A concrete implementation of :class:`TestResult` used by the :class:"
"`TextTestRunner`. Subclasses should accept ``**kwargs`` to ensure "
"compatibility as the interface changes."
msgstr ""

#: ../../library/unittest.rst:2204
msgid "Added the *durations* keyword parameter."
msgstr "新增 *durations* 關鍵字參數。"

#: ../../library/unittest.rst:2209
msgid ""
"Instance of the :class:`TestLoader` class intended to be shared.  If no "
"customization of the :class:`TestLoader` is needed, this instance can be "
"used instead of repeatedly creating new instances."
msgstr ""

#: ../../library/unittest.rst:2218
msgid ""
"A basic test runner implementation that outputs results to a stream. If "
"*stream* is ``None``, the default, :data:`sys.stderr` is used as the output "
"stream. This class has a few configurable parameters, but is essentially "
"very simple.  Graphical applications which run test suites should provide "
"alternate implementations. Such implementations should accept ``**kwargs`` "
"as the interface to construct runners changes when features are added to "
"unittest."
msgstr ""

#: ../../library/unittest.rst:2225
msgid ""
"By default this runner shows :exc:`DeprecationWarning`, :exc:"
"`PendingDeprecationWarning`, :exc:`ResourceWarning` and :exc:`ImportWarning` "
"even if they are :ref:`ignored by default <warning-ignored>`.  This behavior "
"can be overridden using Python's :option:`!-Wd` or :option:`!-Wa` options "
"(see :ref:`Warning control <using-on-warnings>`) and leaving *warnings* to "
"``None``."
msgstr ""

#: ../../library/unittest.rst:2233
msgid "Added the *warnings* parameter."
msgstr "新增 *warnings* 參數。"

#: ../../library/unittest.rst:2236
msgid ""
"The default stream is set to :data:`sys.stderr` at instantiation time rather "
"than import time."
msgstr ""

#: ../../library/unittest.rst:2240
msgid "Added the *tb_locals* parameter."
msgstr "新增 *tb_locals* 參數。"

#: ../../library/unittest.rst:2243
msgid "Added the *durations* parameter."
msgstr "新增 *durations* 參數。"

#: ../../library/unittest.rst:2248
msgid ""
"This method returns the instance of ``TestResult`` used by :meth:`run`. It "
"is not intended to be called directly, but can be overridden in subclasses "
"to provide a custom ``TestResult``."
msgstr ""

#: ../../library/unittest.rst:2252
msgid ""
"``_makeResult()`` instantiates the class or callable passed in the "
"``TextTestRunner`` constructor as the ``resultclass`` argument. It defaults "
"to :class:`TextTestResult` if no ``resultclass`` is provided. The result "
"class is instantiated with the following arguments::"
msgstr ""

#: ../../library/unittest.rst:2257
msgid "stream, descriptions, verbosity"
msgstr ""

#: ../../library/unittest.rst:2261
msgid ""
"This method is the main public interface to the ``TextTestRunner``. This "
"method takes a :class:`TestSuite` or :class:`TestCase` instance. A :class:"
"`TestResult` is created by calling :func:`_makeResult` and the test(s) are "
"run and the results printed to stdout."
msgstr ""

#: ../../library/unittest.rst:2272
msgid ""
"A command-line program that loads a set of tests from *module* and runs "
"them; this is primarily for making test modules conveniently executable. The "
"simplest use for this function is to include the following line at the end "
"of a test script::"
msgstr ""

#: ../../library/unittest.rst:2277
msgid ""
"if __name__ == '__main__':\n"
"    unittest.main()"
msgstr ""
"if __name__ == '__main__':\n"
"    unittest.main()"

#: ../../library/unittest.rst:2280
msgid ""
"You can run tests with more detailed information by passing in the verbosity "
"argument::"
msgstr ""

#: ../../library/unittest.rst:2283
msgid ""
"if __name__ == '__main__':\n"
"    unittest.main(verbosity=2)"
msgstr ""
"if __name__ == '__main__':\n"
"    unittest.main(verbosity=2)"

#: ../../library/unittest.rst:2286
msgid ""
"The *defaultTest* argument is either the name of a single test or an "
"iterable of test names to run if no test names are specified via *argv*.  If "
"not specified or ``None`` and no test names are provided via *argv*, all "
"tests found in *module* are run."
msgstr ""

#: ../../library/unittest.rst:2291
msgid ""
"The *argv* argument can be a list of options passed to the program, with the "
"first element being the program name.  If not specified or ``None``, the "
"values of :data:`sys.argv` are used."
msgstr ""

#: ../../library/unittest.rst:2295
msgid ""
"The *testRunner* argument can either be a test runner class or an already "
"created instance of it. By default ``main`` calls :func:`sys.exit` with an "
"exit code indicating success (0) or failure (1) of the tests run. An exit "
"code of 5 indicates that no tests were run or skipped."
msgstr ""

#: ../../library/unittest.rst:2300
msgid ""
"The *testLoader* argument has to be a :class:`TestLoader` instance, and "
"defaults to :data:`defaultTestLoader`."
msgstr ""

#: ../../library/unittest.rst:2303
msgid ""
"``main`` supports being used from the interactive interpreter by passing in "
"the argument ``exit=False``. This displays the result on standard output "
"without calling :func:`sys.exit`::"
msgstr ""

#: ../../library/unittest.rst:2307
msgid ""
">>> from unittest import main\n"
">>> main(module='test_module', exit=False)"
msgstr ""
">>> from unittest import main\n"
">>> main(module='test_module', exit=False)"

#: ../../library/unittest.rst:2310
msgid ""
"The *failfast*, *catchbreak* and *buffer* parameters have the same effect as "
"the same-name `command-line options`_."
msgstr ""

#: ../../library/unittest.rst:2313
msgid ""
"The *warnings* argument specifies the :ref:`warning filter <warning-filter>` "
"that should be used while running the tests.  If it's not specified, it will "
"remain ``None`` if a :option:`!-W` option is passed to :program:`python` "
"(see :ref:`Warning control <using-on-warnings>`), otherwise it will be set "
"to ``'default'``."
msgstr ""

#: ../../library/unittest.rst:2319
msgid ""
"Calling ``main`` returns an object with the ``result`` attribute that "
"contains the result of the tests run as a :class:`unittest.TestResult`."
msgstr ""

#: ../../library/unittest.rst:2322
msgid "The *exit* parameter was added."
msgstr "新增 *exit* 參數。"

#: ../../library/unittest.rst:2325
msgid ""
"The *verbosity*, *failfast*, *catchbreak*, *buffer* and *warnings* "
"parameters were added."
msgstr ""

#: ../../library/unittest.rst:2329
msgid ""
"The *defaultTest* parameter was changed to also accept an iterable of test "
"names."
msgstr ""

#: ../../library/unittest.rst:2337
msgid "load_tests Protocol"
msgstr "load_tests 協定"

#: ../../library/unittest.rst:2341
msgid ""
"Modules or packages can customize how tests are loaded from them during "
"normal test runs or test discovery by implementing a function called "
"``load_tests``."
msgstr ""

#: ../../library/unittest.rst:2344
msgid ""
"If a test module defines ``load_tests`` it will be called by :meth:"
"`TestLoader.loadTestsFromModule` with the following arguments::"
msgstr ""

#: ../../library/unittest.rst:2347 ../../library/unittest.rst:2379
msgid "load_tests(loader, standard_tests, pattern)"
msgstr "load_tests(loader, standard_tests, pattern)"

#: ../../library/unittest.rst:2349
msgid ""
"where *pattern* is passed straight through from ``loadTestsFromModule``.  It "
"defaults to ``None``."
msgstr ""

#: ../../library/unittest.rst:2352
msgid "It should return a :class:`TestSuite`."
msgstr "它應該回傳一個 :class:`TestSuite`。"

#: ../../library/unittest.rst:2354
msgid ""
"*loader* is the instance of :class:`TestLoader` doing the loading. "
"*standard_tests* are the tests that would be loaded by default from the "
"module. It is common for test modules to only want to add or remove tests "
"from the standard set of tests. The third argument is used when loading "
"packages as part of test discovery."
msgstr ""

#: ../../library/unittest.rst:2360
msgid ""
"A typical ``load_tests`` function that loads tests from a specific set of :"
"class:`TestCase` classes may look like::"
msgstr ""

#: ../../library/unittest.rst:2363
msgid ""
"test_cases = (TestCase1, TestCase2, TestCase3)\n"
"\n"
"def load_tests(loader, tests, pattern):\n"
"    suite = TestSuite()\n"
"    for test_class in test_cases:\n"
"        tests = loader.loadTestsFromTestCase(test_class)\n"
"        suite.addTests(tests)\n"
"    return suite"
msgstr ""
"test_cases = (TestCase1, TestCase2, TestCase3)\n"
"\n"
"def load_tests(loader, tests, pattern):\n"
"    suite = TestSuite()\n"
"    for test_class in test_cases:\n"
"        tests = loader.loadTestsFromTestCase(test_class)\n"
"        suite.addTests(tests)\n"
"    return suite"

#: ../../library/unittest.rst:2372
msgid ""
"If discovery is started in a directory containing a package, either from the "
"command line or by calling :meth:`TestLoader.discover`, then the package :"
"file:`__init__.py` will be checked for ``load_tests``.  If that function "
"does not exist, discovery will recurse into the package as though it were "
"just another directory.  Otherwise, discovery of the package's tests will be "
"left up to ``load_tests`` which is called with the following arguments::"
msgstr ""

#: ../../library/unittest.rst:2381
msgid ""
"This should return a :class:`TestSuite` representing all the tests from the "
"package. (``standard_tests`` will only contain tests collected from :file:"
"`__init__.py`.)"
msgstr ""

#: ../../library/unittest.rst:2385
msgid ""
"Because the pattern is passed into ``load_tests`` the package is free to "
"continue (and potentially modify) test discovery. A 'do nothing' "
"``load_tests`` function for a test package would look like::"
msgstr ""

#: ../../library/unittest.rst:2389
msgid ""
"def load_tests(loader, standard_tests, pattern):\n"
"    # top level directory cached on loader instance\n"
"    this_dir = os.path.dirname(__file__)\n"
"    package_tests = loader.discover(start_dir=this_dir, pattern=pattern)\n"
"    standard_tests.addTests(package_tests)\n"
"    return standard_tests"
msgstr ""

#: ../../library/unittest.rst:2396
msgid ""
"Discovery no longer checks package names for matching *pattern* due to the "
"impossibility of package names matching the default pattern."
msgstr ""

#: ../../library/unittest.rst:2403
msgid "Class and Module Fixtures"
msgstr ""

#: ../../library/unittest.rst:2405
msgid ""
"Class and module level fixtures are implemented in :class:`TestSuite`. When "
"the test suite encounters a test from a new class then :meth:`tearDownClass` "
"from the previous class (if there is one) is called, followed by :meth:"
"`setUpClass` from the new class."
msgstr ""

#: ../../library/unittest.rst:2410
msgid ""
"Similarly if a test is from a different module from the previous test then "
"``tearDownModule`` from the previous module is run, followed by "
"``setUpModule`` from the new module."
msgstr ""

#: ../../library/unittest.rst:2414
msgid ""
"After all the tests have run the final ``tearDownClass`` and "
"``tearDownModule`` are run."
msgstr ""

#: ../../library/unittest.rst:2417
msgid ""
"Note that shared fixtures do not play well with [potential] features like "
"test parallelization and they break test isolation. They should be used with "
"care."
msgstr ""

#: ../../library/unittest.rst:2420
msgid ""
"The default ordering of tests created by the unittest test loaders is to "
"group all tests from the same modules and classes together. This will lead "
"to ``setUpClass`` / ``setUpModule`` (etc) being called exactly once per "
"class and module. If you randomize the order, so that tests from different "
"modules and classes are adjacent to each other, then these shared fixture "
"functions may be called multiple times in a single test run."
msgstr ""

#: ../../library/unittest.rst:2427
msgid ""
"Shared fixtures are not intended to work with suites with non-standard "
"ordering. A ``BaseTestSuite`` still exists for frameworks that don't want to "
"support shared fixtures."
msgstr ""

#: ../../library/unittest.rst:2431
msgid ""
"If there are any exceptions raised during one of the shared fixture "
"functions the test is reported as an error. Because there is no "
"corresponding test instance an ``_ErrorHolder`` object (that has the same "
"interface as a :class:`TestCase`) is created to represent the error. If you "
"are just using the standard unittest test runner then this detail doesn't "
"matter, but if you are a framework author it may be relevant."
msgstr ""

#: ../../library/unittest.rst:2440
msgid "setUpClass and tearDownClass"
msgstr "setUpClass 和 tearDownClass"

#: ../../library/unittest.rst:2442
msgid "These must be implemented as class methods::"
msgstr ""

#: ../../library/unittest.rst:2444
msgid ""
"import unittest\n"
"\n"
"class Test(unittest.TestCase):\n"
"    @classmethod\n"
"    def setUpClass(cls):\n"
"        cls._connection = createExpensiveConnectionObject()\n"
"\n"
"    @classmethod\n"
"    def tearDownClass(cls):\n"
"        cls._connection.destroy()"
msgstr ""
"import unittest\n"
"\n"
"class Test(unittest.TestCase):\n"
"    @classmethod\n"
"    def setUpClass(cls):\n"
"        cls._connection = createExpensiveConnectionObject()\n"
"\n"
"    @classmethod\n"
"    def tearDownClass(cls):\n"
"        cls._connection.destroy()"

#: ../../library/unittest.rst:2455
msgid ""
"If you want the ``setUpClass`` and ``tearDownClass`` on base classes called "
"then you must call up to them yourself. The implementations in :class:"
"`TestCase` are empty."
msgstr ""

#: ../../library/unittest.rst:2459
msgid ""
"If an exception is raised during a ``setUpClass`` then the tests in the "
"class are not run and the ``tearDownClass`` is not run. Skipped classes will "
"not have ``setUpClass`` or ``tearDownClass`` run. If the exception is a :exc:"
"`SkipTest` exception then the class will be reported as having been skipped "
"instead of as an error."
msgstr ""

#: ../../library/unittest.rst:2467
msgid "setUpModule and tearDownModule"
msgstr "setUpModule 和 tearDownModule"

#: ../../library/unittest.rst:2469
msgid "These should be implemented as functions::"
msgstr ""

#: ../../library/unittest.rst:2471
msgid ""
"def setUpModule():\n"
"    createConnection()\n"
"\n"
"def tearDownModule():\n"
"    closeConnection()"
msgstr ""
"def setUpModule():\n"
"    createConnection()\n"
"\n"
"def tearDownModule():\n"
"    closeConnection()"

#: ../../library/unittest.rst:2477
msgid ""
"If an exception is raised in a ``setUpModule`` then none of the tests in the "
"module will be run and the ``tearDownModule`` will not be run. If the "
"exception is a :exc:`SkipTest` exception then the module will be reported as "
"having been skipped instead of as an error."
msgstr ""

#: ../../library/unittest.rst:2482
msgid ""
"To add cleanup code that must be run even in the case of an exception, use "
"``addModuleCleanup``:"
msgstr ""

#: ../../library/unittest.rst:2488
msgid ""
"Add a function to be called after :func:`tearDownModule` to cleanup "
"resources used during the test class. Functions will be called in reverse "
"order to the order they are added (:abbr:`LIFO (last-in, first-out)`). They "
"are called with any arguments and keyword arguments passed into :meth:"
"`addModuleCleanup` when they are added."
msgstr ""

#: ../../library/unittest.rst:2494
msgid ""
"If :meth:`setUpModule` fails, meaning that :func:`tearDownModule` is not "
"called, then any cleanup functions added will still be called."
msgstr ""

#: ../../library/unittest.rst:2502
msgid ""
"Enter the supplied :term:`context manager`.  If successful, also add its :"
"meth:`~object.__exit__` method as a cleanup function by :func:"
"`addModuleCleanup` and return the result of the :meth:`~object.__enter__` "
"method."
msgstr ""

#: ../../library/unittest.rst:2512
msgid ""
"This function is called unconditionally after :func:`tearDownModule`, or "
"after :func:`setUpModule` if :func:`setUpModule` raises an exception."
msgstr ""

#: ../../library/unittest.rst:2515
msgid ""
"It is responsible for calling all the cleanup functions added by :func:"
"`addModuleCleanup`. If you need cleanup functions to be called *prior* to :"
"func:`tearDownModule` then you can call :func:`doModuleCleanups` yourself."
msgstr ""

#: ../../library/unittest.rst:2520
msgid ""
":func:`doModuleCleanups` pops methods off the stack of cleanup functions one "
"at a time, so it can be called at any time."
msgstr ""

#: ../../library/unittest.rst:2527
msgid "Signal Handling"
msgstr ""

#: ../../library/unittest.rst:2531
msgid ""
"The :option:`-c/--catch <unittest -c>` command-line option to unittest, "
"along with the ``catchbreak`` parameter to :func:`unittest.main`, provide "
"more friendly handling of control-C during a test run. With catch break "
"behavior enabled control-C will allow the currently running test to "
"complete, and the test run will then end and report all the results so far. "
"A second control-c will raise a :exc:`KeyboardInterrupt` in the usual way."
msgstr ""

#: ../../library/unittest.rst:2538
msgid ""
"The control-c handling signal handler attempts to remain compatible with "
"code or tests that install their own :const:`signal.SIGINT` handler. If the "
"``unittest`` handler is called but *isn't* the installed :const:`signal."
"SIGINT` handler, i.e. it has been replaced by the system under test and "
"delegated to, then it calls the default handler. This will normally be the "
"expected behavior by code that replaces an installed handler and delegates "
"to it. For individual tests that need ``unittest`` control-c handling "
"disabled the :func:`removeHandler` decorator can be used."
msgstr ""

#: ../../library/unittest.rst:2547
msgid ""
"There are a few utility functions for framework authors to enable control-c "
"handling functionality within test frameworks."
msgstr ""

#: ../../library/unittest.rst:2552
msgid ""
"Install the control-c handler. When a :const:`signal.SIGINT` is received "
"(usually in response to the user pressing control-c) all registered results "
"have :meth:`~TestResult.stop` called."
msgstr ""

#: ../../library/unittest.rst:2559
msgid ""
"Register a :class:`TestResult` object for control-c handling. Registering a "
"result stores a weak reference to it, so it doesn't prevent the result from "
"being garbage collected."
msgstr ""

#: ../../library/unittest.rst:2563
msgid ""
"Registering a :class:`TestResult` object has no side-effects if control-c "
"handling is not enabled, so test frameworks can unconditionally register all "
"results they create independently of whether or not handling is enabled."
msgstr ""

#: ../../library/unittest.rst:2570
msgid ""
"Remove a registered result. Once a result has been removed then :meth:"
"`~TestResult.stop` will no longer be called on that result object in "
"response to a control-c."
msgstr ""

#: ../../library/unittest.rst:2577
msgid ""
"When called without arguments this function removes the control-c handler if "
"it has been installed. This function can also be used as a test decorator to "
"temporarily remove the handler while the test is being executed::"
msgstr ""

#: ../../library/unittest.rst:2581
msgid ""
"@unittest.removeHandler\n"
"def test_signal_handling(self):\n"
"    ..."
msgstr ""
"@unittest.removeHandler\n"
"def test_signal_handling(self):\n"
"    ..."