# SOME DESCRIPTIVE TITLE. # Copyright (C) 2001-2016, Python Software Foundation # This file is distributed under the same license as the Python package. # FIRST AUTHOR , YEAR. # #, fuzzy msgid "" msgstr "" "Project-Id-Version: Python 3.6\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2017-04-02 22:11+0200\n" "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" "Last-Translator: FULL NAME \n" "Language-Team: LANGUAGE \n" "Language: fr\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" #: ../Doc/library/unittest.rst:2 msgid ":mod:`unittest` --- Unit testing framework" msgstr "" #: ../Doc/library/unittest.rst:12 msgid "**Source code:** :source:`Lib/unittest/__init__.py`" msgstr "" #: ../Doc/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 `.)" msgstr "" #: ../Doc/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 "" #: ../Doc/library/unittest.rst:25 msgid "" "To achieve this, :mod:`unittest` supports some important concepts in an " "object-oriented way:" msgstr "" #: ../Doc/library/unittest.rst:32 msgid "test fixture" msgstr "" #: ../Doc/library/unittest.rst:29 msgid "" "A :dfn:`test fixture` represents the preparation needed to perform one or " "more tests, and any associate cleanup actions. This may involve, for " "example, creating temporary or proxy databases, directories, or starting a " "server process." msgstr "" #: ../Doc/library/unittest.rst:37 msgid "test case" msgstr "" #: ../Doc/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 "" #: ../Doc/library/unittest.rst:41 msgid "test suite" msgstr "" #: ../Doc/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 "" #: ../Doc/library/unittest.rst:48 msgid "test runner" msgstr "" #: ../Doc/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 "" #: ../Doc/library/unittest.rst:53 msgid "Module :mod:`doctest`" msgstr "" #: ../Doc/library/unittest.rst:53 msgid "Another test-support module with a very different flavor." msgstr "" #: ../Doc/library/unittest.rst:57 msgid "" "`Simple Smalltalk Testing: With Patterns `_" msgstr "" #: ../Doc/library/unittest.rst:56 msgid "" "Kent Beck's original paper on testing frameworks using the pattern shared " "by :mod:`unittest`." msgstr "" #: ../Doc/library/unittest.rst:61 msgid "" "`Nose `_ and `py.test `_" msgstr "" #: ../Doc/library/unittest.rst:60 msgid "" "Third-party unittest frameworks with a lighter-weight syntax for writing " "tests. For example, ``assert func(10) == 42``." msgstr "" #: ../Doc/library/unittest.rst:65 msgid "" "`The Python Testing Tools Taxonomy `_" msgstr "" #: ../Doc/library/unittest.rst:64 msgid "" "An extensive list of Python testing tools including functional testing " "frameworks and mock object libraries." msgstr "" #: ../Doc/library/unittest.rst:69 msgid "" "`Testing in Python Mailing List `_" msgstr "" #: ../Doc/library/unittest.rst:68 msgid "" "A special-interest-group for discussion of testing, and testing tools, in " "Python." msgstr "" #: ../Doc/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 `_, " "`Jenkins `_ or `Hudson `_." msgstr "" #: ../Doc/library/unittest.rst:82 msgid "Basic example" msgstr "" #: ../Doc/library/unittest.rst:84 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 "" #: ../Doc/library/unittest.rst:88 msgid "Here is a short script to test three string methods::" msgstr "" #: ../Doc/library/unittest.rst:112 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 "" #: ../Doc/library/unittest.rst:117 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 "" #: ../Doc/library/unittest.rst:124 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 "" #: ../Doc/library/unittest.rst:128 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 "" #: ../Doc/library/unittest.rst:138 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 "" #: ../Doc/library/unittest.rst:150 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 "" #: ../Doc/library/unittest.rst:158 msgid "Command-Line Interface" msgstr "" #: ../Doc/library/unittest.rst:160 msgid "" "The unittest module can be used from the command line to run tests from " "modules, classes or even individual test methods::" msgstr "" #: ../Doc/library/unittest.rst:167 msgid "" "You can pass in a list with any combination of module names, and fully " "qualified class or method names." msgstr "" #: ../Doc/library/unittest.rst:170 msgid "Test modules can be specified by file path as well::" msgstr "" #: ../Doc/library/unittest.rst:174 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 "" #: ../Doc/library/unittest.rst:180 msgid "" "You can run tests with more detail (higher verbosity) by passing in the -v " "flag::" msgstr "" #: ../Doc/library/unittest.rst:184 msgid "" "When executed without arguments :ref:`unittest-test-discovery` is started::" msgstr "" #: ../Doc/library/unittest.rst:188 msgid "For a list of all the command-line options::" msgstr "" #: ../Doc/library/unittest.rst:192 msgid "" "In earlier versions it was only possible to run individual test methods and " "not modules or classes." msgstr "" #: ../Doc/library/unittest.rst:198 msgid "Command-line options" msgstr "" #: ../Doc/library/unittest.rst:200 msgid ":program:`unittest` supports these command-line options:" msgstr "" #: ../Doc/library/unittest.rst:206 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 "" #: ../Doc/library/unittest.rst:212 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 "" #: ../Doc/library/unittest.rst:216 msgid "" "See `Signal Handling`_ for the functions that provide this functionality." msgstr "" #: ../Doc/library/unittest.rst:220 msgid "Stop the test run on the first error or failure." msgstr "" #: ../Doc/library/unittest.rst:224 msgid "Show local variables in tracebacks." msgstr "" #: ../Doc/library/unittest.rst:226 msgid "The command-line options ``-b``, ``-c`` and ``-f`` were added." msgstr "" #: ../Doc/library/unittest.rst:229 msgid "The command-line option ``--locals``." msgstr "" #: ../Doc/library/unittest.rst:232 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 "" #: ../Doc/library/unittest.rst:239 msgid "Test Discovery" msgstr "" #: ../Doc/library/unittest.rst:243 msgid "" "Unittest supports simple test discovery. In order to be compatible with test " "discovery, all of the test files must be :ref:`modules ` or :" "ref:`packages ` (including :term:`namespace packages " "`) importable from the top-level directory of the project " "(this means that their filenames must be valid :ref:`identifiers " "`)." msgstr "" #: ../Doc/library/unittest.rst:250 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 "" #: ../Doc/library/unittest.rst:258 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 "" #: ../Doc/library/unittest.rst:262 msgid "The ``discover`` sub-command has the following options:" msgstr "" #: ../Doc/library/unittest.rst:268 msgid "Verbose output" msgstr "" #: ../Doc/library/unittest.rst:272 msgid "Directory to start discovery (``.`` default)" msgstr "" #: ../Doc/library/unittest.rst:276 msgid "Pattern to match test files (``test*.py`` default)" msgstr "" #: ../Doc/library/unittest.rst:280 msgid "Top level directory of project (defaults to start directory)" msgstr "" #: ../Doc/library/unittest.rst:282 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 "" #: ../Doc/library/unittest.rst:289 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 "" #: ../Doc/library/unittest.rst:296 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 "" #: ../Doc/library/unittest.rst:301 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 "" #: ../Doc/library/unittest.rst:305 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 "" #: ../Doc/library/unittest.rst:310 msgid "" "Test modules and packages can customize test loading and discovery by " "through the `load_tests protocol`_." msgstr "" #: ../Doc/library/unittest.rst:313 msgid "Test discovery supports :term:`namespace packages `." msgstr "" #: ../Doc/library/unittest.rst:320 msgid "Organizing test code" msgstr "" #: ../Doc/library/unittest.rst:322 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 "" #: ../Doc/library/unittest.rst:328 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 "" #: ../Doc/library/unittest.rst:332 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 "" #: ../Doc/library/unittest.rst:343 msgid "" "Note that in order to test something, we use one of the :meth:`assert\\*` " "methods provided by the :class:`TestCase` base class. If the test fails, an " "exception will be raised, and :mod:`unittest` will identify the test case as " "a :dfn:`failure`. Any other exceptions will be treated as :dfn:`errors`." msgstr "" #: ../Doc/library/unittest.rst:348 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 "" #: ../Doc/library/unittest.rst:369 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 "" #: ../Doc/library/unittest.rst:373 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 "" #: ../Doc/library/unittest.rst:377 msgid "" "Similarly, we can provide a :meth:`~TestCase.tearDown` method that tidies up " "after the test method has been run::" msgstr "" #: ../Doc/library/unittest.rst:389 msgid "" "If :meth:`~TestCase.setUp` succeeded, :meth:`~TestCase.tearDown` will be run " "whether the test method succeeded or not." msgstr "" #: ../Doc/library/unittest.rst:392 msgid "" "Such a working environment for the testing code is called a :dfn:`fixture`." msgstr "" #: ../Doc/library/unittest.rst:394 msgid "" "Test case instances are grouped 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 then execute them." msgstr "" #: ../Doc/library/unittest.rst:400 msgid "" "However, should you want to customize the building of your test suite, you " "can do it yourself::" msgstr "" #: ../Doc/library/unittest.rst:409 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 "" #: ../Doc/library/unittest.rst:414 msgid "The test module can be run standalone from the command line." msgstr "" #: ../Doc/library/unittest.rst:416 msgid "The test code can more easily be separated from shipped code." msgstr "" #: ../Doc/library/unittest.rst:418 msgid "" "There is less temptation to change test code to fit the code it tests " "without a good reason." msgstr "" #: ../Doc/library/unittest.rst:421 msgid "" "Test code should be modified much less frequently than the code it tests." msgstr "" #: ../Doc/library/unittest.rst:423 msgid "Tested code can be refactored more easily." msgstr "" #: ../Doc/library/unittest.rst:425 msgid "" "Tests for modules written in C must be in separate modules anyway, so why " "not be consistent?" msgstr "" #: ../Doc/library/unittest.rst:428 msgid "" "If the testing strategy changes, there is no need to change the source code." msgstr "" #: ../Doc/library/unittest.rst:434 msgid "Re-using old test code" msgstr "" #: ../Doc/library/unittest.rst:436 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 "" #: ../Doc/library/unittest.rst:440 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 "" #: ../Doc/library/unittest.rst:444 msgid "Given the following test function::" msgstr "" #: ../Doc/library/unittest.rst:451 msgid "" "one can create an equivalent test case instance as follows, with optional " "set-up and tear-down methods::" msgstr "" #: ../Doc/library/unittest.rst:460 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 "" #: ../Doc/library/unittest.rst:465 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 "" #: ../Doc/library/unittest.rst:474 msgid "Skipping tests and expected failures" msgstr "" #: ../Doc/library/unittest.rst:478 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 "" #: ../Doc/library/unittest.rst:483 msgid "" "Skipping a test is simply a matter of using the :func:`skip` :term:" "`decorator` or one of its conditional variants." msgstr "" #: ../Doc/library/unittest.rst:486 msgid "Basic skipping looks like this::" msgstr "" #: ../Doc/library/unittest.rst:505 msgid "This is the output of running the example above in verbose mode::" msgstr "" #: ../Doc/library/unittest.rst:516 msgid "Classes can be skipped just like methods::" msgstr "" #: ../Doc/library/unittest.rst:523 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 "" #: ../Doc/library/unittest.rst:526 msgid "Expected failures use the :func:`expectedFailure` decorator. ::" msgstr "" #: ../Doc/library/unittest.rst:533 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 "" #: ../Doc/library/unittest.rst:542 msgid "The following decorators implement test skipping and expected failures:" msgstr "" #: ../Doc/library/unittest.rst:546 msgid "" "Unconditionally skip the decorated test. *reason* should describe why the " "test is being skipped." msgstr "" #: ../Doc/library/unittest.rst:551 msgid "Skip the decorated test if *condition* is true." msgstr "" #: ../Doc/library/unittest.rst:555 msgid "Skip the decorated test unless *condition* is true." msgstr "" #: ../Doc/library/unittest.rst:559 msgid "" "Mark the test as an expected failure. If the test fails when run, the test " "is not counted as a failure." msgstr "" #: ../Doc/library/unittest.rst:564 msgid "This exception is raised to skip a test." msgstr "" #: ../Doc/library/unittest.rst:566 msgid "" "Usually you can use :meth:`TestCase.skipTest` or one of the skipping " "decorators instead of raising this directly." msgstr "" #: ../Doc/library/unittest.rst:569 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 "" #: ../Doc/library/unittest.rst:577 msgid "Distinguishing test iterations using subtests" msgstr "" #: ../Doc/library/unittest.rst:581 msgid "" "When some of your tests differ only by a some very small differences, 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 "" #: ../Doc/library/unittest.rst:585 msgid "For example, the following test::" msgstr "" #: ../Doc/library/unittest.rst:597 msgid "will produce the following output::" msgstr "" #: ../Doc/library/unittest.rst:623 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 "" #: ../Doc/library/unittest.rst:639 msgid "Classes and functions" msgstr "" #: ../Doc/library/unittest.rst:641 msgid "This section describes in depth the API of :mod:`unittest`." msgstr "" #: ../Doc/library/unittest.rst:647 msgid "Test cases" msgstr "" #: ../Doc/library/unittest.rst:651 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 "" #: ../Doc/library/unittest.rst:658 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 "" #: ../Doc/library/unittest.rst:663 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 "" #: ../Doc/library/unittest.rst:668 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 "" #: ../Doc/library/unittest.rst:673 msgid "Methods in the first group (running the test) are:" msgstr "" #: ../Doc/library/unittest.rst:677 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 "" #: ../Doc/library/unittest.rst:685 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 "" #: ../Doc/library/unittest.rst:698 msgid "" "A class method called before tests in an individual class run. " "``setUpClass`` is called with the class as the only argument and must be " "decorated as a :func:`classmethod`::" msgstr "" #: ../Doc/library/unittest.rst:706 ../Doc/library/unittest.rst:721 msgid "See `Class and Module Fixtures`_ for more details." msgstr "" #: ../Doc/library/unittest.rst:713 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 "" #: ../Doc/library/unittest.rst:728 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 "" #: ../Doc/library/unittest.rst:734 msgid "" "The same effect may be had by simply calling the :class:`TestCase` instance." msgstr "" #: ../Doc/library/unittest.rst:737 msgid "" "Previous versions of ``run`` did not return the result. Neither did calling " "an instance." msgstr "" #: ../Doc/library/unittest.rst:743 msgid "" "Calling this during a test method or :meth:`setUp` skips the current test. " "See :ref:`unittest-skipping` for more information." msgstr "" #: ../Doc/library/unittest.rst:751 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 "" #: ../Doc/library/unittest.rst:756 msgid "" "A test case can contain any number of subtest declarations, and they can be " "arbitrarily nested." msgstr "" #: ../Doc/library/unittest.rst:759 msgid "See :ref:`subtests` for more information." msgstr "" #: ../Doc/library/unittest.rst:766 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 "" #: ../Doc/library/unittest.rst:772 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 "" #: ../Doc/library/unittest.rst:777 ../Doc/library/unittest.rst:899 #: ../Doc/library/unittest.rst:1091 ../Doc/library/unittest.rst:1215 msgid "Method" msgstr "Méthode" #: ../Doc/library/unittest.rst:777 ../Doc/library/unittest.rst:899 #: ../Doc/library/unittest.rst:1091 msgid "Checks that" msgstr "" #: ../Doc/library/unittest.rst:777 ../Doc/library/unittest.rst:899 #: ../Doc/library/unittest.rst:1091 ../Doc/library/unittest.rst:1215 msgid "New in" msgstr "" #: ../Doc/library/unittest.rst:779 msgid ":meth:`assertEqual(a, b) `" msgstr ":meth:`assertEqual(a, b) `" #: ../Doc/library/unittest.rst:779 msgid "``a == b``" msgstr "``a == b``" #: ../Doc/library/unittest.rst:782 msgid ":meth:`assertNotEqual(a, b) `" msgstr ":meth:`assertNotEqual(a, b) `" #: ../Doc/library/unittest.rst:782 msgid "``a != b``" msgstr "``a != b``" #: ../Doc/library/unittest.rst:785 msgid ":meth:`assertTrue(x) `" msgstr ":meth:`assertTrue(x) `" #: ../Doc/library/unittest.rst:785 msgid "``bool(x) is True``" msgstr "``bool(x) is True``" #: ../Doc/library/unittest.rst:788 msgid ":meth:`assertFalse(x) `" msgstr ":meth:`assertFalse(x) `" #: ../Doc/library/unittest.rst:788 msgid "``bool(x) is False``" msgstr "``bool(x) is False``" #: ../Doc/library/unittest.rst:791 msgid ":meth:`assertIs(a, b) `" msgstr ":meth:`assertIs(a, b) `" #: ../Doc/library/unittest.rst:791 msgid "``a is b``" msgstr "``a is b``" #: ../Doc/library/unittest.rst:791 ../Doc/library/unittest.rst:794 #: ../Doc/library/unittest.rst:797 ../Doc/library/unittest.rst:800 #: ../Doc/library/unittest.rst:803 ../Doc/library/unittest.rst:806 #: ../Doc/library/unittest.rst:904 ../Doc/library/unittest.rst:1099 #: ../Doc/library/unittest.rst:1102 ../Doc/library/unittest.rst:1105 #: ../Doc/library/unittest.rst:1108 ../Doc/library/unittest.rst:1111 #: ../Doc/library/unittest.rst:1217 ../Doc/library/unittest.rst:1220 #: ../Doc/library/unittest.rst:1223 ../Doc/library/unittest.rst:1226 #: ../Doc/library/unittest.rst:1229 ../Doc/library/unittest.rst:1232 msgid "3.1" msgstr "3.1" #: ../Doc/library/unittest.rst:794 msgid ":meth:`assertIsNot(a, b) `" msgstr ":meth:`assertIsNot(a, b) `" #: ../Doc/library/unittest.rst:794 msgid "``a is not b``" msgstr "``a is not b``" #: ../Doc/library/unittest.rst:797 msgid ":meth:`assertIsNone(x) `" msgstr ":meth:`assertIsNone(x) `" #: ../Doc/library/unittest.rst:797 msgid "``x is None``" msgstr "``x is None``" #: ../Doc/library/unittest.rst:800 msgid ":meth:`assertIsNotNone(x) `" msgstr ":meth:`assertIsNotNone(x) `" #: ../Doc/library/unittest.rst:800 msgid "``x is not None``" msgstr "``x is not None``" #: ../Doc/library/unittest.rst:803 msgid ":meth:`assertIn(a, b) `" msgstr ":meth:`assertIn(a, b) `" #: ../Doc/library/unittest.rst:803 msgid "``a in b``" msgstr "``a in b``" #: ../Doc/library/unittest.rst:806 msgid ":meth:`assertNotIn(a, b) `" msgstr ":meth:`assertNotIn(a, b) `" #: ../Doc/library/unittest.rst:806 msgid "``a not in b``" msgstr "``a not in b``" #: ../Doc/library/unittest.rst:809 msgid ":meth:`assertIsInstance(a, b) `" msgstr ":meth:`assertIsInstance(a, b) `" #: ../Doc/library/unittest.rst:809 msgid "``isinstance(a, b)``" msgstr "``isinstance(a, b)``" #: ../Doc/library/unittest.rst:809 ../Doc/library/unittest.rst:812 #: ../Doc/library/unittest.rst:907 ../Doc/library/unittest.rst:910 #: ../Doc/library/unittest.rst:1114 ../Doc/library/unittest.rst:1117 msgid "3.2" msgstr "3.2" #: ../Doc/library/unittest.rst:812 msgid ":meth:`assertNotIsInstance(a, b) `" msgstr ":meth:`assertNotIsInstance(a, b) `" #: ../Doc/library/unittest.rst:812 msgid "``not isinstance(a, b)``" msgstr "``not isinstance(a, b)``" #: ../Doc/library/unittest.rst:816 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 "" #: ../Doc/library/unittest.rst:824 msgid "" "Test that *first* and *second* are equal. If the values do not compare " "equal, the test will fail." msgstr "" #: ../Doc/library/unittest.rst:827 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 `)." msgstr "" #: ../Doc/library/unittest.rst:834 msgid "Added the automatic calling of type-specific equality function." msgstr "" #: ../Doc/library/unittest.rst:837 msgid "" ":meth:`assertMultiLineEqual` added as the default type equality function for " "comparing strings." msgstr "" #: ../Doc/library/unittest.rst:844 msgid "" "Test that *first* and *second* are not equal. If the values do compare " "equal, the test will fail." msgstr "" #: ../Doc/library/unittest.rst:850 msgid "Test that *expr* is true (or false)." msgstr "" #: ../Doc/library/unittest.rst:852 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 "" #: ../Doc/library/unittest.rst:862 msgid "" "Test that *first* and *second* evaluate (or don't evaluate) to the same " "object." msgstr "" #: ../Doc/library/unittest.rst:871 msgid "Test that *expr* is (or is not) ``None``." msgstr "" #: ../Doc/library/unittest.rst:879 msgid "Test that *first* is (or is not) in *second*." msgstr "" #: ../Doc/library/unittest.rst:887 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) `." msgstr "" #: ../Doc/library/unittest.rst:895 msgid "" "It is also possible to check the production of exceptions, warnings, and log " "messages using the following methods:" msgstr "" #: ../Doc/library/unittest.rst:901 msgid ":meth:`assertRaises(exc, fun, *args, **kwds) `" msgstr "" #: ../Doc/library/unittest.rst:901 msgid "``fun(*args, **kwds)`` raises *exc*" msgstr "" #: ../Doc/library/unittest.rst:904 msgid "" ":meth:`assertRaisesRegex(exc, r, fun, *args, **kwds) `" msgstr "" #: ../Doc/library/unittest.rst:904 msgid "``fun(*args, **kwds)`` raises *exc* and the message matches regex *r*" msgstr "" #: ../Doc/library/unittest.rst:907 msgid ":meth:`assertWarns(warn, fun, *args, **kwds) `" msgstr "" #: ../Doc/library/unittest.rst:907 msgid "``fun(*args, **kwds)`` raises *warn*" msgstr "" #: ../Doc/library/unittest.rst:910 msgid "" ":meth:`assertWarnsRegex(warn, r, fun, *args, **kwds) `" msgstr "" #: ../Doc/library/unittest.rst:910 msgid "``fun(*args, **kwds)`` raises *warn* and the message matches regex *r*" msgstr "" #: ../Doc/library/unittest.rst:913 msgid ":meth:`assertLogs(logger, level) `" msgstr "" #: ../Doc/library/unittest.rst:913 msgid "The ``with`` block logs on *logger* with minimum *level*" msgstr "" #: ../Doc/library/unittest.rst:913 msgid "3.4" msgstr "3.4" #: ../Doc/library/unittest.rst:920 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 "" #: ../Doc/library/unittest.rst:927 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 "" #: ../Doc/library/unittest.rst:934 msgid "" "When used as a context manager, :meth:`assertRaises` accepts the additional " "keyword argument *msg*." msgstr "" #: ../Doc/library/unittest.rst:937 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 "" #: ../Doc/library/unittest.rst:947 msgid "Added the ability to use :meth:`assertRaises` as a context manager." msgstr "" #: ../Doc/library/unittest.rst:950 msgid "Added the :attr:`exception` attribute." msgstr "" #: ../Doc/library/unittest.rst:953 ../Doc/library/unittest.rst:979 #: ../Doc/library/unittest.rst:1020 ../Doc/library/unittest.rst:1043 msgid "Added the *msg* keyword argument when used as a context manager." msgstr "" #: ../Doc/library/unittest.rst:960 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 "" #: ../Doc/library/unittest.rst:968 ../Doc/library/unittest.rst:1036 msgid "or::" msgstr "ou : ::" #: ../Doc/library/unittest.rst:973 msgid "under the name ``assertRaisesRegexp``." msgstr "" #: ../Doc/library/unittest.rst:976 msgid "Renamed to :meth:`assertRaisesRegex`." msgstr "" #: ../Doc/library/unittest.rst:986 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 "" #: ../Doc/library/unittest.rst:993 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 "" #: ../Doc/library/unittest.rst:1000 msgid "" "When used as a context manager, :meth:`assertWarns` accepts the additional " "keyword argument *msg*." msgstr "" #: ../Doc/library/unittest.rst:1003 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 "" #: ../Doc/library/unittest.rst:1015 msgid "" "This method works regardless of the warning filters in place when it is " "called." msgstr "" #: ../Doc/library/unittest.rst:1027 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 "" #: ../Doc/library/unittest.rst:1048 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 "" #: ../Doc/library/unittest.rst:1052 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 "" #: ../Doc/library/unittest.rst:1056 msgid "" "If given, *level* should be either a numeric logging level or its string " "equivalent (for example either ``\"ERROR\"`` or :attr:`logging.ERROR`). The " "default is :attr:`logging.INFO`." msgstr "" #: ../Doc/library/unittest.rst:1060 msgid "" "The test passes if at least one message emitted inside the ``with`` block " "matches the *logger* and *level* conditions, otherwise it fails." msgstr "" #: ../Doc/library/unittest.rst:1063 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 "" #: ../Doc/library/unittest.rst:1069 msgid "" "A list of :class:`logging.LogRecord` objects of the matching log messages." msgstr "" #: ../Doc/library/unittest.rst:1074 msgid "" "A list of :class:`str` objects with the formatted output of matching " "messages." msgstr "" #: ../Doc/library/unittest.rst:1077 msgid "Example::" msgstr "Exemples ::" #: ../Doc/library/unittest.rst:1088 msgid "" "There are also other methods used to perform more specific checks, such as:" msgstr "" #: ../Doc/library/unittest.rst:1093 msgid ":meth:`assertAlmostEqual(a, b) `" msgstr ":meth:`assertAlmostEqual(a, b) `" #: ../Doc/library/unittest.rst:1093 msgid "``round(a-b, 7) == 0``" msgstr "``round(a-b, 7) == 0``" #: ../Doc/library/unittest.rst:1096 msgid ":meth:`assertNotAlmostEqual(a, b) `" msgstr "" #: ../Doc/library/unittest.rst:1096 msgid "``round(a-b, 7) != 0``" msgstr "``round(a-b, 7) != 0``" #: ../Doc/library/unittest.rst:1099 msgid ":meth:`assertGreater(a, b) `" msgstr ":meth:`assertGreater(a, b) `" #: ../Doc/library/unittest.rst:1099 msgid "``a > b``" msgstr "``a > b``" #: ../Doc/library/unittest.rst:1102 msgid ":meth:`assertGreaterEqual(a, b) `" msgstr ":meth:`assertGreaterEqual(a, b) `" #: ../Doc/library/unittest.rst:1102 msgid "``a >= b``" msgstr "``a >= b``" #: ../Doc/library/unittest.rst:1105 msgid ":meth:`assertLess(a, b) `" msgstr ":meth:`assertLess(a, b) `" #: ../Doc/library/unittest.rst:1105 msgid "``a < b``" msgstr "``a < b``" #: ../Doc/library/unittest.rst:1108 msgid ":meth:`assertLessEqual(a, b) `" msgstr ":meth:`assertLessEqual(a, b) `" #: ../Doc/library/unittest.rst:1108 msgid "``a <= b``" msgstr "``a <= b``" #: ../Doc/library/unittest.rst:1111 msgid ":meth:`assertRegex(s, r) `" msgstr ":meth:`assertRegex(s, r) `" #: ../Doc/library/unittest.rst:1111 msgid "``r.search(s)``" msgstr "``r.search(s)``" #: ../Doc/library/unittest.rst:1114 msgid ":meth:`assertNotRegex(s, r) `" msgstr ":meth:`assertNotRegex(s, r) `" #: ../Doc/library/unittest.rst:1114 msgid "``not r.search(s)``" msgstr "``not r.search(s)``" #: ../Doc/library/unittest.rst:1117 msgid ":meth:`assertCountEqual(a, b) `" msgstr ":meth:`assertCountEqual(a, b) `" #: ../Doc/library/unittest.rst:1117 msgid "" "*a* and *b* have the same elements in the same number, regardless of their " "order" msgstr "" #: ../Doc/library/unittest.rst:1126 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 "" #: ../Doc/library/unittest.rst:1132 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 "" #: ../Doc/library/unittest.rst:1135 msgid "Supplying both *delta* and *places* raises a ``TypeError``." msgstr "" #: ../Doc/library/unittest.rst:1137 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 "" #: ../Doc/library/unittest.rst:1148 msgid "" "Test that *first* is respectively >, >=, < or <= than *second* depending on " "the method name. If not, the test will fail::" msgstr "" #: ../Doc/library/unittest.rst:1160 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 "" #: ../Doc/library/unittest.rst:1166 msgid "under the name ``assertRegexpMatches``." msgstr "" #: ../Doc/library/unittest.rst:1168 msgid "" "The method ``assertRegexpMatches()`` has been renamed to :meth:`." "assertRegex`." msgstr "" #: ../Doc/library/unittest.rst:1171 msgid ":meth:`.assertNotRegex`." msgstr ":meth:`.assertNotRegex`." #: ../Doc/library/unittest.rst:1177 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 "" #: ../Doc/library/unittest.rst:1181 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 "" #: ../Doc/library/unittest.rst:1192 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 "" #: ../Doc/library/unittest.rst:1199 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) ` when inequality between the first " "two parameters is detected -- possibly providing useful information and " "explaining the inequalities in details in the error message." msgstr "" #: ../Doc/library/unittest.rst:1210 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 "" #: ../Doc/library/unittest.rst:1215 msgid "Used to compare" msgstr "" #: ../Doc/library/unittest.rst:1217 msgid ":meth:`assertMultiLineEqual(a, b) `" msgstr ":meth:`assertMultiLineEqual(a, b) `" #: ../Doc/library/unittest.rst:1217 msgid "strings" msgstr "chaînes" #: ../Doc/library/unittest.rst:1220 msgid ":meth:`assertSequenceEqual(a, b) `" msgstr ":meth:`assertSequenceEqual(a, b) `" #: ../Doc/library/unittest.rst:1220 msgid "sequences" msgstr "séquences" #: ../Doc/library/unittest.rst:1223 msgid ":meth:`assertListEqual(a, b) `" msgstr ":meth:`assertListEqual(a, b) `" #: ../Doc/library/unittest.rst:1223 msgid "lists" msgstr "" #: ../Doc/library/unittest.rst:1226 msgid ":meth:`assertTupleEqual(a, b) `" msgstr ":meth:`assertTupleEqual(a, b) `" #: ../Doc/library/unittest.rst:1226 msgid "tuples" msgstr "" #: ../Doc/library/unittest.rst:1229 msgid ":meth:`assertSetEqual(a, b) `" msgstr ":meth:`assertSetEqual(a, b) `" #: ../Doc/library/unittest.rst:1229 msgid "sets or frozensets" msgstr "" #: ../Doc/library/unittest.rst:1232 msgid ":meth:`assertDictEqual(a, b) `" msgstr ":meth:`assertDictEqual(a, b) `" #: ../Doc/library/unittest.rst:1232 msgid "dicts" msgstr "" #: ../Doc/library/unittest.rst:1240 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 "" #: ../Doc/library/unittest.rst:1250 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 "" #: ../Doc/library/unittest.rst:1255 msgid "" "This method is not called directly by :meth:`assertEqual`, but it's used to " "implement :meth:`assertListEqual` and :meth:`assertTupleEqual`." msgstr "" #: ../Doc/library/unittest.rst:1265 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 "" #: ../Doc/library/unittest.rst:1276 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 "" #: ../Doc/library/unittest.rst:1280 msgid "" "Fails if either of *first* or *second* does not have a :meth:`set." "difference` method." msgstr "" #: ../Doc/library/unittest.rst:1288 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 "" #: ../Doc/library/unittest.rst:1299 msgid "" "Finally the :class:`TestCase` provides the following methods and attributes:" msgstr "" #: ../Doc/library/unittest.rst:1304 msgid "" "Signals a test failure unconditionally, with *msg* or ``None`` for the error " "message." msgstr "" #: ../Doc/library/unittest.rst:1310 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 "" #: ../Doc/library/unittest.rst:1319 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 "" #: ../Doc/library/unittest.rst:1325 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 "" #: ../Doc/library/unittest.rst:1329 msgid "The class setting gets reset before each test call." msgstr "" #: ../Doc/library/unittest.rst:1336 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 "" #: ../Doc/library/unittest.rst:1343 msgid "" "Setting ``maxDiff`` to ``None`` means that there is no maximum length of " "diffs." msgstr "" #: ../Doc/library/unittest.rst:1349 msgid "" "Testing frameworks can use the following methods to collect information on " "the test:" msgstr "" #: ../Doc/library/unittest.rst:1355 msgid "" "Return the number of tests represented by this test object. For :class:" "`TestCase` instances, this will always be ``1``." msgstr "" #: ../Doc/library/unittest.rst:1361 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 "" #: ../Doc/library/unittest.rst:1365 msgid "" "For :class:`TestCase` instances, this will always be an instance of :class:" "`TestResult`; subclasses of :class:`TestCase` should override this as " "necessary." msgstr "" #: ../Doc/library/unittest.rst:1372 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 "" #: ../Doc/library/unittest.rst:1378 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 "" #: ../Doc/library/unittest.rst:1383 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 "" #: ../Doc/library/unittest.rst:1392 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 "" #: ../Doc/library/unittest.rst:1398 msgid "" "If :meth:`setUp` fails, meaning that :meth:`tearDown` is not called, then " "any cleanup functions added will still be called." msgstr "" #: ../Doc/library/unittest.rst:1406 msgid "" "This method is called unconditionally after :meth:`tearDown`, or after :meth:" "`setUp` if :meth:`setUp` raises an exception." msgstr "" #: ../Doc/library/unittest.rst:1409 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 "" #: ../Doc/library/unittest.rst:1414 msgid "" ":meth:`doCleanups` pops methods off the stack of cleanup functions one at a " "time, so it can be called at any time." msgstr "" #: ../Doc/library/unittest.rst:1422 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 "" #: ../Doc/library/unittest.rst:1432 msgid "Deprecated aliases" msgstr "" #: ../Doc/library/unittest.rst:1434 msgid "" "For historical reasons, some of the :class:`TestCase` methods had one or " "more aliases that are now deprecated. The following table lists the correct " "names along with their deprecated aliases:" msgstr "" #: ../Doc/library/unittest.rst:1439 msgid "Method Name" msgstr "Nom de méthode" #: ../Doc/library/unittest.rst:1439 msgid "Deprecated alias" msgstr "" #: ../Doc/library/unittest.rst:1441 msgid ":meth:`.assertEqual`" msgstr ":meth:`.assertEqual`" #: ../Doc/library/unittest.rst:1441 msgid "failUnlessEqual" msgstr "failUnlessEqual" #: ../Doc/library/unittest.rst:1441 msgid "assertEquals" msgstr "assertEquals" #: ../Doc/library/unittest.rst:1442 msgid ":meth:`.assertNotEqual`" msgstr ":meth:`.assertNotEqual`" #: ../Doc/library/unittest.rst:1442 msgid "failIfEqual" msgstr "failIfEqual" #: ../Doc/library/unittest.rst:1442 msgid "assertNotEquals" msgstr "assertNotEquals" #: ../Doc/library/unittest.rst:1443 msgid ":meth:`.assertTrue`" msgstr ":meth:`.assertTrue`" #: ../Doc/library/unittest.rst:1443 msgid "failUnless" msgstr "failUnless" #: ../Doc/library/unittest.rst:1443 msgid "assert\\_" msgstr "assert\\_" #: ../Doc/library/unittest.rst:1444 msgid ":meth:`.assertFalse`" msgstr ":meth:`.assertFalse`" #: ../Doc/library/unittest.rst:1444 msgid "failIf" msgstr "failIf" #: ../Doc/library/unittest.rst:1445 msgid ":meth:`.assertRaises`" msgstr ":meth:`.assertRaises`" #: ../Doc/library/unittest.rst:1445 msgid "failUnlessRaises" msgstr "failUnlessRaises" #: ../Doc/library/unittest.rst:1446 msgid ":meth:`.assertAlmostEqual`" msgstr ":meth:`.assertAlmostEqual`" #: ../Doc/library/unittest.rst:1446 msgid "failUnlessAlmostEqual" msgstr "failUnlessAlmostEqual" #: ../Doc/library/unittest.rst:1446 msgid "assertAlmostEquals" msgstr "assertAlmostEquals" #: ../Doc/library/unittest.rst:1447 msgid ":meth:`.assertNotAlmostEqual`" msgstr ":meth:`.assertNotAlmostEqual`" #: ../Doc/library/unittest.rst:1447 msgid "failIfAlmostEqual" msgstr "failIfAlmostEqual" #: ../Doc/library/unittest.rst:1447 msgid "assertNotAlmostEquals" msgstr "assertNotAlmostEquals" #: ../Doc/library/unittest.rst:1448 msgid ":meth:`.assertRegex`" msgstr ":meth:`.assertRegex`" #: ../Doc/library/unittest.rst:1448 msgid "assertRegexpMatches" msgstr "assertRegexpMatches" #: ../Doc/library/unittest.rst:1449 msgid ":meth:`.assertRaisesRegex`" msgstr ":meth:`.assertRaisesRegex`" #: ../Doc/library/unittest.rst:1449 msgid "assertRaisesRegexp" msgstr "assertRaisesRegexp" #: ../Doc/library/unittest.rst:1452 msgid "the fail* aliases listed in the second column." msgstr "" #: ../Doc/library/unittest.rst:1454 msgid "the assert* aliases listed in the third column." msgstr "" #: ../Doc/library/unittest.rst:1456 msgid "" "``assertRegexpMatches`` and ``assertRaisesRegexp`` have been renamed to :" "meth:`.assertRegex` and :meth:`.assertRaisesRegex`" msgstr "" #: ../Doc/library/unittest.rst:1464 msgid "Grouping tests" msgstr "" #: ../Doc/library/unittest.rst:1468 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 "" #: ../Doc/library/unittest.rst:1473 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 "" #: ../Doc/library/unittest.rst:1477 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 "" #: ../Doc/library/unittest.rst:1485 msgid "Add a :class:`TestCase` or :class:`TestSuite` to the suite." msgstr "" #: ../Doc/library/unittest.rst:1490 msgid "" "Add all the tests from an iterable of :class:`TestCase` and :class:" "`TestSuite` instances to this test suite." msgstr "" #: ../Doc/library/unittest.rst:1493 msgid "" "This is equivalent to iterating over *tests*, calling :meth:`addTest` for " "each element." msgstr "" #: ../Doc/library/unittest.rst:1496 msgid ":class:`TestSuite` shares the following methods with :class:`TestCase`:" msgstr "" #: ../Doc/library/unittest.rst:1501 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 "" #: ../Doc/library/unittest.rst:1509 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 "" #: ../Doc/library/unittest.rst:1516 msgid "" "Return the number of tests represented by this test object, including all " "individual tests and sub-suites." msgstr "" #: ../Doc/library/unittest.rst:1522 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 "" #: ../Doc/library/unittest.rst:1532 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 "" #: ../Doc/library/unittest.rst:1537 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 "" #: ../Doc/library/unittest.rst:1542 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 "" #: ../Doc/library/unittest.rst:1547 msgid "Loading and running tests" msgstr "" #: ../Doc/library/unittest.rst:1551 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 "" #: ../Doc/library/unittest.rst:1557 msgid ":class:`TestLoader` objects have the following attributes:" msgstr "" #: ../Doc/library/unittest.rst:1562 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 a 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 "" #: ../Doc/library/unittest.rst:1571 msgid ":class:`TestLoader` objects have the following methods:" msgstr "" #: ../Doc/library/unittest.rst:1576 msgid "" "Return a suite of all test cases contained in the :class:`TestCase`\\ -" "derived :class:`testCaseClass`." msgstr "" #: ../Doc/library/unittest.rst:1579 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 "" #: ../Doc/library/unittest.rst:1588 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 "" #: ../Doc/library/unittest.rst:1595 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 "" #: ../Doc/library/unittest.rst:1601 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 "" #: ../Doc/library/unittest.rst:1606 msgid "Support for ``load_tests`` added." msgstr "" #: ../Doc/library/unittest.rst:1609 msgid "" "The undocumented and unofficial *use_load_tests* default argument is " "deprecated and ignored, although it is still accepted for backward " "compatibility. The method also now accepts a keyword-only argument " "*pattern* which is passed to ``load_tests`` as the third argument." msgstr "" #: ../Doc/library/unittest.rst:1618 msgid "Return a suite of all test cases given a string specifier." msgstr "" #: ../Doc/library/unittest.rst:1620 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 "" #: ../Doc/library/unittest.rst:1628 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 "" #: ../Doc/library/unittest.rst:1638 msgid "The method optionally resolves *name* relative to the given *module*." msgstr "" #: ../Doc/library/unittest.rst:1640 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 "" #: ../Doc/library/unittest.rst:1649 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 "" #: ../Doc/library/unittest.rst:1656 msgid "" "Return a sorted sequence of method names found within *testCaseClass*; this " "should be a subclass of :class:`TestCase`." msgstr "" #: ../Doc/library/unittest.rst:1662 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 "" #: ../Doc/library/unittest.rst:1668 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 the top level " "directory must be specified separately." msgstr "" #: ../Doc/library/unittest.rst:1672 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 "" #: ../Doc/library/unittest.rst:1677 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 "" #: ../Doc/library/unittest.rst:1685 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 "" #: ../Doc/library/unittest.rst:1689 msgid "" "The pattern is deliberately not stored as a loader attribute so that " "packages can continue discovery themselves. *top_level_dir* is stored so " "``load_tests`` does not need to pass this argument in to ``loader." "discover()``." msgstr "" #: ../Doc/library/unittest.rst:1694 msgid "*start_dir* can be a dotted module name as well as a directory." msgstr "" #: ../Doc/library/unittest.rst:1698 msgid "" "Modules that raise :exc:`SkipTest` on import are recorded as skips, not " "errors. Discovery works for :term:`namespace packages `. " "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 "" #: ../Doc/library/unittest.rst:1706 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 "" #: ../Doc/library/unittest.rst:1712 msgid "" "The following attributes of a :class:`TestLoader` can be configured either " "by subclassing or assignment on an instance:" msgstr "" #: ../Doc/library/unittest.rst:1718 msgid "" "String giving the prefix of method names which will be interpreted as test " "methods. The default value is ``'test'``." msgstr "" #: ../Doc/library/unittest.rst:1721 msgid "" "This affects :meth:`getTestCaseNames` and all the :meth:`loadTestsFrom\\*` " "methods." msgstr "" #: ../Doc/library/unittest.rst:1727 msgid "" "Function to be used to compare method names when sorting them in :meth:" "`getTestCaseNames` and all the :meth:`loadTestsFrom\\*` methods." msgstr "" #: ../Doc/library/unittest.rst:1733 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 "" #: ../Doc/library/unittest.rst:1737 msgid "This affects all the :meth:`loadTestsFrom\\*` methods." msgstr "" #: ../Doc/library/unittest.rst:1742 msgid "" "This class is used to compile information about which tests have succeeded " "and which have failed." msgstr "" #: ../Doc/library/unittest.rst:1745 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 "" #: ../Doc/library/unittest.rst:1750 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 "" #: ../Doc/library/unittest.rst:1755 msgid "" ":class:`TestResult` instances have the following attributes that will be of " "interest when inspecting the results of running a set of tests:" msgstr "" #: ../Doc/library/unittest.rst:1761 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 "" #: ../Doc/library/unittest.rst:1767 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 :meth:`TestCase.assert\\*` methods." msgstr "" #: ../Doc/library/unittest.rst:1773 msgid "" "A list containing 2-tuples of :class:`TestCase` instances and strings " "holding the reason for skipping the test." msgstr "" #: ../Doc/library/unittest.rst:1780 msgid "" "A list containing 2-tuples of :class:`TestCase` instances and strings " "holding formatted tracebacks. Each tuple represents an expected failure of " "the test case." msgstr "" #: ../Doc/library/unittest.rst:1786 msgid "" "A list containing :class:`TestCase` instances that were marked as expected " "failures, but succeeded." msgstr "" #: ../Doc/library/unittest.rst:1791 msgid "" "Set to ``True`` when the execution of tests should stop by :meth:`stop`." msgstr "" #: ../Doc/library/unittest.rst:1795 msgid "The total number of tests run so far." msgstr "" #: ../Doc/library/unittest.rst:1799 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 "" #: ../Doc/library/unittest.rst:1808 msgid "" "If set to true :meth:`stop` will be called on the first failure or error, " "halting the test run." msgstr "" #: ../Doc/library/unittest.rst:1815 msgid "If set to true then local variables will be shown in tracebacks." msgstr "" #: ../Doc/library/unittest.rst:1821 msgid "" "Return ``True`` if all tests run so far have passed, otherwise returns " "``False``." msgstr "" #: ../Doc/library/unittest.rst:1824 msgid "" "Returns ``False`` if there were any :attr:`unexpectedSuccesses` from tests " "marked with the :func:`expectedFailure` decorator." msgstr "" #: ../Doc/library/unittest.rst:1830 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 "" #: ../Doc/library/unittest.rst:1835 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 "" #: ../Doc/library/unittest.rst:1840 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 "" #: ../Doc/library/unittest.rst:1848 msgid "Called when the test case *test* is about to be run." msgstr "" #: ../Doc/library/unittest.rst:1852 msgid "" "Called after the test case *test* has been executed, regardless of the " "outcome." msgstr "" #: ../Doc/library/unittest.rst:1857 msgid "Called once before any tests are executed." msgstr "" #: ../Doc/library/unittest.rst:1864 msgid "Called once after all tests are executed." msgstr "" #: ../Doc/library/unittest.rst:1871 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 "" #: ../Doc/library/unittest.rst:1875 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 "" #: ../Doc/library/unittest.rst:1882 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 "" #: ../Doc/library/unittest.rst:1885 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 "" #: ../Doc/library/unittest.rst:1892 msgid "Called when the test case *test* succeeds." msgstr "" #: ../Doc/library/unittest.rst:1894 msgid "The default implementation does nothing." msgstr "" #: ../Doc/library/unittest.rst:1899 msgid "" "Called when the test case *test* is skipped. *reason* is the reason the " "test gave for skipping." msgstr "" #: ../Doc/library/unittest.rst:1902 msgid "" "The default implementation appends a tuple ``(test, reason)`` to the " "instance's :attr:`skipped` attribute." msgstr "" #: ../Doc/library/unittest.rst:1908 msgid "" "Called when the test case *test* fails, but was marked with the :func:" "`expectedFailure` decorator." msgstr "" #: ../Doc/library/unittest.rst:1911 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 "" #: ../Doc/library/unittest.rst:1918 msgid "" "Called when the test case *test* was marked with the :func:`expectedFailure` " "decorator, but succeeded." msgstr "" #: ../Doc/library/unittest.rst:1921 msgid "" "The default implementation appends the test to the instance's :attr:" "`unexpectedSuccesses` attribute." msgstr "" #: ../Doc/library/unittest.rst:1927 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 "" #: ../Doc/library/unittest.rst:1931 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 "" #: ../Doc/library/unittest.rst:1935 msgid "" "The default implementation does nothing when the outcome is a success, and " "records subtest failures as normal failures." msgstr "" #: ../Doc/library/unittest.rst:1943 msgid "" "A concrete implementation of :class:`TestResult` used by the :class:" "`TextTestRunner`." msgstr "" #: ../Doc/library/unittest.rst:1946 msgid "" "This class was previously named ``_TextTestResult``. The old name still " "exists as an alias but is deprecated." msgstr "" #: ../Doc/library/unittest.rst:1953 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 "" #: ../Doc/library/unittest.rst:1961 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 "" #: ../Doc/library/unittest.rst:1968 msgid "" "By default this runner shows :exc:`DeprecationWarning`, :exc:" "`PendingDeprecationWarning`, :exc:`ResourceWarning` and :exc:`ImportWarning` " "even if they are :ref:`ignored by default `. Deprecation " "warnings caused by :ref:`deprecated unittest methods ` " "are also special-cased and, when the warning filters are ``'default'`` or " "``'always'``, they will appear only once per-module, in order to avoid too " "many warning messages. This behavior can be overridden using Python's :" "option:`!-Wd` or :option:`!-Wa` options (see :ref:`Warning control `) and leaving *warnings* to ``None``." msgstr "" #: ../Doc/library/unittest.rst:1979 msgid "Added the ``warnings`` argument." msgstr "" #: ../Doc/library/unittest.rst:1982 msgid "" "The default stream is set to :data:`sys.stderr` at instantiation time rather " "than import time." msgstr "" #: ../Doc/library/unittest.rst:1986 msgid "Added the tb_locals parameter." msgstr "" #: ../Doc/library/unittest.rst:1991 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 "" #: ../Doc/library/unittest.rst:1995 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 "" #: ../Doc/library/unittest.rst:2004 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 "" #: ../Doc/library/unittest.rst:2015 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 "" #: ../Doc/library/unittest.rst:2023 msgid "" "You can run tests with more detailed information by passing in the verbosity " "argument::" msgstr "" #: ../Doc/library/unittest.rst:2029 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 "" #: ../Doc/library/unittest.rst:2034 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 "" #: ../Doc/library/unittest.rst:2038 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 or failure of the tests run." msgstr "" #: ../Doc/library/unittest.rst:2042 msgid "" "The *testLoader* argument has to be a :class:`TestLoader` instance, and " "defaults to :data:`defaultTestLoader`." msgstr "" #: ../Doc/library/unittest.rst:2045 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 "" #: ../Doc/library/unittest.rst:2052 msgid "" "The *failfast*, *catchbreak* and *buffer* parameters have the same effect as " "the same-name `command-line options`_." msgstr "" #: ../Doc/library/unittest.rst:2055 msgid "" "The *warnings* argument specifies the :ref:`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 `), otherwise it will be set " "to ``'default'``." msgstr "" #: ../Doc/library/unittest.rst:2061 msgid "" "Calling ``main`` actually returns an instance of the ``TestProgram`` class. " "This stores the result of the tests run as the ``result`` attribute." msgstr "" #: ../Doc/library/unittest.rst:2064 msgid "The *exit* parameter was added." msgstr "" #: ../Doc/library/unittest.rst:2067 msgid "" "The *verbosity*, *failfast*, *catchbreak*, *buffer* and *warnings* " "parameters were added." msgstr "" #: ../Doc/library/unittest.rst:2071 msgid "" "The *defaultTest* parameter was changed to also accept an iterable of test " "names." msgstr "" #: ../Doc/library/unittest.rst:2077 msgid "load_tests Protocol" msgstr "" #: ../Doc/library/unittest.rst:2081 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 "" #: ../Doc/library/unittest.rst:2084 msgid "" "If a test module defines ``load_tests`` it will be called by :meth:" "`TestLoader.loadTestsFromModule` with the following arguments::" msgstr "" #: ../Doc/library/unittest.rst:2089 msgid "" "where *pattern* is passed straight through from ``loadTestsFromModule``. It " "defaults to ``None``." msgstr "" #: ../Doc/library/unittest.rst:2092 msgid "It should return a :class:`TestSuite`." msgstr "" #: ../Doc/library/unittest.rst:2094 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 "" #: ../Doc/library/unittest.rst:2100 msgid "" "A typical ``load_tests`` function that loads tests from a specific set of :" "class:`TestCase` classes may look like::" msgstr "" #: ../Doc/library/unittest.rst:2112 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 "" #: ../Doc/library/unittest.rst:2121 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 "" #: ../Doc/library/unittest.rst:2125 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 "" #: ../Doc/library/unittest.rst:2136 msgid "" "Discovery no longer checks package names for matching *pattern* due to the " "impossibility of package names matching the default pattern." msgstr "" #: ../Doc/library/unittest.rst:2143 msgid "Class and Module Fixtures" msgstr "" #: ../Doc/library/unittest.rst:2145 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 "" #: ../Doc/library/unittest.rst:2150 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 "" #: ../Doc/library/unittest.rst:2154 msgid "" "After all the tests have run the final ``tearDownClass`` and " "``tearDownModule`` are run." msgstr "" #: ../Doc/library/unittest.rst:2157 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 "" #: ../Doc/library/unittest.rst:2160 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 "" #: ../Doc/library/unittest.rst:2167 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 "" #: ../Doc/library/unittest.rst:2171 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 "" #: ../Doc/library/unittest.rst:2180 msgid "setUpClass and tearDownClass" msgstr "" #: ../Doc/library/unittest.rst:2182 msgid "These must be implemented as class methods::" msgstr "" #: ../Doc/library/unittest.rst:2195 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 "" #: ../Doc/library/unittest.rst:2199 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 "" #: ../Doc/library/unittest.rst:2207 msgid "setUpModule and tearDownModule" msgstr "" #: ../Doc/library/unittest.rst:2209 msgid "These should be implemented as functions::" msgstr "" #: ../Doc/library/unittest.rst:2217 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 "" #: ../Doc/library/unittest.rst:2224 msgid "Signal Handling" msgstr "" #: ../Doc/library/unittest.rst:2228 msgid "" "The :option:`-c/--catch ` 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 "" #: ../Doc/library/unittest.rst:2235 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 "" #: ../Doc/library/unittest.rst:2244 msgid "" "There are a few utility functions for framework authors to enable control-c " "handling functionality within test frameworks." msgstr "" #: ../Doc/library/unittest.rst:2249 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 "" #: ../Doc/library/unittest.rst:2256 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 "" #: ../Doc/library/unittest.rst:2260 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 "" #: ../Doc/library/unittest.rst:2267 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 "" #: ../Doc/library/unittest.rst:2274 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 whilst the test is being executed::" msgstr ""