def next_call(self, for_method=None):
        """Start expecting or providing multiple calls.

        .. note:: next_call() cannot be used in combination with :func:`fudge.Fake.times_called`

        Up until calling this method, calls are infinite.

        For example, before next_call() ... ::

            >>> from fudge import Fake
            >>> f = Fake().provides('status').returns('Awake!')
            >>> f.status()
            'Awake!'
            >>> f.status()
            'Awake!'

        After next_call() ... ::

            >>> from fudge import Fake
            >>> f = Fake().provides('status').returns('Awake!')
            >>> f = f.next_call().returns('Asleep')
            >>> f = f.next_call().returns('Dreaming')
            >>> f.status()
            'Awake!'
            >>> f.status()
            'Asleep'
            >>> f.status()
            'Dreaming'
            >>> f.status()
            Traceback (most recent call last):
            ...
            AssertionError: This attribute of fake:unnamed can only be called 3 time(s).  Call reset() if necessary or fudge.clear_calls().

        If you need to affect the next call of something other than the last declared call,
        use ``next_call(for_method="other_call")``.  Here is an example using getters and setters
        on a session object ::

            >>> from fudge import Fake
            >>> sess = Fake('session').provides('get_count').returns(1)
            >>> sess = sess.provides('set_count').with_args(5)

        Now go back and adjust return values for get_count() ::

            >>> sess = sess.next_call(for_method='get_count').returns(5)

        This allows these calls to be made ::

            >>> sess.get_count()
            1
            >>> sess.set_count(5)
            >>> sess.get_count()
            5

        When using :func:`fudge.Fake.remember_order` in combination with :func:`fudge.Fake.expects` and :func:`fudge.Fake.next_call` each new call will be part of the expected order.

        """
        last_call_name = self._last_declared_call_name
        if for_method:
            if for_method not in self._declared_calls:
                raise FakeDeclarationError(
                            "next_call(for_method=%r) is not possible; "
                            "declare expects(%r) or provides(%r) first" % (
                                                        for_method, for_method, for_method))
            else:
                # set this for the local function:
                last_call_name = for_method
                # reset this for subsequent methods:
                self._last_declared_call_name = last_call_name

        if last_call_name:
            exp = self._declared_calls[last_call_name]
        elif self._callable:
            exp = self._callable
        else:
            raise FakeDeclarationError('next_call() must follow provides(), '
                                       'expects() or is_callable()')

        if getattr(exp, 'expected_times_called', None) is not None:
            raise FakeDeclarationError("Cannot use next_call() in combination with times_called()")

        if not isinstance(exp, CallStack):
            # lazily create a stack with the last defined
            # expected call as the first on the stack:
            stack = CallStack(self, initial_calls=[exp],
                                    expected=isinstance(exp, ExpectedCall),
                                    call_name=exp.call_name)

            # replace the old call obj using the same name:
            if last_call_name:
                self._declare_call(last_call_name, stack)
            elif self._callable:
                self._callable = stack
        else:
            stack = exp

        # hmm, we need a copy here so that the last call
        # falls off the stack.
        if stack.expected:
            next_call = ExpectedCall(self, call_name=exp.call_name, call_order=self._expected_call_order)
        else:
            next_call = Call(self, call_name=exp.call_name)
        stack.add_call(next_call)
        return self
Start expecting or providing multiple calls.

        .. note:: next_call() cannot be used in combination with :func:`fudge.Fake.times_called`

        Up until calling this method, calls are infinite.

        For example, before next_call() ... ::

            >>> from fudge import Fake
            >>> f = Fake().provides('status').returns('Awake!')
            >>> f.status()
            'Awake!'
            >>> f.status()
            'Awake!'

        After next_call() ... ::

            >>> from fudge import Fake
            >>> f = Fake().provides('status').returns('Awake!')
            >>> f = f.next_call().returns('Asleep')
            >>> f = f.next_call().returns('Dreaming')
            >>> f.status()
            'Awake!'
            >>> f.status()
            'Asleep'
            >>> f.status()
            'Dreaming'
            >>> f.status()
            Traceback (most recent call last):
            ...
            AssertionError: This attribute of fake:unnamed can only be called 3 time(s).  Call reset() if necessary or fudge.clear_calls().

        If you need to affect the next call of something other than the last declared call,
        use ``next_call(for_method="other_call")``.  Here is an example using getters and setters
        on a session object ::

            >>> from fudge import Fake
            >>> sess = Fake('session').provides('get_count').returns(1)
            >>> sess = sess.provides('set_count').with_args(5)

        Now go back and adjust return values for get_count() ::

            >>> sess = sess.next_call(for_method='get_count').returns(5)

        This allows these calls to be made ::

            >>> sess.get_count()
            1
            >>> sess.set_count(5)
            >>> sess.get_count()
            5

        When using :func:`fudge.Fake.remember_order` in combination with :func:`fudge.Fake.expects` and :func:`fudge.Fake.next_call` each new call will be part of the expected order.