unittest.mock docs: fix use of default role

2 files changed, 360 insertions, 360 deletions

diff --git a/Doc/library/unittest.mock-examples.rst b/Doc/library/unittest.mock-examples.rst
index 0a3cfb6..b286d74 100644
--- a/Doc/library/unittest.mock-examples.rst
+++ b/Doc/library/unittest.mock-examples.rst
@@ -28,22 +28,22 @@ it is called with the correct arguments by another part of the system:
     >>> real.method(3, 4, 5, key='value')
     <MagicMock name='method()' id='...'>
 
-Once our mock has been used (`real.method` in this example) it has methods
+Once our mock has been used (``real.method`` in this example) it has methods
 and attributes that allow you to make assertions about how it has been used.
 
 .. note::
 
     In most of these examples the :class:`Mock` and :class:`MagicMock` classes
-    are interchangeable. As the `MagicMock` is the more capable class it makes
+    are interchangeable. As the ``MagicMock`` is the more capable class it makes
     a sensible one to use by default.
 
 Once the mock has been called its :attr:`~Mock.called` attribute is set to
-`True`. More importantly we can use the :meth:`~Mock.assert_called_with` or
+``True``. More importantly we can use the :meth:`~Mock.assert_called_with` or
 :meth:`~Mock.assert_called_once_with` method to check that it was called with
 the correct arguments.
 
-This example tests that calling `ProductionClass().method` results in a call to
-the `something` method:
+This example tests that calling ``ProductionClass().method`` results in a call to
+the ``something`` method:
 
     >>> class ProductionClass:
     ...     def method(self):
@@ -66,15 +66,15 @@ was called correctly. Another common use case is to pass an object into a
 method (or some part of the system under test) and then check that it is used
 in the correct way.
 
-The simple `ProductionClass` below has a `closer` method. If it is called with
-an object then it calls `close` on it.
+The simple ``ProductionClass`` below has a ``closer`` method. If it is called with
+an object then it calls ``close`` on it.
 
     >>> class ProductionClass:
     ...     def closer(self, something):
     ...         something.close()
     ...
 
-So to test it we need to pass in an object with a `close` method and check
+So to test it we need to pass in an object with a ``close`` method and check
 that it was called correctly.
 
     >>> real = ProductionClass()
@@ -96,9 +96,9 @@ When you patch a class, then that class is replaced with a mock. Instances
 are created by *calling the class*. This means you access the "mock instance"
 by looking at the return value of the mocked class.
 
-In the example below we have a function `some_function` that instantiates `Foo`
-and calls a method on it. The call to `patch` replaces the class `Foo` with a
-mock. The `Foo` instance is the result of calling the mock, so it is configured
+In the example below we have a function ``some_function`` that instantiates ``Foo``
+and calls a method on it. The call to :func:`patch` replaces the class ``Foo`` with a
+mock. The ``Foo`` instance is the result of calling the mock, so it is configured
 by modifying the mock :attr:`~Mock.return_value`.
 
     >>> def some_function():
@@ -141,13 +141,13 @@ to child attributes of the mock - and also to their children.
     >>> mock.mock_calls
     [call.method(), call.attribute.method(10, x=53)]
 
-If you make an assertion about `mock_calls` and any unexpected methods
+If you make an assertion about ``mock_calls`` and any unexpected methods
 have been called, then the assertion will fail. This is useful because as well
 as asserting that the calls you expected have been made, you are also checking
 that they were made in the right order and with no additional calls:
 
 You use the :data:`call` object to construct lists for comparing with
-`mock_calls`:
+``mock_calls``:
 
     >>> expected = [call.method(), call.attribute.method(10, x=53)]
     >>> mock.mock_calls == expected
@@ -185,7 +185,7 @@ If you need an attribute setting on your mock, just do it:
     3
 
 Sometimes you want to mock up a more complex situation, like for example
-`mock.connection.cursor().execute("SELECT 1")`. If we wanted this call to
+``mock.connection.cursor().execute("SELECT 1")``. If we wanted this call to
 return a list, then we have to configure the result of the nested call.
 
 We can use :data:`call` to construct the set of calls in a "chained call" like
@@ -202,7 +202,7 @@ this for easy assertion afterwards:
     >>> mock.mock_calls == expected
     True
 
-It is the call to `.call_list()` that turns our call object into a list of
+It is the call to ``.call_list()`` that turns our call object into a list of
 calls representing the chained calls.
 
 
@@ -223,10 +223,10 @@ is called.
 Side effect functions and iterables
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-`side_effect` can also be set to a function or an iterable. The use case for
-`side_effect` as an iterable is where your mock is going to be called several
+``side_effect`` can also be set to a function or an iterable. The use case for
+``side_effect`` as an iterable is where your mock is going to be called several
 times, and you want each call to return a different value. When you set
-`side_effect` to an iterable every call to the mock returns the next value
+``side_effect`` to an iterable every call to the mock returns the next value
 from the iterable:
 
     >>> mock = MagicMock(side_effect=[4, 5, 6])
@@ -239,7 +239,7 @@ from the iterable:
 
 
 For more advanced use cases, like dynamically varying the return values
-depending on what the mock is called with, `side_effect` can be a function.
+depending on what the mock is called with, ``side_effect`` can be a function.
 The function will be called with the same arguments as the mock. Whatever the
 function returns is what the call returns:
 
@@ -259,13 +259,13 @@ Creating a Mock from an Existing Object
 
 One problem with over use of mocking is that it couples your tests to the
 implementation of your mocks rather than your real code. Suppose you have a
-class that implements `some_method`. In a test for another class, you
-provide a mock of this object that *also* provides `some_method`. If later
-you refactor the first class, so that it no longer has `some_method` - then
+class that implements ``some_method``. In a test for another class, you
+provide a mock of this object that *also* provides ``some_method``. If later
+you refactor the first class, so that it no longer has ``some_method`` - then
 your tests will continue to pass even though your code is now broken!
 
-`Mock` allows you to provide an object as a specification for the mock,
-using the `spec` keyword argument. Accessing methods / attributes on the
+:class:`Mock` allows you to provide an object as a specification for the mock,
+using the *spec* keyword argument. Accessing methods / attributes on the
 mock that don't exist on your specification object will immediately raise an
 attribute error. If you change the implementation of your specification, then
 tests that use that class will start failing immediately without you having to
@@ -293,7 +293,7 @@ you can use :ref:`auto-speccing <auto-speccing>`.
 
 If you want a stronger form of specification that prevents the setting
 of arbitrary attributes as well as the getting of them then you can use
-`spec_set` instead of `spec`.
+*spec_set* instead of *spec*.
 
 
 
@@ -302,8 +302,8 @@ Patch Decorators
 
 .. note::
 
-   With `patch` it matters that you patch objects in the namespace where they
-   are looked up. This is normally straightforward, but for a quick guide
+   With :func:`patch` it matters that you patch objects in the namespace where
+   they are looked up. This is normally straightforward, but for a quick guide
    read :ref:`where to patch <where-to-patch>`.
 
 
@@ -313,15 +313,15 @@ is instantiated. Modules and classes are effectively global, so patching on
 them has to be undone after the test or the patch will persist into other
 tests and cause hard to diagnose problems.
 
-mock provides three convenient decorators for this: `patch`, `patch.object` and
-`patch.dict`. `patch` takes a single string, of the form
-`package.module.Class.attribute` to specify the attribute you are patching. It
+mock provides three convenient decorators for this: :func:`patch`, :func:`patch.object` and
+:func:`patch.dict`. ``patch`` takes a single string, of the form
+``package.module.Class.attribute`` to specify the attribute you are patching. It
 also optionally takes a value that you want the attribute (or class or
 whatever) to be replaced with. 'patch.object' takes an object and the name of
 the attribute you would like patched, plus optionally the value to patch it
 with.
 
-`patch.object`:
+``patch.object``:
 
     >>> original = SomeClass.attribute
     >>> @patch.object(SomeClass, 'attribute', sentinel.attribute)
@@ -338,8 +338,8 @@ with.
     ...
     >>> test()
 
-If you are patching a module (including :mod:`builtins`) then use `patch`
-instead of `patch.object`:
+If you are patching a module (including :mod:`builtins`) then use :func:`patch`
+instead of :func:`patch.object`:
 
     >>> mock = MagicMock(return_value=sentinel.file_handle)
     >>> with patch('builtins.open', mock):
@@ -348,7 +348,7 @@ instead of `patch.object`:
     >>> mock.assert_called_with('filename', 'r')
     >>> assert handle == sentinel.file_handle, "incorrect file handle returned"
 
-The module name can be 'dotted', in the form `package.module` if needed:
+The module name can be 'dotted', in the form ``package.module`` if needed:
 
     >>> @patch('package.module.ClassName.attribute', sentinel.attribute)
     ... def test():
@@ -368,8 +368,8 @@ A nice pattern is to actually decorate test methods themselves:
     >>> MyTest('test_something').test_something()
     >>> assert SomeClass.attribute == original
 
-If you want to patch with a Mock, you can use `patch` with only one argument
-(or `patch.object` with two arguments). The mock will be created for you and
+If you want to patch with a Mock, you can use :func:`patch` with only one argument
+(or :func:`patch.object` with two arguments). The mock will be created for you and
 passed into the test function / method:
 
     >>> class MyTest(unittest2.TestCase):
@@ -394,7 +394,7 @@ You can stack up multiple patch decorators using this pattern:
 When you nest patch decorators the mocks are passed in to the decorated
 function in the same order they applied (the normal *python* order that
 decorators are applied). This means from the bottom up, so in the example
-above the mock for `test_module.ClassName2` is passed in first.
+above the mock for ``test_module.ClassName2`` is passed in first.
 
 There is also :func:`patch.dict` for setting values in a dictionary just
 during a scope and restoring the dictionary to its original state when the test
@@ -407,9 +407,9 @@ ends:
    ...
    >>> assert foo == original
 
-`patch`, `patch.object` and `patch.dict` can all be used as context managers.
+``patch``, ``patch.object`` and ``patch.dict`` can all be used as context managers.
 
-Where you use `patch` to create a mock for you, you can get a reference to the
+Where you use :func:`patch` to create a mock for you, you can get a reference to the
 mock using the "as" form of the with statement:
 
     >>> class ProductionClass:
@@ -424,7 +424,7 @@ mock using the "as" form of the with statement:
     >>> mock_method.assert_called_with(1, 2, 3)
 
 
-As an alternative `patch`, `patch.object` and `patch.dict` can be used as
+As an alternative ``patch``, ``patch.object`` and ``patch.dict`` can be used as
 class decorators. When used in this way it is the same as applying the
 decorator individually to every method whose name starts with "test".
 
@@ -443,11 +443,11 @@ Mocking chained calls
 
 Mocking chained calls is actually straightforward with mock once you
 understand the :attr:`~Mock.return_value` attribute. When a mock is called for
-the first time, or you fetch its `return_value` before it has been called, a
-new `Mock` is created.
+the first time, or you fetch its ``return_value`` before it has been called, a
+new :class:`Mock` is created.
 
 This means that you can see how the object returned from a call to a mocked
-object has been used by interrogating the `return_value` mock:
+object has been used by interrogating the ``return_value`` mock:
 
     >>> mock = Mock()
     >>> mock().foo(a=2, b=3)
@@ -467,22 +467,22 @@ So, suppose we have some code that looks a little bit like this:
     ...         response = self.backend.get_endpoint('foobar').create_call('spam', 'eggs').start_call()
     ...         # more code
 
-Assuming that `BackendProvider` is already well tested, how do we test
-`method()`? Specifically, we want to test that the code section `# more
-code` uses the response object in the correct way.
+Assuming that ``BackendProvider`` is already well tested, how do we test
+``method()``? Specifically, we want to test that the code section ``# more
+code`` uses the response object in the correct way.
 
 As this chain of calls is made from an instance attribute we can monkey patch
-the `backend` attribute on a `Something` instance. In this particular case
+the ``backend`` attribute on a ``Something`` instance. In this particular case
 we are only interested in the return value from the final call to
-`start_call` so we don't have much configuration to do. Let's assume the
+``start_call`` so we don't have much configuration to do. Let's assume the
 object it returns is 'file-like', so we'll ensure that our response object
-uses the builtin `open` as its `spec`.
+uses the builtin :func:`open` as its ``spec``.
 
 To do this we create a mock instance as our mock backend and create a mock
 response object for it. To set the response as the return value for that final
-`start_call` we could do this:
+``start_call`` we could do this::
 
-    `mock_backend.get_endpoint.return_value.create_call.return_value.start_call.return_value = mock_response`.
+    mock_backend.get_endpoint.return_value.create_call.return_value.start_call.return_value = mock_response
 
 We can do that in a slightly nicer way using the :meth:`~Mock.configure_mock`
 method to directly set the return value for us:
@@ -501,7 +501,7 @@ call:
 
 Using :attr:`~Mock.mock_calls` we can check the chained call with a single
 assert. A chained call is several calls in one line of code, so there will be
-several entries in `mock_calls`. We can use :meth:`call.call_list` to create
+several entries in ``mock_calls``. We can use :meth:`call.call_list` to create
 this list of calls for us:
 
     >>> chained = call.get_endpoint('foobar').create_call('spam', 'eggs').start_call()
@@ -512,20 +512,20 @@ this list of calls for us:
 Partial mocking
 ~~~~~~~~~~~~~~~
 
-In some tests I wanted to mock out a call to :func:`datetime.date.today`
+In some tests I wanted to mock out a call to :meth:`datetime.date.today`
 to return a known date, but I didn't want to prevent the code under test from
-creating new date objects. Unfortunately `datetime.date` is written in C, and
-so I couldn't just monkey-patch out the static `date.today` method.
+creating new date objects. Unfortunately :class:`datetime.date` is written in C, and
+so I couldn't just monkey-patch out the static :meth:`date.today` method.
 
 I found a simple way of doing this that involved effectively wrapping the date
 class with a mock, but passing through calls to the constructor to the real
 class (and returning real instances).
 
 The :func:`patch decorator <patch>` is used here to
-mock out the `date` class in the module under test. The :attr:`side_effect`
+mock out the ``date`` class in the module under test. The :attr:`side_effect`
 attribute on the mock date class is then set to a lambda function that returns
 a real date. When the mock date class is called a real date will be
-constructed and returned by `side_effect`.
+constructed and returned by ``side_effect``.
 
     >>> from datetime import date
     >>> with patch('mymodule.date') as mock_date:
@@ -536,16 +536,16 @@ constructed and returned by `side_effect`.
     ...     assert mymodule.date(2009, 6, 8) == date(2009, 6, 8)
     ...
 
-Note that we don't patch `datetime.date` globally, we patch `date` in the
+Note that we don't patch :class:`datetime.date` globally, we patch ``date`` in the
 module that *uses* it. See :ref:`where to patch <where-to-patch>`.
 
-When `date.today()` is called a known date is returned, but calls to the
-`date(...)` constructor still return normal dates. Without this you can find
+When ``date.today()`` is called a known date is returned, but calls to the
+``date(...)`` constructor still return normal dates. Without this you can find
 yourself having to calculate an expected result using exactly the same
 algorithm as the code under test, which is a classic testing anti-pattern.
 
-Calls to the date constructor are recorded in the `mock_date` attributes
-(`call_count` and friends) which may also be useful for your tests.
+Calls to the date constructor are recorded in the ``mock_date`` attributes
+(``call_count`` and friends) which may also be useful for your tests.
 
 An alternative way of dealing with mocking dates, or other builtin classes,
 is discussed in `this blog entry
@@ -561,7 +561,7 @@ to return a series of values when iterated over [#]_.
 A generator method / function is called to return the generator object. It is
 the generator object that is then iterated over. The protocol method for
 iteration is :meth:`~container.__iter__`, so we can
-mock this using a `MagicMock`.
+mock this using a :class:`MagicMock`.
 
 Here's an example class with an "iter" method implemented as a generator:
 
@@ -578,7 +578,7 @@ Here's an example class with an "iter" method implemented as a generator:
 How would we mock this class, and in particular its "iter" method?
 
 To configure the values returned from the iteration (implicit in the call to
-`list`), we need to configure the object returned by the call to `foo.iter()`.
+:class:`list`), we need to configure the object returned by the call to ``foo.iter()``.
 
     >>> mock_foo = MagicMock()
     >>> mock_foo.iter.return_value = iter([1, 2, 3])
@@ -597,10 +597,10 @@ Applying the same patch to every test method
 
 If you want several patches in place for multiple test methods the obvious way
 is to apply the patch decorators to every method. This can feel like unnecessary
-repetition. For Python 2.6 or more recent you can use `patch` (in all its
+repetition. For Python 2.6 or more recent you can use :func:`patch` (in all its
 various forms) as a class decorator. This applies the patches to all test
 methods on the class. A test method is identified by methods whose names start
-with `test`:
+with ``test``:
 
     >>> @patch('mymodule.SomeClass')
     ... class MyTest(TestCase):
@@ -620,7 +620,7 @@ with `test`:
     'something'
 
 An alternative way of managing patches is to use the :ref:`start-and-stop`.
-These allow you to move the patching into your `setUp` and `tearDown` methods.
+These allow you to move the patching into your ``setUp`` and ``tearDown`` methods.
 
     >>> class MyTest(TestCase):
     ...     def setUp(self):
@@ -636,7 +636,7 @@ These allow you to move the patching into your `setUp` and `tearDown` methods.
     >>> MyTest('test_foo').run()
 
 If you use this technique you must ensure that the patching is "undone" by
-calling `stop`. This can be fiddlier than you might think, because if an
+calling ``stop``. This can be fiddlier than you might think, because if an
 exception is raised in the setUp then tearDown is not called.
 :meth:`unittest.TestCase.addCleanup` makes this easier:
 
@@ -666,13 +666,13 @@ function instead. The :func:`patch` decorator makes it so simple to
 patch out methods with a mock that having to create a real function becomes a
 nuisance.
 
-If you pass `autospec=True` to patch then it does the patching with a
+If you pass ``autospec=True`` to patch then it does the patching with a
 *real* function object. This function object has the same signature as the one
 it is replacing, but delegates to a mock under the hood. You still get your
 mock auto-created in exactly the same way as before. What it means though, is
 that if you use it to patch out an unbound method on a class the mocked
 function will be turned into a bound method if it is fetched from an instance.
-It will have `self` passed in as the first argument, which is exactly what I
+It will have ``self`` passed in as the first argument, which is exactly what I
 wanted:
 
     >>> class Foo:
@@ -687,8 +687,8 @@ wanted:
     'foo'
     >>> mock_foo.assert_called_once_with(foo)
 
-If we don't use `autospec=True` then the unbound method is patched out
-with a Mock instance instead, and isn't called with `self`.
+If we don't use ``autospec=True`` then the unbound method is patched out
+with a Mock instance instead, and isn't called with ``self``.
 
 
 Checking multiple calls with mock
@@ -712,7 +712,7 @@ If your mock is only being called once you can use the
         ...
     AssertionError: Expected to be called once. Called 2 times.
 
-Both `assert_called_with` and `assert_called_once_with` make assertions about
+Both ``assert_called_with`` and ``assert_called_once_with`` make assertions about
 the *most recent* call. If your mock is going to be called several times, and
 you want to make assertions about *all* those calls you can use
 :attr:`~Mock.call_args_list`:
@@ -725,8 +725,8 @@ you want to make assertions about *all* those calls you can use
     [call(1, 2, 3), call(4, 5, 6), call()]
 
 The :data:`call` helper makes it easy to make assertions about these calls. You
-can build up a list of expected calls and compare it to `call_args_list`. This
-looks remarkably similar to the repr of the `call_args_list`:
+can build up a list of expected calls and compare it to ``call_args_list``. This
+looks remarkably similar to the repr of the ``call_args_list``:
 
     >>> expected = [call(1, 2, 3), call(4, 5, 6), call()]
     >>> mock.call_args_list == expected
@@ -737,7 +737,7 @@ Coping with mutable arguments
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Another situation is rare, but can bite you, is when your mock is called with
-mutable arguments. `call_args` and `call_args_list` store *references* to the
+mutable arguments. ``call_args`` and ``call_args_list`` store *references* to the
 arguments. If the arguments are mutated by the code under test then you can no
 longer make assertions about what the values were when the mock was called.
 
@@ -752,7 +752,7 @@ defined in 'mymodule'::
         frob(val)
         val.clear()
 
-When we try to test that `grob` calls `frob` with the correct argument look
+When we try to test that ``grob`` calls ``frob`` with the correct argument look
 what happens:
 
     >>> with patch('mymodule.frob') as mock_frob:
@@ -772,8 +772,8 @@ could then cause problems if you do assertions that rely on object identity
 for equality.
 
 Here's one solution that uses the :attr:`side_effect`
-functionality. If you provide a `side_effect` function for a mock then
-`side_effect` will be called with the same args as the mock. This gives us an
+functionality. If you provide a ``side_effect`` function for a mock then
+``side_effect`` will be called with the same args as the mock. This gives us an
 opportunity to copy the arguments and store them for later assertions. In this
 example I'm using *another* mock to store the arguments so that I can use the
 mock methods for doing the assertion. Again a helper function sets this up for
@@ -800,15 +800,15 @@ me.
     >>> new_mock.call_args
     call(set([6]))
 
-`copy_call_args` is called with the mock that will be called. It returns a new
-mock that we do the assertion on. The `side_effect` function makes a copy of
-the args and calls our `new_mock` with the copy.
+``copy_call_args`` is called with the mock that will be called. It returns a new
+mock that we do the assertion on. The ``side_effect`` function makes a copy of
+the args and calls our ``new_mock`` with the copy.
 
 .. note::
 
     If your mock is only going to be used once there is an easier way of
     checking arguments at the point they are called. You can simply do the
-    checking inside a `side_effect` function.
+    checking inside a ``side_effect`` function.
 
         >>> def side_effect(arg):
         ...     assert arg == set([6])
@@ -820,8 +820,8 @@ the args and calls our `new_mock` with the copy.
             ...
         AssertionError
 
-An alternative approach is to create a subclass of `Mock` or `MagicMock` that
-copies (using :func:`copy.deepcopy`) the arguments.
+An alternative approach is to create a subclass of :class:`Mock` or
+:class:`MagicMock` that copies (using :func:`copy.deepcopy`) the arguments.
 Here's an example implementation:
 
     >>> from copy import deepcopy
@@ -844,9 +844,9 @@ Here's an example implementation:
     >>> c.foo
     <CopyingMock name='mock.foo' id='...'>
 
-When you subclass `Mock` or `MagicMock` all dynamically created attributes,
-and the `return_value` will use your subclass automatically. That means all
-children of a `CopyingMock` will also have the type `CopyingMock`.
+When you subclass ``Mock`` or ``MagicMock`` all dynamically created attributes,
+and the ``return_value`` will use your subclass automatically. That means all
+children of a ``CopyingMock`` will also have the type ``CopyingMock``.
 
 
 Nesting Patches
@@ -870,9 +870,9 @@ right:
     >>> MyTest('test_foo').test_foo()
     >>> assert mymodule.Foo is original
 
-With unittest `cleanup` functions and the :ref:`start-and-stop` we can
+With unittest ``cleanup`` functions and the :ref:`start-and-stop` we can
 achieve the same effect without the nested indentation. A simple helper
-method, `create_patch`, puts the patch in place and returns the created mock
+method, ``create_patch``, puts the patch in place and returns the created mock
 for us:
 
     >>> class MyTest(TestCase):
@@ -907,11 +907,11 @@ We can do this with :class:`MagicMock`, which will behave like a dictionary,
 and using :data:`~Mock.side_effect` to delegate dictionary access to a real
 underlying dictionary that is under our control.
 
-When the `__getitem__` and `__setitem__` methods of our `MagicMock` are called
-(normal dictionary access) then `side_effect` is called with the key (and in
-the case of `__setitem__` the value too). We can also control what is returned.
+When the :meth:`__getitem__` and :meth:`__setitem__` methods of our ``MagicMock`` are called
+(normal dictionary access) then ``side_effect`` is called with the key (and in
+the case of ``__setitem__`` the value too). We can also control what is returned.
 
-After the `MagicMock` has been used we can use attributes like
+After the ``MagicMock`` has been used we can use attributes like
 :data:`~Mock.call_args_list` to assert about how the dictionary was used:
 
     >>> my_dict = {'a': 1, 'b': 2, 'c': 3}
@@ -927,23 +927,23 @@ After the `MagicMock` has been used we can use attributes like
 
 .. note::
 
-    An alternative to using `MagicMock` is to use `Mock` and *only* provide
+    An alternative to using ``MagicMock`` is to use ``Mock`` and *only* provide
     the magic methods you specifically want:
 
         >>> mock = Mock()
         >>> mock.__getitem__ = Mock(side_effect=getitem)
         >>> mock.__setitem__ = Mock(side_effect=setitem)
 
-    A *third* option is to use `MagicMock` but passing in `dict` as the `spec`
-    (or `spec_set`) argument so that the `MagicMock` created only has
+    A *third* option is to use ``MagicMock`` but passing in ``dict`` as the *spec*
+    (or *spec_set*) argument so that the ``MagicMock`` created only has
     dictionary magic methods available:
 
         >>> mock = MagicMock(spec_set=dict)
         >>> mock.__getitem__.side_effect = getitem
         >>> mock.__setitem__.side_effect = setitem
 
-With these side effect functions in place, the `mock` will behave like a normal
-dictionary but recording the access. It even raises a `KeyError` if you try
+With these side effect functions in place, the ``mock`` will behave like a normal
+dictionary but recording the access. It even raises a :exc:`KeyError` if you try
 to access a key that doesn't exist.
 
     >>> mock['a']
@@ -975,8 +975,8 @@ mock methods and attributes:
 Mock subclasses and their attributes
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-There are various reasons why you might want to subclass `Mock`. One reason
-might be to add helper methods. Here's a silly example:
+There are various reasons why you might want to subclass :class:`Mock`. One
+reason might be to add helper methods. Here's a silly example:
 
     >>> class MyMock(MagicMock):
     ...     def has_been_called(self):
@@ -991,9 +991,9 @@ might be to add helper methods. Here's a silly example:
     >>> mymock.has_been_called()
     True
 
-The standard behaviour for `Mock` instances is that attributes and the return
+The standard behaviour for ``Mock`` instances is that attributes and the return
 value mocks are of the same type as the mock they are accessed on. This ensures
-that `Mock` attributes are `Mocks` and `MagicMock` attributes are `MagicMocks`
+that ``Mock`` attributes are ``Mocks`` and ``MagicMock`` attributes are ``MagicMocks``
 [#]_. So if you're subclassing to add helper methods then they'll also be
 available on the attributes and return value mock of instances of your
 subclass.
@@ -1013,10 +1013,10 @@ created a `Twisted adaptor
 <http://twistedmatrix.com/documents/11.0.0/api/twisted.python.components.html>`_.
 Having this applied to attributes too actually causes errors.
 
-`Mock` (in all its flavours) uses a method called `_get_child_mock` to create
+``Mock`` (in all its flavours) uses a method called ``_get_child_mock`` to create
 these "sub-mocks" for attributes and return values. You can prevent your
 subclass being used for attributes by overriding this method. The signature is
-that it takes arbitrary keyword arguments (`**kwargs`) which are then passed
+that it takes arbitrary keyword arguments (``**kwargs``) which are then passed
 onto the mock constructor:
 
     >>> class Subclass(MagicMock):
@@ -1049,17 +1049,17 @@ import. This can also be solved in better ways than an unconditional local
 import (store the module as a class or module attribute and only do the import
 on first use).
 
-That aside there is a way to use `mock` to affect the results of an import.
-Importing fetches an *object* from the `sys.modules` dictionary. Note that it
+That aside there is a way to use ``mock`` to affect the results of an import.
+Importing fetches an *object* from the :data:`sys.modules` dictionary. Note that it
 fetches an *object*, which need not be a module. Importing a module for the
 first time results in a module object being put in `sys.modules`, so usually
 when you import something you get a module back. This need not be the case
 however.
 
 This means you can use :func:`patch.dict` to *temporarily* put a mock in place
-in `sys.modules`. Any imports whilst this patch is active will fetch the mock.
+in :data:`sys.modules`. Any imports whilst this patch is active will fetch the mock.
 When the patch is complete (the decorated function exits, the with statement
-body is complete or `patcher.stop()` is called) then whatever was there
+body is complete or ``patcher.stop()`` is called) then whatever was there
 previously will be restored safely.
 
 Here's an example that mocks out the 'fooble' module.
@@ -1073,10 +1073,10 @@ Here's an example that mocks out the 'fooble' module.
     >>> assert 'fooble' not in sys.modules
     >>> mock.blob.assert_called_once_with()
 
-As you can see the `import fooble` succeeds, but on exit there is no 'fooble'
-left in `sys.modules`.
+As you can see the ``import fooble`` succeeds, but on exit there is no 'fooble'
+left in :data:`sys.modules`.
 
-This also works for the `from module import name` form:
+This also works for the ``from module import name`` form:
 
     >>> mock = Mock()
     >>> with patch.dict('sys.modules', {'fooble': mock}):
@@ -1106,10 +1106,10 @@ your mock objects through the :attr:`~Mock.method_calls` attribute. This
 doesn't allow you to track the order of calls between separate mock objects,
 however we can use :attr:`~Mock.mock_calls` to achieve the same effect.
 
-Because mocks track calls to child mocks in `mock_calls`, and accessing an
+Because mocks track calls to child mocks in ``mock_calls``, and accessing an
 arbitrary attribute of a mock creates a child mock, we can create our separate
 mocks from a parent one. Calls to those child mock will then all be recorded,
-in order, in the `mock_calls` of the parent:
+in order, in the ``mock_calls`` of the parent:
 
     >>> manager = Mock()
     >>> mock_foo = manager.foo
@@ -1124,15 +1124,15 @@ in order, in the `mock_calls` of the parent:
     [call.foo.something(), call.bar.other.thing()]
 
 We can then assert about the calls, including the order, by comparing with
-the `mock_calls` attribute on the manager mock:
+the ``mock_calls`` attribute on the manager mock:
 
     >>> expected_calls = [call.foo.something(), call.bar.other.thing()]
     >>> manager.mock_calls == expected_calls
     True
 
-If `patch` is creating, and putting in place, your mocks then you can attach
+If ``patch`` is creating, and putting in place, your mocks then you can attach
 them to a manager mock using the :meth:`~Mock.attach_mock` method. After
-attaching calls will be recorded in `mock_calls` of the manager.
+attaching calls will be recorded in ``mock_calls`` of the manager.
 
     >>> manager = MagicMock()
     >>> with patch('mymodule.Class1') as MockClass1:
@@ -1164,12 +1164,12 @@ with the :data:`call` object). If that sequence of calls are in
     >>> calls = call.one().two().three().call_list()
     >>> m.assert_has_calls(calls)
 
-Even though the chained call `m.one().two().three()` aren't the only calls that
+Even though the chained call ``m.one().two().three()`` aren't the only calls that
 have been made to the mock, the assert still succeeds.
 
 Sometimes a mock may have several calls made to it, and you are only interested
 in asserting about *some* of those calls. You may not even care about the
-order. In this case you can pass `any_order=True` to `assert_has_calls`:
+order. In this case you can pass ``any_order=True`` to ``assert_has_calls``:
 
     >>> m = MagicMock()
     >>> m(1), m.two(2, 3), m.seven(7), m.fifty('50')
@@ -1191,7 +1191,7 @@ in the exact same object. If we are only interested in some of the attributes
 of this object then we can create a matcher that will check these attributes
 for us.
 
-You can see in this example how a 'standard' call to `assert_called_with` isn't
+You can see in this example how a 'standard' call to ``assert_called_with`` isn't
 sufficient:
 
     >>> class Foo:
@@ -1206,7 +1206,7 @@ sufficient:
     AssertionError: Expected: call(<__main__.Foo object at 0x...>)
     Actual call: call(<__main__.Foo object at 0x...>)
 
-A comparison function for our `Foo` class might look something like this:
+A comparison function for our ``Foo`` class might look something like this:
 
     >>> def compare(self, other):
     ...     if not type(self) == type(other):
@@ -1234,11 +1234,11 @@ Putting all this together:
     >>> match_foo = Matcher(compare, Foo(1, 2))
     >>> mock.assert_called_with(match_foo)
 
-The `Matcher` is instantiated with our compare function and the `Foo` object
-we want to compare against. In `assert_called_with` the `Matcher` equality
+The ``Matcher`` is instantiated with our compare function and the ``Foo`` object
+we want to compare against. In ``assert_called_with`` the ``Matcher`` equality
 method will be called, which compares the object the mock was called with
 against the one we created our matcher with. If they match then
-`assert_called_with` passes, and if they don't an `AssertionError` is raised:
+``assert_called_with`` passes, and if they don't an :exc:`AssertionError` is raised:
 
     >>> match_wrong = Matcher(compare, Foo(3, 4))
     >>> mock.assert_called_with(match_wrong)
@@ -1248,7 +1248,7 @@ against the one we created our matcher with. If they match then
     Called with: ((<Foo object at 0x...>,), {})
 
 With a bit of tweaking you could have the comparison function raise the
-`AssertionError` directly and provide a more useful failure message.
+:exc:`AssertionError` directly and provide a more useful failure message.
 
 As of version 1.5, the Python testing library `PyHamcrest
 <https://pypi.python.org/pypi/PyHamcrest>`_ provides similar functionality,
diff --git a/Doc/library/unittest.mock.rst b/Doc/library/unittest.mock.rst
index cb1bac9..f4d06e0 100644
--- a/Doc/library/unittest.mock.rst
+++ b/Doc/library/unittest.mock.rst
@@ -13,7 +13,7 @@
 replace parts of your system under test with mock objects and make assertions
 about how they have been used.
 
-`unittest.mock` provides a core :class:`Mock` class removing the need to
+:mod:`unittest.mock` provides a core :class:`Mock` class removing the need to
 create a host of stubs throughout your test suite. After performing an
 action, you can make assertions about which methods / attributes were used
 and arguments they were called with. You can also specify return values and
@@ -26,10 +26,10 @@ some examples of how to use :class:`Mock`, :class:`MagicMock` and
 :func:`patch`.
 
 Mock is very easy to use and is designed for use with :mod:`unittest`. Mock
-is based on the 'action -> assertion' pattern instead of `'record -> replay'`
+is based on the 'action -> assertion' pattern instead of 'record -> replay'
 used by many mocking frameworks.
 
-There is a backport of `unittest.mock` for earlier versions of Python,
+There is a backport of :mod:`unittest.mock` for earlier versions of Python,
 available as `mock on PyPI <https://pypi.python.org/pypi/mock>`_.
 
 **Source code:** :source:`Lib/unittest/mock.py`
@@ -71,9 +71,9 @@ exception when a mock is called:
    (5, 4, 3)
 
 Mock has many other ways you can configure it and control its behaviour. For
-example the `spec` argument configures the mock to take its specification
+example the *spec* argument configures the mock to take its specification
 from another object. Attempting to access attributes or methods on the mock
-that don't exist on the spec will fail with an `AttributeError`.
+that don't exist on the spec will fail with an :exc:`AttributeError`.
 
 The :func:`patch` decorator / context manager makes it easy to mock classes or
 objects in a module under test. The object you specify will be replaced with a
@@ -97,13 +97,13 @@ mock (or other object) during the test and restored when the test ends:
    When you nest patch decorators the mocks are passed in to the decorated
    function in the same order they applied (the normal *python* order that
    decorators are applied). This means from the bottom up, so in the example
-   above the mock for `module.ClassName1` is passed in first.
+   above the mock for ``module.ClassName1`` is passed in first.
 
-   With `patch` it matters that you patch objects in the namespace where they
+   With :func:`patch` it matters that you patch objects in the namespace where they
    are looked up. This is normally straightforward, but for a quick guide
    read :ref:`where to patch <where-to-patch>`.
 
-As well as a decorator `patch` can be used as a context manager in a with
+As well as a decorator :func:`patch` can be used as a context manager in a with
 statement:
 
     >>> with patch.object(ProductionClass, 'method', return_value=None) as mock_method:
@@ -135,7 +135,7 @@ allows you to do things like:
     >>> mock.__str__.assert_called_with()
 
 Mock allows you to assign functions (or other Mock instances) to magic methods
-and they will be called appropriately. The `MagicMock` class is just a Mock
+and they will be called appropriately. The :class:`MagicMock` class is just a Mock
 variant that has all of the magic methods pre-created for you (well, all the
 useful ones anyway).
 
@@ -149,7 +149,7 @@ class:
 
 For ensuring that the mock objects in your tests have the same api as the
 objects they are replacing, you can use :ref:`auto-speccing <auto-speccing>`.
-Auto-speccing can be done through the `autospec` argument to patch, or the
+Auto-speccing can be done through the *autospec* argument to patch, or the
 :func:`create_autospec` function. Auto-speccing creates mock objects that
 have the same attributes and methods as the objects they are replacing, and
 any functions and methods (including constructors) have the same call
@@ -171,9 +171,9 @@ code if they are used incorrectly:
     ...
    TypeError: <lambda>() takes exactly 3 arguments (1 given)
 
-`create_autospec` can also be used on classes, where it copies the signature of
-the `__init__` method, and on callable objects where it copies the signature of
-the `__call__` method.
+:func:`create_autospec` can also be used on classes, where it copies the signature of
+the ``__init__`` method, and on callable objects where it copies the signature of
+the ``__call__`` method.
 
 
 
@@ -296,13 +296,13 @@ the `new_callable` argument to `patch`.
     .. method:: assert_has_calls(calls, any_order=False)
 
         assert the mock has been called with the specified calls.
-        The `mock_calls` list is checked for the calls.
+        The :attr:`mock_calls` list is checked for the calls.
 
-        If `any_order` is false (the default) then the calls must be
+        If *any_order* is false (the default) then the calls must be
         sequential. There can be extra calls before or after the
         specified calls.
 
-        If `any_order` is true then the calls can be in any order, but
+        If *any_order* is true then the calls can be in any order, but
         they must all appear in :attr:`mock_calls`.
 
             >>> mock = Mock(return_value=None)
@@ -329,7 +329,7 @@ the `new_callable` argument to `patch`.
             False
 
         This can be useful where you want to make a series of assertions that
-        reuse the same object. Note that `reset_mock` *doesn't* clear the
+        reuse the same object. Note that :meth:`reset_mock` *doesn't* clear the
         return value, :attr:`side_effect` or any child attributes you have
         set using normal assignment. Child mocks and the return value mock
         (if any) are reset as well.
@@ -337,11 +337,11 @@ the `new_callable` argument to `patch`.
 
     .. method:: mock_add_spec(spec, spec_set=False)
 
-        Add a spec to a mock. `spec` can either be an object or a
-        list of strings. Only attributes on the `spec` can be fetched as
+        Add a spec to a mock. *spec* can either be an object or a
+        list of strings. Only attributes on the *spec* can be fetched as
         attributes from the mock.
 
-        If `spec_set` is `True` then only attributes on the spec can be set.
+        If *spec_set* is true then only attributes on the spec can be set.
 
 
     .. method:: attach_mock(mock, attribute)
@@ -382,14 +382,14 @@ the `new_callable` argument to `patch`.
               ...
             KeyError
 
-        `configure_mock` exists to make it easier to do configuration
+        :meth:`configure_mock` exists to make it easier to do configuration
         after the mock has been created.
 
 
     .. method:: __dir__()
 
-        `Mock` objects limit the results of `dir(some_mock)` to useful results.
-        For mocks with a `spec` this includes all the permitted attributes
+        :class:`Mock` objects limit the results of ``dir(some_mock)`` to useful results.
+        For mocks with a *spec* this includes all the permitted attributes
         for the mock.
 
         See :data:`FILTER_DIR` for what this filtering does, and how to
@@ -449,7 +449,7 @@ the `new_callable` argument to `patch`.
             <Mock name='mock()()' id='...'>
             >>> mock.return_value.assert_called_with()
 
-        `return_value` can also be set in the constructor:
+        :attr:`return_value` can also be set in the constructor:
 
             >>> mock = Mock(return_value=3)
             >>> mock.return_value
@@ -479,17 +479,17 @@ the `new_callable` argument to `patch`.
               ...
             Exception: Boom!
 
-        Using `side_effect` to return a sequence of values:
+        Using :attr:`side_effect` to return a sequence of values:
 
             >>> mock = Mock()
             >>> mock.side_effect = [3, 2, 1]
             >>> mock(), mock(), mock()
             (3, 2, 1)
 
-        The `side_effect` function is called with the same arguments as the
+        The :attr:`side_effect` function is called with the same arguments as the
         mock (so it is wise for it to take arbitrary args and keyword
         arguments) and whatever it returns is used as the return value for
-        the call. The exception is if `side_effect` returns :data:`DEFAULT`,
+        the call. The exception is if :attr:`side_effect` returns :data:`DEFAULT`,
         in which case the normal :attr:`return_value` is used.
 
             >>> mock = Mock(return_value=3)
@@ -500,7 +500,7 @@ the `new_callable` argument to `patch`.
             >>> mock()
             3
 
-        `side_effect` can be set in the constructor. Here's an example that
+        :attr:`side_effect` can be set in the constructor. Here's an example that
         adds one to the value the mock is called with and returns it:
 
             >>> side_effect = lambda value: value + 1
@@ -510,7 +510,7 @@ the `new_callable` argument to `patch`.
             >>> mock(-8)
             -7
 
-        Setting `side_effect` to `None` clears it:
+        Setting :attr:`side_effect` to ``None`` clears it:
 
             >>> m = Mock(side_effect=KeyError, return_value=3)
             >>> m()
@@ -524,7 +524,7 @@ the `new_callable` argument to `patch`.
 
     .. attribute:: call_args
 
-        This is either `None` (if the mock hasn't been called), or the
+        This is either ``None`` (if the mock hasn't been called), or the
         arguments that the mock was last called with. This will be in the
         form of a tuple: the first member is any ordered arguments the mock
         was called with (or an empty tuple) and the second member is any
@@ -547,7 +547,7 @@ the `new_callable` argument to `patch`.
             >>> mock.call_args
             call(3, 4, 5, key='fish', next='w00t!')
 
-        `call_args`, along with members of the lists :attr:`call_args_list`,
+        :attr:`call_args`, along with members of the lists :attr:`call_args_list`,
         :attr:`method_calls` and :attr:`mock_calls` are :data:`call` objects.
         These are tuples, so they can be unpacked to get at the individual
         arguments and make more complex assertions. See
@@ -560,7 +560,7 @@ the `new_callable` argument to `patch`.
         (so the length of the list is the number of times it has been
         called). Before any calls have been made it is an empty list. The
         :data:`call` object can be used for conveniently constructing lists of
-        calls to compare with `call_args_list`.
+        calls to compare with :attr:`call_args_list`.
 
             >>> mock = Mock(return_value=None)
             >>> mock()
@@ -572,7 +572,7 @@ the `new_callable` argument to `patch`.
             >>> mock.call_args_list == expected
             True
 
-        Members of `call_args_list` are :data:`call` objects. These can be
+        Members of :attr:`call_args_list` are :data:`call` objects. These can be
         unpacked as tuples to get at the individual arguments. See
         :ref:`calls as tuples <calls-as-tuples>`.
 
@@ -590,15 +590,15 @@ the `new_callable` argument to `patch`.
             >>> mock.method_calls
             [call.method(), call.property.method.attribute()]
 
-        Members of `method_calls` are :data:`call` objects. These can be
+        Members of :attr:`method_calls` are :data:`call` objects. These can be
         unpacked as tuples to get at the individual arguments. See
         :ref:`calls as tuples <calls-as-tuples>`.
 
 
     .. attribute:: mock_calls
 
-        `mock_calls` records *all* calls to the mock object, its methods, magic
-        methods *and* return value mocks.
+        :attr:`mock_calls` records *all* calls to the mock object, its methods,
+        magic methods *and* return value mocks.
 
             >>> mock = MagicMock()
             >>> result = mock(1, 2, 3)
@@ -615,24 +615,24 @@ the `new_callable` argument to `patch`.
             >>> mock.mock_calls == expected
             True
 
-        Members of `mock_calls` are :data:`call` objects. These can be
+        Members of :attr:`mock_calls` are :data:`call` objects. These can be
         unpacked as tuples to get at the individual arguments. See
         :ref:`calls as tuples <calls-as-tuples>`.
 
 
     .. attribute:: __class__
 
-        Normally the `__class__` attribute of an object will return its type.
-        For a mock object with a `spec` `__class__` returns the spec class
-        instead. This allows mock objects to pass `isinstance` tests for the
+        Normally the :attr:`__class__` attribute of an object will return its type.
+        For a mock object with a :attr:`spec`, ``__class__`` returns the spec class
+        instead. This allows mock objects to pass :func:`isinstance` tests for the
         object they are replacing / masquerading as:
 
             >>> mock = Mock(spec=3)
             >>> isinstance(mock, int)
             True
 
-        `__class__` is assignable to, this allows a mock to pass an
-        `isinstance` check without forcing you to use a spec:
+        :attr:`__class__` is assignable to, this allows a mock to pass an
+        :func:`isinstance` check without forcing you to use a spec:
 
             >>> mock = Mock()
             >>> mock.__class__ = dict
@@ -641,12 +641,12 @@ the `new_callable` argument to `patch`.
 
 .. class:: NonCallableMock(spec=None, wraps=None, name=None, spec_set=None, **kwargs)
 
-    A non-callable version of `Mock`. The constructor parameters have the same
-    meaning of `Mock`, with the exception of `return_value` and `side_effect`
+    A non-callable version of :class:`Mock`. The constructor parameters have the same
+    meaning of :class:`Mock`, with the exception of *return_value* and *side_effect*
     which have no meaning on a non-callable mock.
 
-Mock objects that use a class or an instance as a `spec` or `spec_set` are able
-to pass `isinstance` tests:
+Mock objects that use a class or an instance as a :attr:`spec` or
+:attr:`spec_set` are able to pass :func:`isinstance` tests:
 
     >>> mock = Mock(spec=SomeClass)
     >>> isinstance(mock, SomeClass)
@@ -655,11 +655,11 @@ to pass `isinstance` tests:
     >>> isinstance(mock, SomeClass)
     True
 
-The `Mock` classes have support for mocking magic methods. See :ref:`magic
+The :class:`Mock` classes have support for mocking magic methods. See :ref:`magic
 methods <magic-methods>` for the full details.
 
 The mock classes and the :func:`patch` decorators all take arbitrary keyword
-arguments for configuration. For the `patch` decorators the keywords are
+arguments for configuration. For the :func:`patch` decorators the keywords are
 passed to the constructor of the mock being created. The keyword arguments
 are for configuring attributes of the mock:
 
@@ -671,7 +671,7 @@ are for configuring attributes of the mock:
 
 The return value and side effect of child mocks can be set in the same way,
 using dotted notation. As you can't use dotted names directly in a call you
-have to create a dictionary and unpack it using `**`:
+have to create a dictionary and unpack it using ``**``:
 
     >>> attrs = {'method.return_value': 3, 'other.side_effect': KeyError}
     >>> mock = Mock(some_attribute='eggs', **attrs)
@@ -709,10 +709,10 @@ apply to method calls on the mock object.
 .. class:: PropertyMock(*args, **kwargs)
 
    A mock intended to be used as a property, or other descriptor, on a class.
-   `PropertyMock` provides `__get__` and `__set__` methods so you can specify
-   a return value when it is fetched.
+   :class:`PropertyMock` provides :meth:`__get__` and :meth:`__set__` methods
+   so you can specify a return value when it is fetched.
 
-   Fetching a `PropertyMock` instance from an object calls the mock, with
+   Fetching a :class:`PropertyMock` instance from an object calls the mock, with
    no args. Setting it calls the mock with the value being set.
 
         >>> class Foo:
@@ -734,7 +734,7 @@ apply to method calls on the mock object.
         [call(), call(6)]
 
 Because of the way mock attributes are stored you can't directly attach a
-`PropertyMock` to a mock object. Instead you can attach it to the mock type
+:class:`PropertyMock` to a mock object. Instead you can attach it to the mock type
 object::
 
     >>> m = MagicMock()
@@ -758,7 +758,7 @@ Calls made to the object will be recorded in the attributes
 like :attr:`~Mock.call_args` and :attr:`~Mock.call_args_list`.
 
 If :attr:`~Mock.side_effect` is set then it will be called after the call has
-been recorded, so if `side_effect` raises an exception the call is still
+been recorded, so if :attr:`side_effect` raises an exception the call is still
 recorded.
 
 The simplest way to make a mock raise an exception when called is to make
@@ -779,8 +779,8 @@ The simplest way to make a mock raise an exception when called is to make
         >>> m.mock_calls
         [call(1, 2, 3), call('two', 'three', 'four')]
 
-If `side_effect` is a function then whatever that function returns is what
-calls to the mock return. The `side_effect` function is called with the
+If :attr:`side_effect` is a function then whatever that function returns is what
+calls to the mock return. The :attr:`side_effect` function is called with the
 same arguments as the mock. This allows you to vary the return value of the
 call dynamically, based on the input:
 
@@ -797,7 +797,7 @@ call dynamically, based on the input:
 
 If you want the mock to still return the default return value (a new mock), or
 any set return value, then there are two ways of doing this. Either return
-`mock.return_value` from inside `side_effect`, or return :data:`DEFAULT`:
+:attr:`mock.return_value` from inside :attr:`side_effect`, or return :data:`DEFAULT`:
 
         >>> m = MagicMock()
         >>> def side_effect(*args, **kwargs):
@@ -814,8 +814,8 @@ any set return value, then there are two ways of doing this. Either return
         >>> m()
         3
 
-To remove a `side_effect`, and return to the default behaviour, set the
-`side_effect` to `None`:
+To remove a :attr:`side_effect`, and return to the default behaviour, set the
+:attr:`side_effect` to ``None``:
 
         >>> m = MagicMock(return_value=6)
         >>> def side_effect(*args, **kwargs):
@@ -828,9 +828,9 @@ To remove a `side_effect`, and return to the default behaviour, set the
         >>> m()
         6
 
-The `side_effect` can also be any iterable object. Repeated calls to the mock
+The :attr:`side_effect` can also be any iterable object. Repeated calls to the mock
 will return values from the iterable (until the iterable is exhausted and
-a `StopIteration` is raised):
+a :exc:`StopIteration` is raised):
 
         >>> m = MagicMock(side_effect=[1, 2, 3])
         >>> m()
@@ -867,12 +867,12 @@ Deleting Attributes
 Mock objects create attributes on demand. This allows them to pretend to be
 objects of any type.
 
-You may want a mock object to return `False` to a `hasattr` call, or raise an
-`AttributeError` when an attribute is fetched. You can do this by providing
-an object as a `spec` for a mock, but that isn't always convenient.
+You may want a mock object to return ``False`` to a :func:`hasattr` call, or raise an
+:exc:`AttributeError` when an attribute is fetched. You can do this by providing
+an object as a :attr:`spec` for a mock, but that isn't always convenient.
 
 You "block" attributes by deleting them. Once deleted, accessing an attribute
-will raise an `AttributeError`.
+will raise an :exc:`AttributeError`.
 
     >>> mock = MagicMock()
     >>> hasattr(mock, 'm')
@@ -958,7 +958,7 @@ method:
 
 .. [#] The only exceptions are magic methods and attributes (those that have
        leading and trailing double underscores). Mock doesn't create these but
-       instead raises an ``AttributeError``. This is because the interpreter
+       instead raises an :exc:`AttributeError`. This is because the interpreter
        will often implicitly request these methods, and gets *very* confused to
        get a new Mock object when it expects a magic method. If you need magic
        method support see :ref:`magic methods <magic-methods>`.
@@ -978,53 +978,53 @@ patch
 
 .. note::
 
-    `patch` is straightforward to use. The key is to do the patching in the
+    :func:`patch` is straightforward to use. The key is to do the patching in the
     right namespace. See the section `where to patch`_.
 
 .. function:: patch(target, new=DEFAULT, spec=None, create=False, spec_set=None, autospec=None, new_callable=None, **kwargs)
 
-    `patch` acts as a function decorator, class decorator or a context
-    manager. Inside the body of the function or with statement, the `target`
-    is patched with a `new` object. When the function/with statement exits
+    :func:`patch` acts as a function decorator, class decorator or a context
+    manager. Inside the body of the function or with statement, the *target*
+    is patched with a *new* object. When the function/with statement exits
     the patch is undone.
 
-    If `new` is omitted, then the target is replaced with a
-    :class:`MagicMock`. If `patch` is used as a decorator and `new` is
+    If *new* is omitted, then the target is replaced with a
+    :class:`MagicMock`. If :func:`patch` is used as a decorator and *new* is
     omitted, the created mock is passed in as an extra argument to the
-    decorated function. If `patch` is used as a context manager the created
+    decorated function. If :func:`patch` is used as a context manager the created
     mock is returned by the context manager.
 
-    `target` should be a string in the form `'package.module.ClassName'`. The
-    `target` is imported and the specified object replaced with the `new`
-    object, so the `target` must be importable from the environment you are
-    calling `patch` from. The target is imported when the decorated function
+    *target* should be a string in the form ``'package.module.ClassName'``. The
+    *target* is imported and the specified object replaced with the *new*
+    object, so the *target* must be importable from the environment you are
+    calling :func:`patch` from. The target is imported when the decorated function
     is executed, not at decoration time.
 
-    The `spec` and `spec_set` keyword arguments are passed to the `MagicMock`
+    The *spec* and *spec_set* keyword arguments are passed to the :class:`MagicMock`
     if patch is creating one for you.
 
-    In addition you can pass `spec=True` or `spec_set=True`, which causes
+    In addition you can pass ``spec=True`` or ``spec_set=True``, which causes
     patch to pass in the object being mocked as the spec/spec_set object.
 
-    `new_callable` allows you to specify a different class, or callable object,
-    that will be called to create the `new` object. By default `MagicMock` is
+    *new_callable* allows you to specify a different class, or callable object,
+    that will be called to create the *new* object. By default :class:`MagicMock` is
     used.
 
-    A more powerful form of `spec` is `autospec`. If you set `autospec=True`
+    A more powerful form of *spec* is *autospec*. If you set ``autospec=True``
     then the mock with be created with a spec from the object being replaced.
     All attributes of the mock will also have the spec of the corresponding
     attribute of the object being replaced. Methods and functions being mocked
-    will have their arguments checked and will raise a `TypeError` if they are
+    will have their arguments checked and will raise a :exc:`TypeError` if they are
     called with the wrong signature. For mocks
     replacing a class, their return value (the 'instance') will have the same
     spec as the class. See the :func:`create_autospec` function and
     :ref:`auto-speccing`.
 
-    Instead of `autospec=True` you can pass `autospec=some_object` to use an
+    Instead of ``autospec=True`` you can pass ``autospec=some_object`` to use an
     arbitrary object as the spec instead of the one being replaced.
 
-    By default `patch` will fail to replace attributes that don't exist. If
-    you pass in `create=True`, and the attribute doesn't exist, patch will
+    By default :func:`patch` will fail to replace attributes that don't exist. If
+    you pass in ``create=True``, and the attribute doesn't exist, patch will
     create the attribute for you when the patched function is called, and
     delete it again afterwards. This is useful for writing tests against
     attributes that your production code creates at runtime. It is off by
@@ -1059,16 +1059,16 @@ the decorated function:
     >>> function(None)
     True
 
-Patching a class replaces the class with a `MagicMock` *instance*. If the
+Patching a class replaces the class with a :class:`MagicMock` *instance*. If the
 class is instantiated in the code under test then it will be the
 :attr:`~Mock.return_value` of the mock that will be used.
 
 If the class is instantiated multiple times you could use
 :attr:`~Mock.side_effect` to return a new mock each time. Alternatively you
-can set the `return_value` to be anything you want.
+can set the *return_value* to be anything you want.
 
 To configure return values on methods of *instances* on the patched class
-you must do this on the `return_value`. For example:
+you must do this on the :attr:`return_value`. For example:
 
     >>> class Class:
     ...     def method(self):
@@ -1081,7 +1081,7 @@ you must do this on the `return_value`. For example:
     ...     assert Class().method() == 'foo'
     ...
 
-If you use `spec` or `spec_set` and `patch` is replacing a *class*, then the
+If you use *spec* or *spec_set* and :func:`patch` is replacing a *class*, then the
 return value of the created mock will have the same spec.
 
     >>> Original = Class
@@ -1091,7 +1091,7 @@ return value of the created mock will have the same spec.
     >>> assert isinstance(instance, Original)
     >>> patcher.stop()
 
-The `new_callable` argument is useful where you want to use an alternative
+The *new_callable* argument is useful where you want to use an alternative
 class to the default :class:`MagicMock` for the created mock. For example, if
 you wanted a :class:`NonCallableMock` to be used:
 
@@ -1104,7 +1104,7 @@ you wanted a :class:`NonCallableMock` to be used:
       ...
     TypeError: 'NonCallableMock' object is not callable
 
-Another use case might be to replace an object with a `io.StringIO` instance:
+Another use case might be to replace an object with a :class:`io.StringIO` instance:
 
     >>> from io import StringIO
     >>> def foo():
@@ -1117,7 +1117,7 @@ Another use case might be to replace an object with a `io.StringIO` instance:
     ...
     >>> test()
 
-When `patch` is creating a mock for you, it is common that the first thing
+When :func:`patch` is creating a mock for you, it is common that the first thing
 you need to do is to configure the mock. Some of that configuration can be done
 in the call to patch. Any arbitrary keywords you pass into the call will be
 used to set attributes on the created mock:
@@ -1133,7 +1133,7 @@ As well as attributes on the created mock attributes, like the
 :attr:`~Mock.return_value` and :attr:`~Mock.side_effect`, of child mocks can
 also be configured. These aren't syntactically valid to pass in directly as
 keyword arguments, but a dictionary with these as keys can still be expanded
-into a `patch` call using `**`:
+into a :func:`patch` call using ``**``:
 
     >>> config = {'method.return_value': 3, 'other.side_effect': KeyError}
     >>> patcher = patch('__main__.thing', **config)
@@ -1151,19 +1151,19 @@ patch.object
 
 .. function:: patch.object(target, attribute, new=DEFAULT, spec=None, create=False, spec_set=None, autospec=None, new_callable=None, **kwargs)
 
-    patch the named member (`attribute`) on an object (`target`) with a mock
+    patch the named member (*attribute*) on an object (*target*) with a mock
     object.
 
-    `patch.object` can be used as a decorator, class decorator or a context
-    manager. Arguments `new`, `spec`, `create`, `spec_set`, `autospec` and
-    `new_callable` have the same meaning as for `patch`. Like `patch`,
-    `patch.object` takes arbitrary keyword arguments for configuring the mock
+    :func:`patch.object` can be used as a decorator, class decorator or a context
+    manager. Arguments *new*, *spec*, *create*, *spec_set*, *autospec* and
+    *new_callable* have the same meaning as for :func:`patch`. Like :func:`patch`,
+    :func:`patch.object` takes arbitrary keyword arguments for configuring the mock
     object it creates.
 
-    When used as a class decorator `patch.object` honours `patch.TEST_PREFIX`
+    When used as a class decorator :func:`patch.object` honours ``patch.TEST_PREFIX``
     for choosing which methods to wrap.
 
-You can either call `patch.object` with three arguments or two arguments. The
+You can either call :func:`patch.object` with three arguments or two arguments. The
 three argument form takes the object to be patched, the attribute name and the
 object to replace the attribute with.
 
@@ -1178,8 +1178,8 @@ function:
     ...
     >>> test()
 
-`spec`, `create` and the other arguments to `patch.object` have the same
-meaning as they do for `patch`.
+*spec*, *create* and the other arguments to :func:`patch.object` have the same
+meaning as they do for :func:`patch`.
 
 
 patch.dict
@@ -1190,27 +1190,27 @@ patch.dict
     Patch a dictionary, or dictionary like object, and restore the dictionary
     to its original state after the test.
 
-    `in_dict` can be a dictionary or a mapping like container. If it is a
+    *in_dict* can be a dictionary or a mapping like container. If it is a
     mapping then it must at least support getting, setting and deleting items
     plus iterating over keys.
 
-    `in_dict` can also be a string specifying the name of the dictionary, which
+    *in_dict* can also be a string specifying the name of the dictionary, which
     will then be fetched by importing it.
 
-    `values` can be a dictionary of values to set in the dictionary. `values`
-    can also be an iterable of `(key, value)` pairs.
+    *values* can be a dictionary of values to set in the dictionary. *values*
+    can also be an iterable of ``(key, value)`` pairs.
 
-    If `clear` is true then the dictionary will be cleared before the new
+    If *clear* is true then the dictionary will be cleared before the new
     values are set.
 
-    `patch.dict` can also be called with arbitrary keyword arguments to set
+    :func:`patch.dict` can also be called with arbitrary keyword arguments to set
     values in the dictionary.
 
-    `patch.dict` can be used as a context manager, decorator or class
-    decorator. When used as a class decorator `patch.dict` honours
-    `patch.TEST_PREFIX` for choosing which methods to wrap.
+    :func:`patch.dict` can be used as a context manager, decorator or class
+    decorator. When used as a class decorator :func:`patch.dict` honours
+    ``patch.TEST_PREFIX`` for choosing which methods to wrap.
 
-`patch.dict` can be used to add members to a dictionary, or simply let a test
+:func:`patch.dict` can be used to add members to a dictionary, or simply let a test
 change a dictionary, and ensure the dictionary is restored when the test
 ends.
 
@@ -1227,7 +1227,7 @@ ends.
     newvalue
     >>> assert 'newkey' not in os.environ
 
-Keywords can be used in the `patch.dict` call to set values in the dictionary:
+Keywords can be used in the :func:`patch.dict` call to set values in the dictionary:
 
     >>> mymodule = MagicMock()
     >>> mymodule.function.return_value = 'fish'
@@ -1237,11 +1237,11 @@ Keywords can be used in the `patch.dict` call to set values in the dictionary:
     ...
     'fish'
 
-`patch.dict` can be used with dictionary like objects that aren't actually
+:func:`patch.dict` can be used with dictionary like objects that aren't actually
 dictionaries. At the very minimum they must support item getting, setting,
 deleting and either iteration or membership test. This corresponds to the
-magic methods `__getitem__`, `__setitem__`, `__delitem__` and either
-`__iter__` or `__contains__`.
+magic methods :meth:`__getitem__`, :meth:`__setitem__`, :meth:`__delitem__` and either
+:meth:`__iter__` or :meth:`__contains__`.
 
     >>> class Container:
     ...     def __init__(self):
@@ -1277,21 +1277,21 @@ patch.multiple
         with patch.multiple(settings, FIRST_PATCH='one', SECOND_PATCH='two'):
             ...
 
-    Use :data:`DEFAULT` as the value if you want `patch.multiple` to create
+    Use :data:`DEFAULT` as the value if you want :func:`patch.multiple` to create
     mocks for you. In this case the created mocks are passed into a decorated
-    function by keyword, and a dictionary is returned when `patch.multiple` is
+    function by keyword, and a dictionary is returned when :func:`patch.multiple` is
     used as a context manager.
 
-    `patch.multiple` can be used as a decorator, class decorator or a context
-    manager. The arguments `spec`, `spec_set`, `create`, `autospec` and
-    `new_callable` have the same meaning as for `patch`. These arguments will
-    be applied to *all* patches done by `patch.multiple`.
+    :func:`patch.multiple` can be used as a decorator, class decorator or a context
+    manager. The arguments *spec*, *spec_set*, *create*, *autospec* and
+    *new_callable* have the same meaning as for :func:`patch`. These arguments will
+    be applied to *all* patches done by :func:`patch.multiple`.
 
-    When used as a class decorator `patch.multiple` honours `patch.TEST_PREFIX`
+    When used as a class decorator :func:`patch.multiple` honours ``patch.TEST_PREFIX``
     for choosing which methods to wrap.
 
-If you want `patch.multiple` to create mocks for you, then you can use
-:data:`DEFAULT` as the value. If you use `patch.multiple` as a decorator
+If you want :func:`patch.multiple` to create mocks for you, then you can use
+:data:`DEFAULT` as the value. If you use :func:`patch.multiple` as a decorator
 then the created mocks are passed into the decorated function by keyword.
 
     >>> thing = object()
@@ -1304,8 +1304,8 @@ then the created mocks are passed into the decorated function by keyword.
     ...
     >>> test_function()
 
-`patch.multiple` can be nested with other `patch` decorators, but put arguments
-passed by keyword *after* any of the standard arguments created by `patch`:
+:func:`patch.multiple` can be nested with other ``patch`` decorators, but put arguments
+passed by keyword *after* any of the standard arguments created by :func:`patch`:
 
     >>> @patch('sys.exit')
     ... @patch.multiple('__main__', thing=DEFAULT, other=DEFAULT)
@@ -1316,7 +1316,7 @@ passed by keyword *after* any of the standard arguments created by `patch`:
     ...
     >>> test_function()
 
-If `patch.multiple` is used as a context manager, the value returned by the
+If :func:`patch.multiple` is used as a context manager, the value returned by the
 context manger is a dictionary where created mocks are keyed by name:
 
     >>> with patch.multiple('__main__', thing=DEFAULT, other=DEFAULT) as values:
@@ -1332,16 +1332,16 @@ context manger is a dictionary where created mocks are keyed by name:
 patch methods: start and stop
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-All the patchers have `start` and `stop` methods. These make it simpler to do
-patching in `setUp` methods or where you want to do multiple patches without
+All the patchers have :meth:`start` and :meth:`stop` methods. These make it simpler to do
+patching in ``setUp`` methods or where you want to do multiple patches without
 nesting decorators or with statements.
 
-To use them call `patch`, `patch.object` or `patch.dict` as normal and keep a
-reference to the returned `patcher` object. You can then call `start` to put
-the patch in place and `stop` to undo it.
+To use them call :func:`patch`, :func:`patch.object` or :func:`patch.dict` as
+normal and keep a reference to the returned ``patcher`` object. You can then
+call :meth:`start` to put the patch in place and :meth:`stop` to undo it.
 
-If you are using `patch` to create a mock for you then it will be returned by
-the call to `patcher.start`.
+If you are using :func:`patch` to create a mock for you then it will be returned by
+the call to ``patcher.start``.
 
     >>> patcher = patch('package.module.ClassName')
     >>> from package import module
@@ -1354,8 +1354,8 @@ the call to `patcher.start`.
     >>> assert module.ClassName is not new_mock
 
 
-A typical use case for this might be for doing multiple patches in the `setUp`
-method of a `TestCase`:
+A typical use case for this might be for doing multiple patches in the ``setUp``
+method of a :class:`TestCase`:
 
     >>> class MyTest(TestCase):
     ...     def setUp(self):
@@ -1377,7 +1377,7 @@ method of a `TestCase`:
 .. caution::
 
     If you use this technique you must ensure that the patching is "undone" by
-    calling `stop`. This can be fiddlier than you might think, because if an
+    calling ``stop``. This can be fiddlier than you might think, because if an
     exception is raised in the ``setUp`` then ``tearDown`` is not called.
     :meth:`unittest.TestCase.addCleanup` makes this easier:
 
@@ -1407,11 +1407,11 @@ TEST_PREFIX
 
 All of the patchers can be used as class decorators. When used in this way
 they wrap every test method on the class. The patchers recognise methods that
-start with `test` as being test methods. This is the same way that the
+start with ``'test'`` as being test methods. This is the same way that the
 :class:`unittest.TestLoader` finds test methods by default.
 
 It is possible that you want to use a different prefix for your tests. You can
-inform the patchers of the different prefix by setting `patch.TEST_PREFIX`:
+inform the patchers of the different prefix by setting ``patch.TEST_PREFIX``:
 
     >>> patch.TEST_PREFIX = 'foo'
     >>> value = 3
@@ -1464,7 +1464,7 @@ passed into your test function matches this order.
 Where to patch
 ~~~~~~~~~~~~~~
 
-`patch` works by (temporarily) changing the object that a *name* points to with
+:func:`patch` works by (temporarily) changing the object that a *name* points to with
 another one. There can be many names pointing to any individual object, so
 for patching to work you must ensure that you patch the name used by the system
 under test.
@@ -1482,23 +1482,23 @@ Imagine we have a project that we want to test with the following structure::
         -> from a import SomeClass
         -> some_function instantiates SomeClass
 
-Now we want to test `some_function` but we want to mock out `SomeClass` using
-`patch`. The problem is that when we import module b, which we will have to
-do then it imports `SomeClass` from module a. If we use `patch` to mock out
-`a.SomeClass` then it will have no effect on our test; module b already has a
-reference to the *real* `SomeClass` and it looks like our patching had no
+Now we want to test ``some_function`` but we want to mock out ``SomeClass`` using
+:func:`patch`. The problem is that when we import module b, which we will have to
+do then it imports ``SomeClass`` from module a. If we use :func:`patch` to mock out
+``a.SomeClass`` then it will have no effect on our test; module b already has a
+reference to the *real* ``SomeClass`` and it looks like our patching had no
 effect.
 
-The key is to patch out `SomeClass` where it is used (or where it is looked up
-). In this case `some_function` will actually look up `SomeClass` in module b,
+The key is to patch out ``SomeClass`` where it is used (or where it is looked up
+). In this case ``some_function`` will actually look up ``SomeClass`` in module b,
 where we have imported it. The patching should look like::
 
     @patch('b.SomeClass')
 
-However, consider the alternative scenario where instead of `from a import
-SomeClass` module b does `import a` and `some_function` uses `a.SomeClass`. Both
+However, consider the alternative scenario where instead of ``from a import
+SomeClass`` module b does ``import a`` and ``some_function`` uses ``a.SomeClass``. Both
 of these import forms are common. In this case the class we want to patch is
-being looked up on the a module and so we have to patch `a.SomeClass` instead::
+being looked up on the a module and so we have to patch ``a.SomeClass`` instead::
 
     @patch('a.SomeClass')
 
@@ -1554,7 +1554,7 @@ the first argument [#]_.
    []
 
 One use case for this is for mocking objects used as context managers in a
-`with` statement:
+:keyword:`with` statement:
 
    >>> mock = Mock()
    >>> mock.__enter__ = Mock(return_value='foo')
@@ -1570,8 +1570,8 @@ are recorded in :attr:`~Mock.mock_calls`.
 
 .. note::
 
-   If you use the `spec` keyword argument to create a mock then attempting to
-   set a magic method that isn't in the spec will raise an `AttributeError`.
+   If you use the *spec* keyword argument to create a mock then attempting to
+   set a magic method that isn't in the spec will raise an :exc:`AttributeError`.
 
 The full list of supported magic methods is:
 
@@ -1607,7 +1607,7 @@ by mock, can't be set dynamically, or can cause problems:
 Magic Mock
 ~~~~~~~~~~
 
-There are two `MagicMock` variants: `MagicMock` and `NonCallableMagicMock`.
+There are two ``MagicMock`` variants: :class:`MagicMock` and :class:`NonCallableMagicMock`.
 
 
 .. class:: MagicMock(*args, **kw)
@@ -1618,19 +1618,19 @@ There are two `MagicMock` variants: `MagicMock` and `NonCallableMagicMock`.
 
    The constructor parameters have the same meaning as for :class:`Mock`.
 
-   If you use the `spec` or `spec_set` arguments then *only* magic methods
+   If you use the *spec* or *spec_set* arguments then *only* magic methods
    that exist in the spec will be created.
 
 
 .. class:: NonCallableMagicMock(*args, **kw)
 
-    A non-callable version of `MagicMock`.
+    A non-callable version of :class:`MagicMock`.
 
     The constructor parameters have the same meaning as for
-    :class:`MagicMock`, with the exception of `return_value` and
-    `side_effect` which have no meaning on a non-callable mock.
+    :class:`MagicMock`, with the exception of *return_value* and
+    *side_effect* which have no meaning on a non-callable mock.
 
-The magic methods are setup with `MagicMock` objects, so you can configure them
+The magic methods are setup with :class:`MagicMock` objects, so you can configure them
 and use them in the usual way:
 
    >>> mock = MagicMock()
@@ -1677,7 +1677,7 @@ For example:
    >>> object() in mock
    False
 
-The two equality method, `__eq__` and `__ne__`, are special.
+The two equality method, :meth:`__eq__` and :meth:`__ne__`, are special.
 They do the default equality comparison on identity, using a side
 effect, unless you change their return value to return something else:
 
@@ -1690,7 +1690,7 @@ effect, unless you change their return value to return something else:
    >>> mock == 3
    True
 
-The return value of `MagicMock.__iter__` can be any iterable object and isn't
+The return value of :meth:`MagicMock.__iter__` can be any iterable object and isn't
 required to be an iterator:
 
    >>> mock = MagicMock()
@@ -1750,10 +1750,10 @@ sentinel
 
 Sometimes when testing you need to test that a specific object is passed as an
 argument to another method, or returned. It can be common to create named
-sentinel objects to test this. `sentinel` provides a convenient way of
+sentinel objects to test this. :data:`sentinel` provides a convenient way of
 creating and testing the identity of objects like this.
 
-In this example we monkey patch `method` to return `sentinel.some_object`:
+In this example we monkey patch ``method`` to return ``sentinel.some_object``:
 
     >>> real = ProductionClass()
     >>> real.method = Mock(name="method")
@@ -1770,8 +1770,8 @@ DEFAULT
 
 .. data:: DEFAULT
 
-    The `DEFAULT` object is a pre-created sentinel (actually
-    `sentinel.DEFAULT`). It can be used by :attr:`~Mock.side_effect`
+    The :data:`DEFAULT` object is a pre-created sentinel (actually
+    ``sentinel.DEFAULT``). It can be used by :attr:`~Mock.side_effect`
     functions to indicate that the normal return value should be used.
 
 
@@ -1780,9 +1780,9 @@ call
 
 .. function:: call(*args, **kwargs)
 
-    `call` is a helper object for making simpler assertions, for comparing with
+    :func:`call` is a helper object for making simpler assertions, for comparing with
     :attr:`~Mock.call_args`, :attr:`~Mock.call_args_list`,
-    :attr:`~Mock.mock_calls` and :attr:`~Mock.method_calls`. `call` can also be
+    :attr:`~Mock.mock_calls` and :attr:`~Mock.method_calls`. :func:`call` can also be
     used with :meth:`~Mock.assert_has_calls`.
 
         >>> m = MagicMock(return_value=None)
@@ -1793,11 +1793,11 @@ call
 
 .. method:: call.call_list()
 
-    For a call object that represents multiple calls, `call_list`
+    For a call object that represents multiple calls, :meth:`call_list`
     returns a list of all the intermediate calls as well as the
     final call.
 
-`call_list` is particularly useful for making assertions on "chained calls". A
+``call_list`` is particularly useful for making assertions on "chained calls". A
 chained call is multiple calls on a single line of code. This results in
 multiple entries in :attr:`~Mock.mock_calls` on a mock. Manually constructing
 the sequence of calls can be tedious.
@@ -1819,15 +1819,15 @@ chained call:
 
 .. _calls-as-tuples:
 
-A `call` object is either a tuple of (positional args, keyword args) or
+A ``call`` object is either a tuple of (positional args, keyword args) or
 (name, positional args, keyword args) depending on how it was constructed. When
-you construct them yourself this isn't particularly interesting, but the `call`
+you construct them yourself this isn't particularly interesting, but the ``call``
 objects that are in the :attr:`Mock.call_args`, :attr:`Mock.call_args_list` and
 :attr:`Mock.mock_calls` attributes can be introspected to get at the individual
 arguments they contain.
 
-The `call` objects in :attr:`Mock.call_args` and :attr:`Mock.call_args_list`
-are two-tuples of (positional args, keyword args) whereas the `call` objects
+The ``call`` objects in :attr:`Mock.call_args` and :attr:`Mock.call_args_list`
+are two-tuples of (positional args, keyword args) whereas the ``call`` objects
 in :attr:`Mock.mock_calls`, along with ones you construct yourself, are
 three-tuples of (name, positional args, keyword args).
 
@@ -1870,25 +1870,25 @@ create_autospec
 .. function:: create_autospec(spec, spec_set=False, instance=False, **kwargs)
 
     Create a mock object using another object as a spec. Attributes on the
-    mock will use the corresponding attribute on the `spec` object as their
+    mock will use the corresponding attribute on the *spec* object as their
     spec.
 
     Functions or methods being mocked will have their arguments checked to
     ensure that they are called with the correct signature.
 
-    If `spec_set` is `True` then attempting to set attributes that don't exist
-    on the spec object will raise an `AttributeError`.
+    If *spec_set* is ``True`` then attempting to set attributes that don't exist
+    on the spec object will raise an :exc:`AttributeError`.
 
     If a class is used as a spec then the return value of the mock (the
     instance of the class) will have the same spec. You can use a class as the
-    spec for an instance object by passing `instance=True`. The returned mock
+    spec for an instance object by passing ``instance=True``. The returned mock
     will only be callable if instances of the mock are callable.
 
-    `create_autospec` also takes arbitrary keyword arguments that are passed to
+    :func:`create_autospec` also takes arbitrary keyword arguments that are passed to
     the constructor of the created mock.
 
 See :ref:`auto-speccing` for examples of how to use auto-speccing with
-`create_autospec` and the `autospec` argument to :func:`patch`.
+:func:`create_autospec` and the *autospec* argument to :func:`patch`.
 
 
 ANY
@@ -1910,7 +1910,7 @@ passed in.
     >>> mock('foo', bar=object())
     >>> mock.assert_called_once_with('foo', bar=ANY)
 
-`ANY` can also be used in comparisons with call lists like
+:data:`ANY` can also be used in comparisons with call lists like
 :attr:`~Mock.mock_calls`:
 
     >>> m = MagicMock(return_value=None)
@@ -1927,15 +1927,15 @@ FILTER_DIR
 
 .. data:: FILTER_DIR
 
-`FILTER_DIR` is a module level variable that controls the way mock objects
-respond to `dir` (only for Python 2.6 or more recent). The default is `True`,
+:data:`FILTER_DIR` is a module level variable that controls the way mock objects
+respond to :func:`dir` (only for Python 2.6 or more recent). The default is ``True``,
 which uses the filtering described below, to only show useful members. If you
 dislike this filtering, or need to switch it off for diagnostic purposes, then
-set `mock.FILTER_DIR = False`.
+set ``mock.FILTER_DIR = False``.
 
-With filtering on, `dir(some_mock)` shows only useful attributes and will
+With filtering on, ``dir(some_mock)`` shows only useful attributes and will
 include any dynamically created attributes that wouldn't normally be shown.
-If the mock was created with a `spec` (or `autospec` of course) then all the
+If the mock was created with a *spec* (or *autospec* of course) then all the
 attributes from the original are shown, even if they haven't been accessed
 yet:
 
@@ -1954,11 +1954,11 @@ yet:
      'BaseHandler',
      ...
 
-Many of the not-very-useful (private to `Mock` rather than the thing being
+Many of the not-very-useful (private to :class:`Mock` rather than the thing being
 mocked) underscore and double underscore prefixed attributes have been
-filtered from the result of calling `dir` on a `Mock`. If you dislike this
+filtered from the result of calling :func:`dir` on a :class:`Mock`. If you dislike this
 behaviour you can switch it off by setting the module level switch
-`FILTER_DIR`:
+:data:`FILTER_DIR`:
 
     >>> from unittest import mock
     >>> mock.FILTER_DIR = False
@@ -1972,9 +1972,9 @@ behaviour you can switch it off by setting the module level switch
      '__class__',
      ...
 
-Alternatively you can just use `vars(my_mock)` (instance members) and
-`dir(type(my_mock))` (type members) to bypass the filtering irrespective of
-`mock.FILTER_DIR`.
+Alternatively you can just use ``vars(my_mock)`` (instance members) and
+``dir(type(my_mock))`` (type members) to bypass the filtering irrespective of
+:data:`mock.FILTER_DIR`.
 
 
 mock_open
@@ -1982,30 +1982,30 @@ mock_open
 
 .. function:: mock_open(mock=None, read_data=None)
 
-    A helper function to create a mock to replace the use of `open`. It works
-    for `open` called directly or used as a context manager.
+    A helper function to create a mock to replace the use of :func:`open`. It works
+    for :func:`open` called directly or used as a context manager.
 
-    The `mock` argument is the mock object to configure. If `None` (the
-    default) then a `MagicMock` will be created for you, with the API limited
+    The *mock* argument is the mock object to configure. If ``None`` (the
+    default) then a :class:`MagicMock` will be created for you, with the API limited
     to methods or attributes available on standard file handles.
 
-    `read_data` is a string for the :meth:`~io.IOBase.read`,
+    *read_data* is a string for the :meth:`~io.IOBase.read`,
     :meth:`~io.IOBase.readline`, and :meth:`~io.IOBase.readlines` methods
     of the file handle to return.  Calls to those methods will take data from
-    `read_data` until it is depleted.  The mock of these methods is pretty
+    *read_data* until it is depleted.  The mock of these methods is pretty
     simplistic.  If you need more control over the data that you are feeding to
     the tested code you will need to customize this mock for yourself.
-    `read_data` is an empty string by default.
+    *read_data* is an empty string by default.
 
-Using `open` as a context manager is a great way to ensure your file handles
+Using :func:`open` as a context manager is a great way to ensure your file handles
 are closed properly and is becoming common::
 
     with open('/some/path', 'w') as f:
         f.write('something')
 
-The issue is that even if you mock out the call to `open` it is the
-*returned object* that is used as a context manager (and has `__enter__` and
-`__exit__` called).
+The issue is that even if you mock out the call to :func:`open` it is the
+*returned object* that is used as a context manager (and has :meth:`__enter__` and
+:meth:`__exit__` called).
 
 Mocking context managers with a :class:`MagicMock` is common enough and fiddly
 enough that a helper function is useful.
@@ -2039,21 +2039,21 @@ And for reading files:
 Autospeccing
 ~~~~~~~~~~~~
 
-Autospeccing is based on the existing `spec` feature of mock. It limits the
+Autospeccing is based on the existing :attr:`spec` feature of mock. It limits the
 api of mocks to the api of an original object (the spec), but it is recursive
 (implemented lazily) so that attributes of mocks only have the same api as
 the attributes of the spec. In addition mocked functions / methods have the
-same call signature as the original so they raise a `TypeError` if they are
+same call signature as the original so they raise a :exc:`TypeError` if they are
 called incorrectly.
 
 Before I explain how auto-speccing works, here's why it is needed.
 
-`Mock` is a very powerful and flexible object, but it suffers from two flaws
+:class:`Mock` is a very powerful and flexible object, but it suffers from two flaws
 when used to mock out objects from a system under test. One of these flaws is
-specific to the `Mock` api and the other is a more general problem with using
+specific to the :class:`Mock` api and the other is a more general problem with using
 mock objects.
 
-First the problem specific to `Mock`. `Mock` has two assert methods that are
+First the problem specific to :class:`Mock`. :class:`Mock` has two assert methods that are
 extremely handy: :meth:`~Mock.assert_called_with` and
 :meth:`~Mock.assert_called_once_with`.
 
@@ -2088,8 +2088,8 @@ unit tests. Testing everything in isolation is all fine and dandy, but if you
 don't test how your units are "wired together" there is still lots of room
 for bugs that tests might have caught.
 
-`mock` already provides a feature to help with this, called speccing. If you
-use a class or instance as the `spec` for a mock then you can only access
+:mod:`mock` already provides a feature to help with this, called speccing. If you
+use a class or instance as the :attr:`spec` for a mock then you can only access
 attributes on the mock that exist on the real class:
 
     >>> from urllib import request
@@ -2108,9 +2108,9 @@ with any methods on the mock:
     <mock.Mock object at 0x...>
     >>> mock.has_data.assret_called_with()
 
-Auto-speccing solves this problem. You can either pass `autospec=True` to
-`patch` / `patch.object` or use the `create_autospec` function to create a
-mock with a spec. If you use the `autospec=True` argument to `patch` then the
+Auto-speccing solves this problem. You can either pass ``autospec=True`` to
+:func:`patch` / :func:`patch.object` or use the :func:`create_autospec` function to create a
+mock with a spec. If you use the ``autospec=True`` argument to :func:`patch` then the
 object that is being replaced will be used as the spec object. Because the
 speccing is done "lazily" (the spec is created as attributes on the mock are
 accessed) you can use it with very complex or deeply nested objects (like
@@ -2127,8 +2127,8 @@ Here's an example of it in use:
     >>> mock_request.Request
     <MagicMock name='request.Request' spec='Request' id='...'>
 
-You can see that `request.Request` has a spec. `request.Request` takes two
-arguments in the constructor (one of which is `self`). Here's what happens if
+You can see that :class:`request.Request` has a spec. :class:`request.Request` takes two
+arguments in the constructor (one of which is *self*). Here's what happens if
 we try to call it incorrectly:
 
     >>> req = request.Request()
@@ -2143,8 +2143,8 @@ specced mocks):
     >>> req
     <NonCallableMagicMock name='request.Request()' spec='Request' id='...'>
 
-`Request` objects are not callable, so the return value of instantiating our
-mocked out `request.Request` is a non-callable mock. With the spec in place
+:class:`Request` objects are not callable, so the return value of instantiating our
+mocked out :class:`request.Request` is a non-callable mock. With the spec in place
 any typos in our asserts will raise the correct error:
 
     >>> req.add_header('spam', 'eggs')
@@ -2155,11 +2155,11 @@ any typos in our asserts will raise the correct error:
     AttributeError: Mock object has no attribute 'assret_called_with'
     >>> req.add_header.assert_called_with('spam', 'eggs')
 
-In many cases you will just be able to add `autospec=True` to your existing
-`patch` calls and then be protected against bugs due to typos and api
+In many cases you will just be able to add ``autospec=True`` to your existing
+:func:`patch` calls and then be protected against bugs due to typos and api
 changes.
 
-As well as using `autospec` through `patch` there is a
+As well as using *autospec* through :func:`patch` there is a
 :func:`create_autospec` for creating autospecced mocks directly:
 
     >>> from urllib import request
@@ -2177,8 +2177,8 @@ able to use autospec. On the other hand it is much better to design your
 objects so that introspection is safe [#]_.
 
 A more serious problem is that it is common for instance attributes to be
-created in the `__init__` method and not to exist on the class at all.
-`autospec` can't know about any dynamically created attributes and restricts
+created in the :meth:`__init__` method and not to exist on the class at all.
+*autospec* can't know about any dynamically created attributes and restricts
 the api to visible attributes.
 
     >>> class Something:
@@ -2195,7 +2195,7 @@ the api to visible attributes.
 
 There are a few different ways of resolving this problem. The easiest, but
 not necessarily the least annoying, way is to simply set the required
-attributes on the mock after creation. Just because `autospec` doesn't allow
+attributes on the mock after creation. Just because *autospec* doesn't allow
 you to fetch attributes that don't exist on the spec it doesn't prevent you
 setting them:
 
@@ -2204,7 +2204,7 @@ setting them:
     ...   thing.a = 33
     ...
 
-There is a more aggressive version of both `spec` and `autospec` that *does*
+There is a more aggressive version of both *spec* and *autospec* that *does*
 prevent you setting non-existent attributes. This is useful if you want to
 ensure your code only *sets* valid attributes too, but obviously it prevents
 this particular scenario:
@@ -2218,8 +2218,8 @@ this particular scenario:
     AttributeError: Mock object has no attribute 'a'
 
 Probably the best way of solving the problem is to add class attributes as
-default values for instance members initialised in `__init__`. Note that if
-you are only setting default attributes in `__init__` then providing them via
+default values for instance members initialised in :meth:`__init__`. Note that if
+you are only setting default attributes in :meth:`__init__` then providing them via
 class attributes (shared between instances of course) is faster too. e.g.
 
 .. code-block:: python
@@ -2228,12 +2228,12 @@ class attributes (shared between instances of course) is faster too. e.g.
         a = 33
 
 This brings up another issue. It is relatively common to provide a default
-value of `None` for members that will later be an object of a different type.
-`None` would be useless as a spec because it wouldn't let you access *any*
-attributes or methods on it. As `None` is *never* going to be useful as a
+value of ``None`` for members that will later be an object of a different type.
+``None`` would be useless as a spec because it wouldn't let you access *any*
+attributes or methods on it. As ``None`` is *never* going to be useful as a
 spec, and probably indicates a member that will normally of some other type,
-`autospec` doesn't use a spec for members that are set to `None`. These will
-just be ordinary mocks (well - `MagicMocks`):
+autospec doesn't use a spec for members that are set to ``None``. These will
+just be ordinary mocks (well - MagicMocks):
 
     >>> class Something:
     ...     member = None
@@ -2247,8 +2247,8 @@ then there are more options. One of these is simply to use an instance as the
 spec rather than the class. The other is to create a subclass of the
 production class and add the defaults to the subclass without affecting the
 production class. Both of these require you to use an alternative object as
-the spec. Thankfully `patch` supports this - you can simply pass the
-alternative object as the `autospec` argument:
+the spec. Thankfully :func:`patch` supports this - you can simply pass the
+alternative object as the *autospec* argument:
 
     >>> class Something:
     ...   def __init__(self):
@@ -2265,5 +2265,5 @@ alternative object as the `autospec` argument:
 
 .. [#] This only applies to classes or already instantiated objects. Calling
    a mocked class to create a mock instance *does not* create a real instance.
-   It is only attribute lookups - along with calls to `dir` - that are done.
+   It is only attribute lookups - along with calls to :func:`dir` - that are done.