Failing one test.

2 files changed, 729 insertions, 693 deletions

diff --git a/repoze/bfg/tests/test_registry.py b/repoze/bfg/tests/test_registry.py
index 3eada7b1c..11f5cbf3a 100644
--- a/repoze/bfg/tests/test_registry.py
+++ b/repoze/bfg/tests/test_registry.py
@@ -61,6 +61,355 @@ class TestRegistry(unittest.TestCase):
         self.assertEqual(overrides.inserted, [('path', 'opackage', 'oprefix')])
         self.assertEqual(overrides.package, package)
 
+    def _registerRenderer(self, reg, name='.txt'):
+        from repoze.bfg.interfaces import IRendererFactory
+        from repoze.bfg.interfaces import ITemplateRenderer
+        from zope.interface import implements
+        class Renderer:
+            implements(ITemplateRenderer)
+            def __init__(self, path):
+                pass
+            def __call__(self, *arg):
+                return 'Hello!'
+        reg.registerUtility(Renderer, IRendererFactory, name=name)
+
+    def test_map_view_as_function_context_and_request(self):
+        def view(context, request):
+            return 'OK'
+        reg = self._makeOne()
+        result = reg.map_view(view)
+        self.failUnless(result is view)
+        self.assertEqual(result(None, None), 'OK')
+
+    def test_map_view_as_function_with_attr(self):
+        def view(context, request):
+            """ """
+        reg = self._makeOne()
+        result = reg.map_view(view, attr='__name__')
+        self.failIf(result is view)
+        self.assertRaises(TypeError, result, None, None)
+
+    def test_map_view_as_function_with_attr_and_renderer(self):
+        reg = self._makeOne()
+        self._registerRenderer(reg)
+        def view(context, request):
+            """ """
+        result = reg.map_view(view, attr='__name__',
+                              renderer_name='fixtures/minimal.txt')
+        self.failIf(result is view)
+        self.assertRaises(TypeError, result, None, None)
+        
+    def test_map_view_as_function_requestonly(self):
+        reg = self._makeOne()
+        def view(request):
+            return 'OK'
+        result = reg.map_view(view)
+        self.failIf(result is view)
+        self.assertEqual(view.__module__, result.__module__)
+        self.assertEqual(view.__doc__, result.__doc__)
+        self.assertEqual(view.__name__, result.__name__)
+        self.assertEqual(result(None, None), 'OK')
+
+    def test_map_view_as_function_requestonly_with_attr(self):
+        reg = self._makeOne()
+        def view(request):
+            """ """
+        result = reg.map_view(view, attr='__name__')
+        self.failIf(result is view)
+        self.assertEqual(view.__module__, result.__module__)
+        self.assertEqual(view.__doc__, result.__doc__)
+        self.assertEqual(view.__name__, result.__name__)
+        self.assertRaises(TypeError, result, None, None)
+
+    def test_map_view_as_newstyle_class_context_and_request(self):
+        reg = self._makeOne()
+        class view(object):
+            def __init__(self, context, request):
+                pass
+            def __call__(self):
+                return 'OK'
+        result = reg.map_view(view)
+        self.failIf(result is view)
+        self.assertEqual(view.__module__, result.__module__)
+        self.assertEqual(view.__doc__, result.__doc__)
+        self.assertEqual(view.__name__, result.__name__)
+        self.assertEqual(result(None, None), 'OK')
+
+    def test_map_view_as_newstyle_class_context_and_request_with_attr(self):
+        reg = self._makeOne()
+        class view(object):
+            def __init__(self, context, request):
+                pass
+            def index(self):
+                return 'OK'
+        result = reg.map_view(view, attr='index')
+        self.failIf(result is view)
+        self.assertEqual(view.__module__, result.__module__)
+        self.assertEqual(view.__doc__, result.__doc__)
+        self.assertEqual(view.__name__, result.__name__)
+        self.assertEqual(result(None, None), 'OK')
+
+    def test_map_view_as_newstyle_class_context_and_request_attr_and_renderer(
+        self):
+        reg = self._makeOne()
+        self._registerRenderer(reg)
+        class view(object):
+            def __init__(self, context, request):
+                pass
+            def index(self):
+                return {'a':'1'}
+        result = reg.map_view(
+            view, attr='index',
+            renderer_name='repoze.bfg.tests:fixtures/minimal.txt')
+        self.failIf(result is view)
+        self.assertEqual(view.__module__, result.__module__)
+        self.assertEqual(view.__doc__, result.__doc__)
+        self.assertEqual(view.__name__, result.__name__)
+        request = DummyRequest()
+        self.assertEqual(result(None, request).body, 'Hello!')
+        
+    def test_map_view_as_newstyle_class_requestonly(self):
+        reg = self._makeOne()
+        class view(object):
+            def __init__(self, request):
+                pass
+            def __call__(self):
+                return 'OK'
+        result = reg.map_view(view)
+        self.failIf(result is view)
+        self.assertEqual(view.__module__, result.__module__)
+        self.assertEqual(view.__doc__, result.__doc__)
+        self.assertEqual(view.__name__, result.__name__)
+        self.assertEqual(result(None, None), 'OK')
+
+    def test_map_view_as_newstyle_class_requestonly_with_attr(self):
+        reg = self._makeOne()
+        class view(object):
+            def __init__(self, request):
+                pass
+            def index(self):
+                return 'OK'
+        result = reg.map_view(view, attr='index')
+        self.failIf(result is view)
+        self.assertEqual(view.__module__, result.__module__)
+        self.assertEqual(view.__doc__, result.__doc__)
+        self.assertEqual(view.__name__, result.__name__)
+        self.assertEqual(result(None, None), 'OK')
+
+    def test_map_view_as_newstyle_class_requestonly_with_attr_and_renderer(self):
+        reg = self._makeOne()
+        self._registerRenderer(reg)
+        class view(object):
+            def __init__(self, request):
+                pass
+            def index(self):
+                return {'a':'1'}
+        result = reg.map_view(
+            view, attr='index',
+            renderer_name='repoze.bfg.tests:fixtures/minimal.txt')
+        self.failIf(result is view)
+        self.assertEqual(view.__module__, result.__module__)
+        self.assertEqual(view.__doc__, result.__doc__)
+        self.assertEqual(view.__name__, result.__name__)
+        request = DummyRequest()
+        self.assertEqual(result(None, request).body, 'Hello!')
+
+    def test_map_view_as_oldstyle_class_context_and_request(self):
+        reg = self._makeOne()
+        class view:
+            def __init__(self, context, request):
+                pass
+            def __call__(self):
+                return 'OK'
+        result = reg.map_view(view)
+        self.failIf(result is view)
+        self.assertEqual(view.__module__, result.__module__)
+        self.assertEqual(view.__doc__, result.__doc__)
+        self.assertEqual(view.__name__, result.__name__)
+        self.assertEqual(result(None, None), 'OK')
+
+    def test_map_view_as_oldstyle_class_context_and_request_with_attr(self):
+        reg = self._makeOne()
+        class view:
+            def __init__(self, context, request):
+                pass
+            def index(self):
+                return 'OK'
+        result = reg.map_view(view, attr='index')
+        self.failIf(result is view)
+        self.assertEqual(view.__module__, result.__module__)
+        self.assertEqual(view.__doc__, result.__doc__)
+        self.assertEqual(view.__name__, result.__name__)
+        self.assertEqual(result(None, None), 'OK')
+
+    def test_map_view_as_oldstyle_class_context_and_request_attr_and_renderer(
+        self):
+        reg = self._makeOne()
+        self._registerRenderer(reg)
+        class view:
+            def __init__(self, context, request):
+                pass
+            def index(self):
+                return {'a':'1'}
+        result = reg.map_view(
+            view, attr='index',
+            renderer_name='repoze.bfg.tests:fixtures/minimal.txt')
+        self.failIf(result is view)
+        self.assertEqual(view.__module__, result.__module__)
+        self.assertEqual(view.__doc__, result.__doc__)
+        self.assertEqual(view.__name__, result.__name__)
+        request = DummyRequest()
+        self.assertEqual(result(None, request).body, 'Hello!')
+
+    def test_map_view_as_oldstyle_class_requestonly(self):
+        reg = self._makeOne()
+        class view:
+            def __init__(self, request):
+                pass
+            def __call__(self):
+                return 'OK'
+        result = reg.map_view(view)
+        self.failIf(result is view)
+        self.assertEqual(view.__module__, result.__module__)
+        self.assertEqual(view.__doc__, result.__doc__)
+        self.assertEqual(view.__name__, result.__name__)
+        self.assertEqual(result(None, None), 'OK')
+
+    def test_map_view_as_oldstyle_class_requestonly_with_attr(self):
+        reg = self._makeOne()
+        class view:
+            def __init__(self, request):
+                pass
+            def index(self):
+                return 'OK'
+        result = reg.map_view(view, attr='index')
+        self.failIf(result is view)
+        self.assertEqual(view.__module__, result.__module__)
+        self.assertEqual(view.__doc__, result.__doc__)
+        self.assertEqual(view.__name__, result.__name__)
+        self.assertEqual(result(None, None), 'OK')
+
+    def test_map_view_as_oldstyle_class_requestonly_attr_and_renderer(self):
+        reg = self._makeOne()
+        self._registerRenderer(reg)
+        class view:
+            def __init__(self, request):
+                pass
+            def index(self):
+                return {'a':'1'}
+        result = reg.map_view(
+            view, attr='index',
+            renderer_name='repoze.bfg.tests:fixtures/minimal.txt')
+        self.failIf(result is view)
+        self.assertEqual(view.__module__, result.__module__)
+        self.assertEqual(view.__doc__, result.__doc__)
+        self.assertEqual(view.__name__, result.__name__)
+        request = DummyRequest()
+        self.assertEqual(result(None, request).body, 'Hello!')
+
+    def test_map_view_as_instance_context_and_request(self):
+        reg = self._makeOne()
+        class View:
+            def __call__(self, context, request):
+                return 'OK'
+        view = View()
+        result = reg.map_view(view)
+        self.failUnless(result is view)
+        self.assertEqual(result(None, None), 'OK')
+        
+    def test_map_view_as_instance_context_and_request_and_attr(self):
+        reg = self._makeOne()
+        class View:
+            def index(self, context, request):
+                return 'OK'
+        view = View()
+        result = reg.map_view(view, attr='index')
+        self.failIf(result is view)
+        self.assertEqual(result(None, None), 'OK')
+
+    def test_map_view_as_instance_context_and_request_attr_and_renderer(self):
+        reg = self._makeOne()
+        self._registerRenderer(reg)
+        class View:
+            def index(self, context, request):
+                return {'a':'1'}
+        view = View()
+        result = reg.map_view(
+            view, attr='index',
+            renderer_name='repoze.bfg.tests:fixtures/minimal.txt')
+        self.failIf(result is view)
+        request = DummyRequest()
+        self.assertEqual(result(None, request).body, 'Hello!')
+
+    def test_map_view_as_instance_requestonly(self):
+        reg = self._makeOne()
+        class View:
+            def __call__(self, request):
+                return 'OK'
+        view = View()
+        result = reg.map_view(view)
+        self.failIf(result is view)
+        self.assertEqual(view.__module__, result.__module__)
+        self.assertEqual(view.__doc__, result.__doc__)
+        self.failUnless('instance' in result.__name__)
+        self.assertEqual(result(None, None), 'OK')
+
+    def test_map_view_as_instance_requestonly_with_attr(self):
+        reg = self._makeOne()
+        class View:
+            def index(self, request):
+                return 'OK'
+        view = View()
+        result = reg.map_view(view, attr='index')
+        self.failIf(result is view)
+        self.assertEqual(view.__module__, result.__module__)
+        self.assertEqual(view.__doc__, result.__doc__)
+        self.failUnless('instance' in result.__name__)
+        self.assertEqual(result(None, None), 'OK')
+
+    def test_map_view_as_instance_requestonly_with_attr_and_renderer(self):
+        reg = self._makeOne()
+        self._registerRenderer(reg)
+        class View:
+            def index(self, request):
+                return {'a':'1'}
+        view = View()
+        result = reg.map_view(
+            view, attr='index',
+            renderer_name='repoze.bfg.tests:fixtures/minimal.txt')
+        self.failIf(result is view)
+        self.assertEqual(view.__module__, result.__module__)
+        self.assertEqual(view.__doc__, result.__doc__)
+        self.failUnless('instance' in result.__name__)
+        request = DummyRequest()
+        self.assertEqual(result(None, request).body, 'Hello!')
+
+    def test_map_view_rendereronly(self):
+        reg = self._makeOne()
+        self._registerRenderer(reg)
+        def view(context, request):
+            return {'a':'1'}
+        result = reg.map_view(
+            view,
+            renderer_name='repoze.bfg.tests:fixtures/minimal.txt')
+        self.failIf(result is view)
+        self.assertEqual(view.__module__, result.__module__)
+        self.assertEqual(view.__doc__, result.__doc__)
+        request = DummyRequest()
+        self.assertEqual(result(None, request).body, 'Hello!')
+
+    def test_map_view_defaultrendereronly(self):
+        reg = self._makeOne()
+        self._registerRenderer(reg, name='')
+        def view(context, request):
+            return {'a':'1'}
+        result = reg.map_view(view)
+        self.failIf(result is view)
+        self.assertEqual(view.__module__, result.__module__)
+        self.assertEqual(view.__doc__, result.__doc__)
+        request = DummyRequest()
+        self.assertEqual(result(None, request).body, 'Hello!')
+
 class TestBFGViewGrokker(unittest.TestCase):
     def setUp(self):
         cleanUp()
@@ -133,7 +482,6 @@ class TestDefaultRootFactory(unittest.TestCase):
         self.assertEqual(root.a, 1)
         self.assertEqual(root.b, 2)
 
-
 class DummyModule:
     __path__ = "foo"
     __name__ = "dummy"
@@ -157,3 +505,26 @@ class DummyOverrides:
 
     def insert(self, path, package, prefix):
         self.inserted.append((path, package, prefix))
+
+class DummyRequest:
+    def __init__(self, environ=None):
+        if environ is None:
+            environ = {}
+        self.environ = environ
+        
+    def get_response(self, application):
+        return application
+
+    def copy(self):
+        self.copied = True
+        return self
+
+class DummyResponse:
+    status = '200 OK'
+    headerlist = ()
+    def __init__(self, body=None):
+        if body is None:
+            self.app_iter = ()
+        else:
+            self.app_iter = [body]
+            
diff --git a/repoze/bfg/tests/test_view.py b/repoze/bfg/tests/test_view.py
index 80179e247..807dbe85a 100644
--- a/repoze/bfg/tests/test_view.py
+++ b/repoze/bfg/tests/test_view.py
@@ -526,698 +526,6 @@ class AppendSlashNotFoundView(unittest.TestCase):
         self.assertEqual(response.status, '302 Found')
         self.assertEqual(response.location, '/abc/')
 
-class TestMultiView(unittest.TestCase):
-    def _getTargetClass(self):
-        from repoze.bfg.view import MultiView
-        return MultiView
-
-    def _makeOne(self, name='name'):
-        return self._getTargetClass()(name)
-    
-    def test_class_implements_ISecuredView(self):
-        from zope.interface.verify import verifyClass
-        from repoze.bfg.interfaces import ISecuredView
-        verifyClass(ISecuredView, self._getTargetClass())
-
-    def test_instance_implements_ISecuredView(self):
-        from zope.interface.verify import verifyObject
-        from repoze.bfg.interfaces import ISecuredView
-        verifyObject(ISecuredView, self._makeOne())
-
-    def test_add(self):
-        mv = self._makeOne()
-        mv.add('view', 100)
-        self.assertEqual(mv.views, [(100, 'view')])
-        mv.add('view2', 99)
-        self.assertEqual(mv.views, [(99, 'view2'), (100, 'view')])
-
-    def test_match_not_found(self):
-        from repoze.bfg.exceptions import NotFound
-        mv = self._makeOne()
-        context = DummyContext()
-        request = DummyRequest()
-        self.assertRaises(NotFound, mv.match, context, request)
-
-    def test_match_predicate_fails(self):
-        from repoze.bfg.exceptions import NotFound
-        mv = self._makeOne()
-        def view(context, request):
-            """ """
-        view.__predicated__ = lambda *arg: False
-        mv.views = [(100, view)]
-        context = DummyContext()
-        request = DummyRequest()
-        self.assertRaises(NotFound, mv.match, context, request)
-
-    def test_match_predicate_succeeds(self):
-        mv = self._makeOne()
-        def view(context, request):
-            """ """
-        view.__predicated__ = lambda *arg: True
-        mv.views = [(100, view)]
-        context = DummyContext()
-        request = DummyRequest()
-        result = mv.match(context, request)
-        self.assertEqual(result, view)
-
-    def test_permitted_no_views(self):
-        from repoze.bfg.exceptions import NotFound
-        mv = self._makeOne()
-        context = DummyContext()
-        request = DummyRequest()
-        self.assertRaises(NotFound, mv.__permitted__, context, request)
-
-    def test_permitted_no_match_with__permitted__(self):
-        mv = self._makeOne()
-        def view(context, request):
-            """ """
-        mv.views = [(100, view)]
-        context = DummyContext()
-        request = DummyRequest()
-        self.assertEqual(mv.__permitted__(None, None), True)
-        
-    def test_permitted(self):
-        from zope.component import getSiteManager
-        mv = self._makeOne()
-        def view(context, request):
-            """ """
-        def permitted(context, request):
-            return False
-        view.__permitted__ = permitted
-        mv.views = [(100, view)]
-        context = DummyContext()
-        request = DummyRequest()
-        sm = getSiteManager()
-        result = mv.__permitted__(context, request)
-        self.assertEqual(result, False)
-
-    def test__call__not_found(self):
-        from repoze.bfg.exceptions import NotFound
-        mv = self._makeOne()
-        context = DummyContext()
-        request = DummyRequest()
-        self.assertRaises(NotFound, mv, context, request)
-
-    def test___call__intermediate_not_found(self):
-        from repoze.bfg.exceptions import NotFound
-        mv = self._makeOne()
-        context = DummyContext()
-        request = DummyRequest()
-        request.view_name = ''
-        expected_response = DummyResponse()
-        def view1(context, request):
-            raise NotFound
-        def view2(context, request):
-            return expected_response
-        mv.views = [(100, view1), (99, view2)]
-        response = mv(context, request)
-        self.assertEqual(response, expected_response)
-
-    def test___call__(self):
-        mv = self._makeOne()
-        context = DummyContext()
-        request = DummyRequest()
-        request.view_name = ''
-        expected_response = DummyResponse()
-        def view(context, request):
-            return expected_response
-        mv.views = [(100, view)]
-        response = mv(context, request)
-        self.assertEqual(response, expected_response)
-
-    def test__call_permissive__not_found(self):
-        from repoze.bfg.exceptions import NotFound
-        mv = self._makeOne()
-        context = DummyContext()
-        request = DummyRequest()
-        self.assertRaises(NotFound, mv, context, request)
-
-    def test___call_permissive_has_call_permissive(self):
-        mv = self._makeOne()
-        context = DummyContext()
-        request = DummyRequest()
-        request.view_name = ''
-        expected_response = DummyResponse()
-        def view(context, request):
-            """ """
-        def permissive(context, request):
-            return expected_response
-        view.__call_permissive__ = permissive
-        mv.views = [(100, view)]
-        response = mv.__call_permissive__(context, request)
-        self.assertEqual(response, expected_response)
-
-    def test___call_permissive_has_no_call_permissive(self):
-        mv = self._makeOne()
-        context = DummyContext()
-        request = DummyRequest()
-        request.view_name = ''
-        expected_response = DummyResponse()
-        def view(context, request):
-            return expected_response
-        mv.views = [(100, view)]
-        response = mv.__call_permissive__(context, request)
-        self.assertEqual(response, expected_response)
-
-class Test_map_view(unittest.TestCase):
-    def setUp(self):
-        cleanUp()
-
-    def tearDown(self):
-        cleanUp()
-        
-    def _callFUT(self, view, *arg, **kw):
-        from repoze.bfg.view import map_view
-        return map_view(view, *arg, **kw)
-
-    def _registerRenderer(self, name='.txt'):
-        from repoze.bfg.interfaces import IRendererFactory
-        from repoze.bfg.interfaces import ITemplateRenderer
-        from zope.interface import implements
-        from zope.component import getSiteManager
-        class Renderer:
-            implements(ITemplateRenderer)
-            def __init__(self, path):
-                pass
-            def __call__(self, *arg):
-                return 'Hello!'
-        sm = getSiteManager()
-        sm.registerUtility(Renderer, IRendererFactory, name=name)
-
-    def test_view_as_function_context_and_request(self):
-        def view(context, request):
-            return 'OK'
-        result = self._callFUT(view)
-        self.failUnless(result is view)
-        self.assertEqual(result(None, None), 'OK')
-
-    def test_view_as_function_with_attr(self):
-        def view(context, request):
-            """ """
-        result = self._callFUT(view, attr='__name__')
-        self.failIf(result is view)
-        self.assertRaises(TypeError, result, None, None)
-
-    def test_view_as_function_with_attr_and_renderer(self):
-        self._registerRenderer()
-        def view(context, request):
-            """ """
-        result = self._callFUT(view, attr='__name__',
-                               renderer_name='fixtures/minimal.txt')
-        self.failIf(result is view)
-        self.assertRaises(TypeError, result, None, None)
-        
-    def test_view_as_function_requestonly(self):
-        def view(request):
-            return 'OK'
-        result = self._callFUT(view)
-        self.failIf(result is view)
-        self.assertEqual(view.__module__, result.__module__)
-        self.assertEqual(view.__doc__, result.__doc__)
-        self.assertEqual(view.__name__, result.__name__)
-        self.assertEqual(result(None, None), 'OK')
-
-    def test_view_as_function_requestonly_with_attr(self):
-        def view(request):
-            """ """
-        result = self._callFUT(view, attr='__name__')
-        self.failIf(result is view)
-        self.assertEqual(view.__module__, result.__module__)
-        self.assertEqual(view.__doc__, result.__doc__)
-        self.assertEqual(view.__name__, result.__name__)
-        self.assertRaises(TypeError, result, None, None)
-
-    def test_view_as_newstyle_class_context_and_request(self):
-        class view(object):
-            def __init__(self, context, request):
-                pass
-            def __call__(self):
-                return 'OK'
-        result = self._callFUT(view)
-        self.failIf(result is view)
-        self.assertEqual(view.__module__, result.__module__)
-        self.assertEqual(view.__doc__, result.__doc__)
-        self.assertEqual(view.__name__, result.__name__)
-        self.assertEqual(result(None, None), 'OK')
-
-    def test_view_as_newstyle_class_context_and_request_with_attr(self):
-        class view(object):
-            def __init__(self, context, request):
-                pass
-            def index(self):
-                return 'OK'
-        result = self._callFUT(view, attr='index')
-        self.failIf(result is view)
-        self.assertEqual(view.__module__, result.__module__)
-        self.assertEqual(view.__doc__, result.__doc__)
-        self.assertEqual(view.__name__, result.__name__)
-        self.assertEqual(result(None, None), 'OK')
-
-    def test_view_as_newstyle_class_context_and_request_with_attr_and_renderer(
-        self):
-        self._registerRenderer()
-        class view(object):
-            def __init__(self, context, request):
-                pass
-            def index(self):
-                return {'a':'1'}
-        result = self._callFUT(
-            view, attr='index',
-            renderer_name='repoze.bfg.tests:fixtures/minimal.txt')
-        self.failIf(result is view)
-        self.assertEqual(view.__module__, result.__module__)
-        self.assertEqual(view.__doc__, result.__doc__)
-        self.assertEqual(view.__name__, result.__name__)
-        request = DummyRequest()
-        self.assertEqual(result(None, request).body, 'Hello!')
-        
-    def test_view_as_newstyle_class_requestonly(self):
-        class view(object):
-            def __init__(self, request):
-                pass
-            def __call__(self):
-                return 'OK'
-        result = self._callFUT(view)
-        self.failIf(result is view)
-        self.assertEqual(view.__module__, result.__module__)
-        self.assertEqual(view.__doc__, result.__doc__)
-        self.assertEqual(view.__name__, result.__name__)
-        self.assertEqual(result(None, None), 'OK')
-
-    def test_view_as_newstyle_class_requestonly_with_attr(self):
-        class view(object):
-            def __init__(self, request):
-                pass
-            def index(self):
-                return 'OK'
-        result = self._callFUT(view, attr='index')
-        self.failIf(result is view)
-        self.assertEqual(view.__module__, result.__module__)
-        self.assertEqual(view.__doc__, result.__doc__)
-        self.assertEqual(view.__name__, result.__name__)
-        self.assertEqual(result(None, None), 'OK')
-
-    def test_view_as_newstyle_class_requestonly_with_attr_and_renderer(self):
-        self._registerRenderer()
-        class view(object):
-            def __init__(self, request):
-                pass
-            def index(self):
-                return {'a':'1'}
-        result = self._callFUT(
-            view, attr='index',
-            renderer_name='repoze.bfg.tests:fixtures/minimal.txt')
-        self.failIf(result is view)
-        self.assertEqual(view.__module__, result.__module__)
-        self.assertEqual(view.__doc__, result.__doc__)
-        self.assertEqual(view.__name__, result.__name__)
-        request = DummyRequest()
-        self.assertEqual(result(None, request).body, 'Hello!')
-
-    def test_view_as_oldstyle_class_context_and_request(self):
-        class view:
-            def __init__(self, context, request):
-                pass
-            def __call__(self):
-                return 'OK'
-        result = self._callFUT(view)
-        self.failIf(result is view)
-        self.assertEqual(view.__module__, result.__module__)
-        self.assertEqual(view.__doc__, result.__doc__)
-        self.assertEqual(view.__name__, result.__name__)
-        self.assertEqual(result(None, None), 'OK')
-
-    def test_view_as_oldstyle_class_context_and_request_with_attr(self):
-        class view:
-            def __init__(self, context, request):
-                pass
-            def index(self):
-                return 'OK'
-        result = self._callFUT(view, attr='index')
-        self.failIf(result is view)
-        self.assertEqual(view.__module__, result.__module__)
-        self.assertEqual(view.__doc__, result.__doc__)
-        self.assertEqual(view.__name__, result.__name__)
-        self.assertEqual(result(None, None), 'OK')
-
-    def test_view_as_oldstyle_class_context_and_request_with_attr_and_renderer(
-        self):
-        self._registerRenderer()
-        class view:
-            def __init__(self, context, request):
-                pass
-            def index(self):
-                return {'a':'1'}
-        result = self._callFUT(
-            view, attr='index',
-            renderer_name='repoze.bfg.tests:fixtures/minimal.txt')
-        self.failIf(result is view)
-        self.assertEqual(view.__module__, result.__module__)
-        self.assertEqual(view.__doc__, result.__doc__)
-        self.assertEqual(view.__name__, result.__name__)
-        request = DummyRequest()
-        self.assertEqual(result(None, request).body, 'Hello!')
-
-    def test_view_as_oldstyle_class_requestonly(self):
-        class view:
-            def __init__(self, request):
-                pass
-            def __call__(self):
-                return 'OK'
-        result = self._callFUT(view)
-        self.failIf(result is view)
-        self.assertEqual(view.__module__, result.__module__)
-        self.assertEqual(view.__doc__, result.__doc__)
-        self.assertEqual(view.__name__, result.__name__)
-        self.assertEqual(result(None, None), 'OK')
-
-    def test_view_as_oldstyle_class_requestonly_with_attr(self):
-        class view:
-            def __init__(self, request):
-                pass
-            def index(self):
-                return 'OK'
-        result = self._callFUT(view, attr='index')
-        self.failIf(result is view)
-        self.assertEqual(view.__module__, result.__module__)
-        self.assertEqual(view.__doc__, result.__doc__)
-        self.assertEqual(view.__name__, result.__name__)
-        self.assertEqual(result(None, None), 'OK')
-
-    def test_view_as_oldstyle_class_requestonly_with_attr_and_renderer(self):
-        self._registerRenderer()
-        class view:
-            def __init__(self, request):
-                pass
-            def index(self):
-                return {'a':'1'}
-        result = self._callFUT(
-            view, attr='index',
-            renderer_name='repoze.bfg.tests:fixtures/minimal.txt')
-        self.failIf(result is view)
-        self.assertEqual(view.__module__, result.__module__)
-        self.assertEqual(view.__doc__, result.__doc__)
-        self.assertEqual(view.__name__, result.__name__)
-        request = DummyRequest()
-        self.assertEqual(result(None, request).body, 'Hello!')
-
-    def test_view_as_instance_context_and_request(self):
-        class View:
-            def __call__(self, context, request):
-                return 'OK'
-        view = View()
-        result = self._callFUT(view)
-        self.failUnless(result is view)
-        self.assertEqual(result(None, None), 'OK')
-        
-    def test_view_as_instance_context_and_request_and_attr(self):
-        class View:
-            def index(self, context, request):
-                return 'OK'
-        view = View()
-        result = self._callFUT(view, attr='index')
-        self.failIf(result is view)
-        self.assertEqual(result(None, None), 'OK')
-
-    def test_view_as_instance_context_and_request_attr_and_renderer(self):
-        self._registerRenderer()
-        class View:
-            def index(self, context, request):
-                return {'a':'1'}
-        view = View()
-        result = self._callFUT(
-            view, attr='index',
-            renderer_name='repoze.bfg.tests:fixtures/minimal.txt')
-        self.failIf(result is view)
-        request = DummyRequest()
-        self.assertEqual(result(None, request).body, 'Hello!')
-
-    def test_view_as_instance_requestonly(self):
-        class View:
-            def __call__(self, request):
-                return 'OK'
-        view = View()
-        result = self._callFUT(view)
-        self.failIf(result is view)
-        self.assertEqual(view.__module__, result.__module__)
-        self.assertEqual(view.__doc__, result.__doc__)
-        self.failUnless('instance' in result.__name__)
-        self.assertEqual(result(None, None), 'OK')
-
-    def test_view_as_instance_requestonly_with_attr(self):
-        class View:
-            def index(self, request):
-                return 'OK'
-        view = View()
-        result = self._callFUT(view, attr='index')
-        self.failIf(result is view)
-        self.assertEqual(view.__module__, result.__module__)
-        self.assertEqual(view.__doc__, result.__doc__)
-        self.failUnless('instance' in result.__name__)
-        self.assertEqual(result(None, None), 'OK')
-
-    def test_view_as_instance_requestonly_with_attr_and_renderer(self):
-        self._registerRenderer()
-        class View:
-            def index(self, request):
-                return {'a':'1'}
-        view = View()
-        result = self._callFUT(
-            view, attr='index',
-            renderer_name='repoze.bfg.tests:fixtures/minimal.txt')
-        self.failIf(result is view)
-        self.assertEqual(view.__module__, result.__module__)
-        self.assertEqual(view.__doc__, result.__doc__)
-        self.failUnless('instance' in result.__name__)
-        request = DummyRequest()
-        self.assertEqual(result(None, request).body, 'Hello!')
-
-    def test_view_rendereronly(self):
-        self._registerRenderer()
-        def view(context, request):
-            return {'a':'1'}
-        result = self._callFUT(
-            view,
-            renderer_name='repoze.bfg.tests:fixtures/minimal.txt')
-        self.failIf(result is view)
-        self.assertEqual(view.__module__, result.__module__)
-        self.assertEqual(view.__doc__, result.__doc__)
-        request = DummyRequest()
-        self.assertEqual(result(None, request).body, 'Hello!')
-
-    def test_view_defaultrendereronly(self):
-        self._registerRenderer(name='')
-        def view(context, request):
-            return {'a':'1'}
-        result = self._callFUT(view)
-        self.failIf(result is view)
-        self.assertEqual(view.__module__, result.__module__)
-        self.assertEqual(view.__doc__, result.__doc__)
-        request = DummyRequest()
-        self.assertEqual(result(None, request).body, 'Hello!')
-
-class TestRequestOnly(unittest.TestCase):
-    def _callFUT(self, arg):
-        from repoze.bfg.view import requestonly
-        return requestonly(arg)
-    
-    def test_newstyle_class_no_init(self):
-        class foo(object):
-            """ """
-        self.assertFalse(self._callFUT(foo))
-
-    def test_newstyle_class_init_toomanyargs(self):
-        class foo(object):
-            def __init__(self, context, request):
-                """ """
-        self.assertFalse(self._callFUT(foo))
-        
-    def test_newstyle_class_init_onearg_named_request(self):
-        class foo(object):
-            def __init__(self, request):
-                """ """
-        self.assertTrue(self._callFUT(foo))
-
-    def test_newstyle_class_init_onearg_named_somethingelse(self):
-        class foo(object):
-            def __init__(self, req):
-                """ """
-        self.assertTrue(self._callFUT(foo))
-
-    def test_newstyle_class_init_defaultargs_firstname_not_request(self):
-        class foo(object):
-            def __init__(self, context, request=None):
-                """ """
-        self.assertFalse(self._callFUT(foo))
-
-    def test_newstyle_class_init_defaultargs_firstname_request(self):
-        class foo(object):
-            def __init__(self, request, foo=1, bar=2):
-                """ """
-        self.assertTrue(self._callFUT(foo))
-
-    def test_newstyle_class_init_noargs(self):
-        class foo(object):
-            def __init__():
-                """ """
-        self.assertFalse(self._callFUT(foo))
-
-    def test_oldstyle_class_no_init(self):
-        class foo:
-            """ """
-        self.assertFalse(self._callFUT(foo))
-
-    def test_oldstyle_class_init_toomanyargs(self):
-        class foo:
-            def __init__(self, context, request):
-                """ """
-        self.assertFalse(self._callFUT(foo))
-        
-    def test_oldstyle_class_init_onearg_named_request(self):
-        class foo:
-            def __init__(self, request):
-                """ """
-        self.assertTrue(self._callFUT(foo))
-
-    def test_oldstyle_class_init_onearg_named_somethingelse(self):
-        class foo:
-            def __init__(self, req):
-                """ """
-        self.assertTrue(self._callFUT(foo))
-
-    def test_oldstyle_class_init_defaultargs_firstname_not_request(self):
-        class foo:
-            def __init__(self, context, request=None):
-                """ """
-        self.assertFalse(self._callFUT(foo))
-
-    def test_oldstyle_class_init_defaultargs_firstname_request(self):
-        class foo:
-            def __init__(self, request, foo=1, bar=2):
-                """ """
-        self.assertTrue(self._callFUT(foo), True)
-
-    def test_oldstyle_class_init_noargs(self):
-        class foo:
-            def __init__():
-                """ """
-        self.assertFalse(self._callFUT(foo))
-
-    def test_function_toomanyargs(self):
-        def foo(context, request):
-            """ """
-        self.assertFalse(self._callFUT(foo))
-        
-    def test_function_onearg_named_request(self):
-        def foo(request):
-            """ """
-        self.assertTrue(self._callFUT(foo))
-
-    def test_function_onearg_named_somethingelse(self):
-        def foo(req):
-            """ """
-        self.assertTrue(self._callFUT(foo))
-
-    def test_function_defaultargs_firstname_not_request(self):
-        def foo(context, request=None):
-            """ """
-        self.assertFalse(self._callFUT(foo))
-
-    def test_function_defaultargs_firstname_request(self):
-        def foo(request, foo=1, bar=2):
-            """ """
-        self.assertTrue(self._callFUT(foo), True)
-
-    def test_instance_toomanyargs(self):
-        class Foo:
-            def __call__(self, context, request):
-                """ """
-        foo = Foo()
-        self.assertFalse(self._callFUT(foo))
-        
-    def test_instance_defaultargs_onearg_named_request(self):
-        class Foo:
-            def __call__(self, request):
-                """ """
-        foo = Foo()
-        self.assertTrue(self._callFUT(foo))
-
-    def test_instance_defaultargs_onearg_named_somethingelse(self):
-        class Foo:
-            def __call__(self, req):
-                """ """
-        foo = Foo()
-        self.assertTrue(self._callFUT(foo))
-
-    def test_instance_defaultargs_firstname_not_request(self):
-        class Foo:
-            def __call__(self, context, request=None):
-                """ """
-        foo = Foo()
-        self.assertFalse(self._callFUT(foo))
-
-    def test_instance_defaultargs_firstname_request(self):
-        class Foo:
-            def __call__(self, request, foo=1, bar=2):
-                """ """
-        foo = Foo()
-        self.assertTrue(self._callFUT(foo), True)
-
-    def test_instance_nocall(self):
-        class Foo: pass
-        foo = Foo()
-        self.assertFalse(self._callFUT(foo))
-
-class TestDecorateView(unittest.TestCase):
-    def _callFUT(self, wrapped, original):
-        from repoze.bfg.view import decorate_view
-        return decorate_view(wrapped, original)
-    
-    def test_it_same(self):
-        def view(context, request):
-            """ """
-        result = self._callFUT(view, view)
-        self.assertEqual(result, False)
-
-    def test_it_different(self):
-        class DummyView1:
-            """ 1 """
-            __name__ = '1'
-            __module__ = '1'
-            def __call__(self, context, request):
-                """ """
-            def __call_permissive__(self, context, reuqest):
-                """ """
-            def __predicated__(self, context, reuqest):
-                """ """
-            def __permitted__(self, context, request):
-                """ """
-        class DummyView2:
-            """ 2 """
-            __name__ = '2'
-            __module__ = '2'
-            def __call__(self, context, request):
-                """ """
-            def __call_permissive__(self, context, reuqest):
-                """ """
-            def __predicated__(self, context, reuqest):
-                """ """
-            def __permitted__(self, context, request):
-                """ """
-        view1 = DummyView1()
-        view2 = DummyView2()
-        result = self._callFUT(view1, view2)
-        self.assertEqual(result, True)
-        self.failUnless(view1.__doc__ is view2.__doc__)
-        self.failUnless(view1.__module__ is view2.__module__)
-        self.failUnless(view1.__name__ is view2.__name__)
-        self.failUnless(view1.__call_permissive__.im_func is
-                        view2.__call_permissive__.im_func)
-        self.failUnless(view1.__permitted__.im_func is
-                        view2.__permitted__.im_func)
-        self.failUnless(view1.__predicated__.im_func is
-                        view2.__predicated__.im_func)
-
 class Test_rendered_response(unittest.TestCase):
     def setUp(self):
         cleanUp()
@@ -1613,6 +921,363 @@ class TestDeriveView(unittest.TestCase):
             inner_view, viewname='inner', wrapper_viewname='owrap')
         result = self.assertRaises(ValueError, wrapped, None, request)
 
+class TestDecorateView(unittest.TestCase):
+    def _callFUT(self, wrapped, original):
+        from repoze.bfg.view import decorate_view
+        return decorate_view(wrapped, original)
+    
+    def test_it_same(self):
+        def view(context, request):
+            """ """
+        result = self._callFUT(view, view)
+        self.assertEqual(result, False)
+
+    def test_it_different(self):
+        class DummyView1:
+            """ 1 """
+            __name__ = '1'
+            __module__ = '1'
+            def __call__(self, context, request):
+                """ """
+            def __call_permissive__(self, context, reuqest):
+                """ """
+            def __predicated__(self, context, reuqest):
+                """ """
+            def __permitted__(self, context, request):
+                """ """
+        class DummyView2:
+            """ 2 """
+            __name__ = '2'
+            __module__ = '2'
+            def __call__(self, context, request):
+                """ """
+            def __call_permissive__(self, context, reuqest):
+                """ """
+            def __predicated__(self, context, reuqest):
+                """ """
+            def __permitted__(self, context, request):
+                """ """
+        view1 = DummyView1()
+        view2 = DummyView2()
+        result = self._callFUT(view1, view2)
+        self.assertEqual(result, True)
+        self.failUnless(view1.__doc__ is view2.__doc__)
+        self.failUnless(view1.__module__ is view2.__module__)
+        self.failUnless(view1.__name__ is view2.__name__)
+        self.failUnless(view1.__call_permissive__.im_func is
+                        view2.__call_permissive__.im_func)
+        self.failUnless(view1.__permitted__.im_func is
+                        view2.__permitted__.im_func)
+        self.failUnless(view1.__predicated__.im_func is
+                        view2.__predicated__.im_func)
+
+class TestMultiView(unittest.TestCase):
+    def _getTargetClass(self):
+        from repoze.bfg.view import MultiView
+        return MultiView
+
+    def _makeOne(self, name='name'):
+        return self._getTargetClass()(name)
+    
+    def test_class_implements_ISecuredView(self):
+        from zope.interface.verify import verifyClass
+        from repoze.bfg.interfaces import ISecuredView
+        verifyClass(ISecuredView, self._getTargetClass())
+
+    def test_instance_implements_ISecuredView(self):
+        from zope.interface.verify import verifyObject
+        from repoze.bfg.interfaces import ISecuredView
+        verifyObject(ISecuredView, self._makeOne())
+
+    def test_add(self):
+        mv = self._makeOne()
+        mv.add('view', 100)
+        self.assertEqual(mv.views, [(100, 'view')])
+        mv.add('view2', 99)
+        self.assertEqual(mv.views, [(99, 'view2'), (100, 'view')])
+
+    def test_match_not_found(self):
+        from repoze.bfg.exceptions import NotFound
+        mv = self._makeOne()
+        context = DummyContext()
+        request = DummyRequest()
+        self.assertRaises(NotFound, mv.match, context, request)
+
+    def test_match_predicate_fails(self):
+        from repoze.bfg.exceptions import NotFound
+        mv = self._makeOne()
+        def view(context, request):
+            """ """
+        view.__predicated__ = lambda *arg: False
+        mv.views = [(100, view)]
+        context = DummyContext()
+        request = DummyRequest()
+        self.assertRaises(NotFound, mv.match, context, request)
+
+    def test_match_predicate_succeeds(self):
+        mv = self._makeOne()
+        def view(context, request):
+            """ """
+        view.__predicated__ = lambda *arg: True
+        mv.views = [(100, view)]
+        context = DummyContext()
+        request = DummyRequest()
+        result = mv.match(context, request)
+        self.assertEqual(result, view)
+
+    def test_permitted_no_views(self):
+        from repoze.bfg.exceptions import NotFound
+        mv = self._makeOne()
+        context = DummyContext()
+        request = DummyRequest()
+        self.assertRaises(NotFound, mv.__permitted__, context, request)
+
+    def test_permitted_no_match_with__permitted__(self):
+        mv = self._makeOne()
+        def view(context, request):
+            """ """
+        mv.views = [(100, view)]
+        context = DummyContext()
+        request = DummyRequest()
+        self.assertEqual(mv.__permitted__(None, None), True)
+        
+    def test_permitted(self):
+        from zope.component import getSiteManager
+        mv = self._makeOne()
+        def view(context, request):
+            """ """
+        def permitted(context, request):
+            return False
+        view.__permitted__ = permitted
+        mv.views = [(100, view)]
+        context = DummyContext()
+        request = DummyRequest()
+        sm = getSiteManager()
+        result = mv.__permitted__(context, request)
+        self.assertEqual(result, False)
+
+    def test__call__not_found(self):
+        from repoze.bfg.exceptions import NotFound
+        mv = self._makeOne()
+        context = DummyContext()
+        request = DummyRequest()
+        self.assertRaises(NotFound, mv, context, request)
+
+    def test___call__intermediate_not_found(self):
+        from repoze.bfg.exceptions import NotFound
+        mv = self._makeOne()
+        context = DummyContext()
+        request = DummyRequest()
+        request.view_name = ''
+        expected_response = DummyResponse()
+        def view1(context, request):
+            raise NotFound
+        def view2(context, request):
+            return expected_response
+        mv.views = [(100, view1), (99, view2)]
+        response = mv(context, request)
+        self.assertEqual(response, expected_response)
+
+    def test___call__(self):
+        mv = self._makeOne()
+        context = DummyContext()
+        request = DummyRequest()
+        request.view_name = ''
+        expected_response = DummyResponse()
+        def view(context, request):
+            return expected_response
+        mv.views = [(100, view)]
+        response = mv(context, request)
+        self.assertEqual(response, expected_response)
+
+    def test__call_permissive__not_found(self):
+        from repoze.bfg.exceptions import NotFound
+        mv = self._makeOne()
+        context = DummyContext()
+        request = DummyRequest()
+        self.assertRaises(NotFound, mv, context, request)
+
+    def test___call_permissive_has_call_permissive(self):
+        mv = self._makeOne()
+        context = DummyContext()
+        request = DummyRequest()
+        request.view_name = ''
+        expected_response = DummyResponse()
+        def view(context, request):
+            """ """
+        def permissive(context, request):
+            return expected_response
+        view.__call_permissive__ = permissive
+        mv.views = [(100, view)]
+        response = mv.__call_permissive__(context, request)
+        self.assertEqual(response, expected_response)
+
+    def test___call_permissive_has_no_call_permissive(self):
+        mv = self._makeOne()
+        context = DummyContext()
+        request = DummyRequest()
+        request.view_name = ''
+        expected_response = DummyResponse()
+        def view(context, request):
+            return expected_response
+        mv.views = [(100, view)]
+        response = mv.__call_permissive__(context, request)
+        self.assertEqual(response, expected_response)
+
+class TestRequestOnly(unittest.TestCase):
+    def _callFUT(self, arg):
+        from repoze.bfg.view import requestonly
+        return requestonly(arg)
+    
+    def test_newstyle_class_no_init(self):
+        class foo(object):
+            """ """
+        self.assertFalse(self._callFUT(foo))
+
+    def test_newstyle_class_init_toomanyargs(self):
+        class foo(object):
+            def __init__(self, context, request):
+                """ """
+        self.assertFalse(self._callFUT(foo))
+        
+    def test_newstyle_class_init_onearg_named_request(self):
+        class foo(object):
+            def __init__(self, request):
+                """ """
+        self.assertTrue(self._callFUT(foo))
+
+    def test_newstyle_class_init_onearg_named_somethingelse(self):
+        class foo(object):
+            def __init__(self, req):
+                """ """
+        self.assertTrue(self._callFUT(foo))
+
+    def test_newstyle_class_init_defaultargs_firstname_not_request(self):
+        class foo(object):
+            def __init__(self, context, request=None):
+                """ """
+        self.assertFalse(self._callFUT(foo))
+
+    def test_newstyle_class_init_defaultargs_firstname_request(self):
+        class foo(object):
+            def __init__(self, request, foo=1, bar=2):
+                """ """
+        self.assertTrue(self._callFUT(foo))
+
+    def test_newstyle_class_init_noargs(self):
+        class foo(object):
+            def __init__():
+                """ """
+        self.assertFalse(self._callFUT(foo))
+
+    def test_oldstyle_class_no_init(self):
+        class foo:
+            """ """
+        self.assertFalse(self._callFUT(foo))
+
+    def test_oldstyle_class_init_toomanyargs(self):
+        class foo:
+            def __init__(self, context, request):
+                """ """
+        self.assertFalse(self._callFUT(foo))
+        
+    def test_oldstyle_class_init_onearg_named_request(self):
+        class foo:
+            def __init__(self, request):
+                """ """
+        self.assertTrue(self._callFUT(foo))
+
+    def test_oldstyle_class_init_onearg_named_somethingelse(self):
+        class foo:
+            def __init__(self, req):
+                """ """
+        self.assertTrue(self._callFUT(foo))
+
+    def test_oldstyle_class_init_defaultargs_firstname_not_request(self):
+        class foo:
+            def __init__(self, context, request=None):
+                """ """
+        self.assertFalse(self._callFUT(foo))
+
+    def test_oldstyle_class_init_defaultargs_firstname_request(self):
+        class foo:
+            def __init__(self, request, foo=1, bar=2):
+                """ """
+        self.assertTrue(self._callFUT(foo), True)
+
+    def test_oldstyle_class_init_noargs(self):
+        class foo:
+            def __init__():
+                """ """
+        self.assertFalse(self._callFUT(foo))
+
+    def test_function_toomanyargs(self):
+        def foo(context, request):
+            """ """
+        self.assertFalse(self._callFUT(foo))
+        
+    def test_function_onearg_named_request(self):
+        def foo(request):
+            """ """
+        self.assertTrue(self._callFUT(foo))
+
+    def test_function_onearg_named_somethingelse(self):
+        def foo(req):
+            """ """
+        self.assertTrue(self._callFUT(foo))
+
+    def test_function_defaultargs_firstname_not_request(self):
+        def foo(context, request=None):
+            """ """
+        self.assertFalse(self._callFUT(foo))
+
+    def test_function_defaultargs_firstname_request(self):
+        def foo(request, foo=1, bar=2):
+            """ """
+        self.assertTrue(self._callFUT(foo), True)
+
+    def test_instance_toomanyargs(self):
+        class Foo:
+            def __call__(self, context, request):
+                """ """
+        foo = Foo()
+        self.assertFalse(self._callFUT(foo))
+        
+    def test_instance_defaultargs_onearg_named_request(self):
+        class Foo:
+            def __call__(self, request):
+                """ """
+        foo = Foo()
+        self.assertTrue(self._callFUT(foo))
+
+    def test_instance_defaultargs_onearg_named_somethingelse(self):
+        class Foo:
+            def __call__(self, req):
+                """ """
+        foo = Foo()
+        self.assertTrue(self._callFUT(foo))
+
+    def test_instance_defaultargs_firstname_not_request(self):
+        class Foo:
+            def __call__(self, context, request=None):
+                """ """
+        foo = Foo()
+        self.assertFalse(self._callFUT(foo))
+
+    def test_instance_defaultargs_firstname_request(self):
+        class Foo:
+            def __call__(self, request, foo=1, bar=2):
+                """ """
+        foo = Foo()
+        self.assertTrue(self._callFUT(foo), True)
+
+    def test_instance_nocall(self):
+        class Foo: pass
+        foo = Foo()
+        self.assertFalse(self._callFUT(foo))
+
+
+
 class DummyContext:
     pass