def testClass(self):
        values = {"a": 2, "b": 3, "c": 5}

        class c(object):
            a = 3

            def __call__(self, b, c=4):
                return "%d%d%d" % (self.a, b, c)

            compute = __call__

        cc = c()
        v = mapply(cc, (), values)
        self.failUnlessEqual(v, "335")

        del values["c"]
        v = mapply(cc.compute, (), values)
        self.failUnlessEqual(v, "334")

        class c2:
            """Must be a classic class."""

        c2inst = c2()
        c2inst.__call__ = cc
        v = mapply(c2inst, (), values)
        self.failUnlessEqual(v, "334")

 def __call__(self):
     mapply(self.update, (), self.request)
     agenda_recente = self.agenda_recente()
     if agenda_recente and not self.editable:
         return agenda_recente.restrictedTraverse('@@view')()
     else:
         return super(AgendaView, self).__call__()

 def __call__(self):
     self.layout = self._get_layout()
     mapply(self.update, (), self.request)
     if self.request.response.getStatus() in (302, 303):
         # A redirect was triggered somewhere in update().  Don't
         # continue rendering the template or doing anything else.
         return
     return self.layout(self)

    def testMethod(self):
        def compute(a,b,c=4):
            return '%d%d%d' % (a, b, c)
        values = {'a':2, 'b':3, 'c':5}
        v = mapply(compute, (), values)
        self.failUnlessEqual(v, '235')

        v = mapply(compute, (7,), values)
        self.failUnlessEqual(v, '735')

 def __call__(self):
     mapply(self.update, (), self.request)
     if self.request.response.getStatus() in (302, 303):
         # A redirect was triggered somewhere in update().  Don't
         # continue rendering the template or doing anything else.
         return
     self.layout = zope.component.getMultiAdapter(
         (self.request, self.context), ILayout)
     return self.layout(self)

    def testMethod(self):
        def compute(a, b, c=4):
            return "%d%d%d" % (a, b, c)

        values = {"a": 2, "b": 3, "c": 5}
        v = mapply(compute, (), values)
        self.assertEqual(v, "235")

        v = mapply(compute, (7,), values)
        self.assertEqual(v, "735")

    def __call__(self):
        mapply(self.update, (), self.request)
        if self.request.response.getStatus() in (302, 303):
            # A redirect was triggered somewhere in update().  Don't
            # continue rendering the template or doing anything else.
            return

        template = getattr(self, 'template', None)
        if template is not None:
            return self._render_template()
        return mapply(self.render, (), self.request)

    def __call__(self):
        mapply(self.update, (), self.request)
        if self.response.getStatus() in (302, 303):
            # A redirect was triggered somewhere in update().  Don't
            # continue processing the form
            return

        self.updateForm()
        if self.response.getStatus() in (302, 303):
            return

        return self.render()

 def testAncientMethod(self):
     # Before Python 2.6, methods did not have __func__ and __code__.
     # They had im_func and func_code instead.
     # This may still be the case for RestrictedPython scripts.
     # Pretend a method that accepts one argument and one keyword argument.
     # The default value for the keyword argument is given as a tuple.
     method = AncientMethod('7 * %d + %d', (0,))
     values = {}
     v = mapply(method, (6,), values)
     self.assertEqual(v, 42)
     v = mapply(method, (5, 4), values)
     self.assertEqual(v, 39)

    def __call__(self):
        mapply(self.update, (), self.request)
        if self.request.response.getStatus() in (302, 303):
            # A redirect was triggered somewhere in update().  Don't
            # continue processing the form
            return
        self.updateForm()
        if self.request.response.getStatus() in (302, 303):
            return

        self.layout = getMultiAdapter(
            (self.request, self.context), ILayout)
        return self.layout(self)

    def testClass(self):
        values = {'a':2, 'b':3, 'c':5}
        class c(object):
            a = 3
            def __call__(self, b, c=4):
                return '%d%d%d' % (self.a, b, c)
            compute = __call__
        cc = c()
        v = mapply(cc, (), values)
        self.assertEqual(v, '335')

        del values['c']
        v = mapply(cc.compute, (), values)
        self.assertEqual(v, '334')

    def __call__(self):
        __traceback_supplement__ = (ErrorSupplement, self)

        layout_factory = component.getMultiAdapter(
            (self.request, self.context,), ILayoutFactory)
        self.layout = layout_factory(self)

        mapply(self.update, (), self.request)

        if self.request.response.getStatus() in (302, 303):
            # A redirect was triggered somewhere in update().  Don't
            # continue rendering the template or doing anything else.
            return

        return self.layout(self)

    def __call__(self):
        convert_request_form_to_unicode(self.request.form)

        self.layout = component.getMultiAdapter(
            (self.request, self.context), ILayout)

        mapply(self.update, (), self.request)
        if self.request.response.getStatus() in (302, 303):
            # A redirect was triggered somewhere in update(). Don't
            # continue processing the form
            return

        self.updateForm()
        if self.request.response.getStatus() in (302, 303):
            return

        return self.layout(self)

 def callObject(self, request, ob):
     # Exception handling, dont try to call request.method
     orig = ob
     #if not IHTTPException.providedBy(ob):
     #    ob = getattr(ob, request.method, None)
     #    if ob is None:
     #        raise MethodNotAllowed(orig, request)
     return mapply(ob, request.getPositionalArguments(), request)

    def callObject(self, request, ob):
        """Call the object, returning the result.

        For GET/POST this means calling it, but for other methods
        (including those of WebDAV and FTP) this might mean invoking
        a method of an adapter.
        """
        from zope.publisher.publish import mapply
        return mapply(ob, request.getPositionalArguments(), request)

    def testClass(self):
        values = {"a": 2, "b": 3, "c": 5}

        class c(object):
            a = 3

            def __call__(self, b, c=4):
                return "%d%d%d" % (self.a, b, c)

            compute = __call__

        cc = c()
        v = mapply(cc, (), values)
        self.assertEqual(v, "335")

        del values["c"]
        v = mapply(cc.compute, (), values)
        self.assertEqual(v, "334")

    def callObject(self, request, ob):
        """See `zope.publisher.interfaces.IPublication`.

        Our implementation make sure that no result is returned on
        redirect.

        It also sets the launchpad.userid and launchpad.pageid WSGI
        environment variables.
        """
        request._publicationticks_start = tickcount.tickcount()
        if request.response.getStatus() in [301, 302, 303, 307]:
            return ''

        request.setInWSGIEnvironment(
            'launchpad.userid', request.principal.id)

        # The view may be security proxied
        view = removeSecurityProxy(ob)
        # It's possible that the view is a bound method.
        view = getattr(view, 'im_self', view)
        context = removeSecurityProxy(getattr(view, 'context', None))
        pageid = self.constructPageID(view, context)
        request.setInWSGIEnvironment('launchpad.pageid', pageid)
        # And spit the pageid out to our tracelog.
        tracelog(request, 'p', pageid)

        # For status URLs, where we really don't want to have any DB access
        # at all, ensure that all flag lookups will stop early.
        if pageid in (
            'RootObject:OpStats', 'RootObject:+opstats',
            'RootObject:+haproxy'):
            request.features = NullFeatureController()
            features.install_feature_controller(request.features)

        # Calculate the hard timeout: needed because featureflags can be used
        # to control the hard timeout, and they trigger DB access, but our
        # DB tracers are not safe for reentrant use, so we must do this
        # outside of the SQL stack. We must also do it after traversal so that
        # the view is known and can be used in scope resolution. As we
        # actually stash the pageid after afterTraversal, we need to do this
        # even later.
        da.set_permit_timeout_from_features(True)
        da._get_request_timeout()

        if isinstance(removeSecurityProxy(ob), METHOD_WRAPPER_TYPE):
            # this is a direct call on a C-defined method such as __repr__ or
            # dict.__setitem__.  Apparently publishing this is possible and
            # acceptable, at least in the case of
            # lp.services.webapp.servers.PrivateXMLRPCPublication.
            # mapply cannot handle these methods because it cannot introspect
            # them.  We'll just call them directly.
            return ob(*request.getPositionalArguments())

        return mapply(ob, request.getPositionalArguments(), request)

    def callObject(self, request, ob):
        if request.method == 'GET':
            orig = removeAllProxies(ob)
            if type(orig) is MethodType:
                strategy = ICacheStrategy(orig.im_self, None)
            else:
                strategy = ICacheStrategy(orig, None)

            if strategy is not None:
                strategy = strategy.__bind__(request)
                if not strategy.isModified():
                    request.response.setStatus(304)
                    strategy.setNotModifiedHeaders()
                    return ''

                result = mapply(ob, request.getPositionalArguments(), request)
                strategy.setCacheHeaders()
                return result

        return mapply(ob, request.getPositionalArguments(), request)

 def callObject(self, request, ob):
     orig = ob
     if not IHTTPException.providedBy(ob):
         ob = component.queryMultiAdapter((ob, request),
                                         name=request.method)
         checker = selectChecker(ob)
         if checker is not None:
             checker.check(ob, '__call__')
         ob = getattr(ob, request.method, None)
         if ob is None:
             raise GrokMethodNotAllowed(orig, request)
     return mapply(ob, request.getPositionalArguments(), request)

    def testClass(self):
        values = {'a':2, 'b':3, 'c':5}
        class c(object):
            a = 3
            def __call__(self, b, c=4):
                return '%d%d%d' % (self.a, b, c)
            compute = __call__
        cc = c()
        v = mapply(cc, (), values)
        self.failUnlessEqual(v, '335')

        del values['c']
        v = mapply(cc.compute, (), values)
        self.failUnlessEqual(v, '334')

        class c2:
            """Must be a classic class."""
            
        c2inst = c2()
        c2inst.__call__ = cc
        v = mapply(c2inst, (), values)
        self.failUnlessEqual(v, '334')