def sessionSetUp(session_data_container_class=PersistentSessionDataContainer):
    placelesssetup.setUp()
    provideAdapter(TestClientId, [IRequest], IClientId)
    provideAdapter(Session, [IRequest], ISession)
    provideUtility(CookieClientIdManager(), IClientIdManager)
    sdc = session_data_container_class()
    provideUtility(sdc, ISessionDataContainer, '')

 def setUp(self):
     placelesssetup.setUp()
     factory = self.getTestClass()
     iface = self.getTestInterface()
     required = self.getAdaptedClass()
     # register language switch for test interface adapter
     ztapi.provideAdapter(required, iface, factory)

    def setUp(self):
        placelesssetup.setUp(self)
        self.config = stubydoo.double()

        # This kind of document uses a rich text field, which has an output
        # attribute.
        self.document = stubydoo.double(body=stubydoo.double())
        self.document.body = u'<p>Test!</p>'

        @zope.component.adapter(None)
        @zope.interface.implementer(interfaces.IHTMLBody)
        def html_body(doc):
            return doc.body
        zope.component.provideAdapter(html_body)

        self.compiler = StyledPageCompilationStrategy(self.document, self.config)

        # This 'stubbing' relies on the fact that the function is accessed
        # through module's getattr always, no references kept.
        from tn.plonestyledpage import styled_page
        self.old_getUniqueId = styled_page.getUniqueId
        styled_page.getUniqueId = lambda page: u'foo'

        self.old_getEscapedStyleBlock = styled_page.getEscapedStyleBlock
        styled_page.getEscapedStyleBlock = lambda page: u'<style>%s</style>' % page.styles

        self.document.styles = u'p{color:red}'

def setUp(test):
    placelesssetup.setUp(test)
    setUpContents()
    component.provideAdapter(
        AnnotationPrincipalPermissionManager, (interface.Interface,))

    setup.setUpTestAsModule(test, 'zojax.content.permissions.TESTS')

def setUp(test):
    placelesssetup.setUp(test)
    testing.setUp()
    component.provideAdapter(view, (None, None), ITraversable, name="view")

    component.provideUtility(
        fileresource.filefactory, IResourceFactoryType)
    component.provideUtility(
        fileresource.filefactory, IResourceFactoryType, name='fileresource')
    component.provideUtility(
        fileresource.imagefactory, IResourceFactoryType, name='imageresource')
    component.provideUtility(
        zrtresource.zrtfactory, IResourceFactoryType, name='zrt')

    component.provideAdapter(
        fileresource.FileResourceAdapter, (FileResource,))

    component.provideUtility(
        command.cssregistry_factory, IZRTCommandFactory, 'cssregistry')

    registry = CSSRegistry()
    registry['fontColor']= property.Property('fontColor', '#11111111')
    registry['fontFamily']= property.Property('fontFamily', 'Verdana')

    component.provideAdapter(
        zcml.Factory(registry),
        (interfaces.ICSSRegistryLayer, interfaces.ICSSRegistryLayer,
         interface.Interface), interfaces.ICSSRegistry, '')

    def afterSetUp(self):
        setUp()
        zcml.load_config("meta.zcml", Products.Five)
        zcml.load_config("permissions.zcml", Products.Five)
        zcml.load_config("configure.zcml", Products.Five.component)
        zcml.load_config("configure.zcml", Products.Five.site)
        zcml_text = """\
        <five:localsite
            xmlns:five="http://namespaces.zope.org/five"
            class="Products.Five.site.tests.dummy.DummySite" />"""

        import warnings
        showwarning = warnings.showwarning
        warnings.showwarning = lambda *a, **k: None

        zcml.load_string(zcml_text)
        manage_addDummySite(self.folder, 'site')
        enableLocalSiteHook(self.folder.site)
        
        warnings.showwarning = showwarning

        # Hook up custom component architecture calls; we need to do
        # this here because zope.app.component.hooks registers a
        # cleanup with the testing cleanup framework, so the hooks get
        # torn down by placelesssetup each time.
        setHooks()

    def setUp(self):
        placelesssetup.setUp(self)
        self.context = zope.container.folder.Folder()
        self.request = stubydoo.double(form={})
        self.add_form = AddForm(self.context)

        self.adder = subscriber_list.SubscriberAdder(self.context,
                                                     self.request,
                                                     self.add_form)

        dates_locale = stubydoo.double()
        self.request.locale = stubydoo.double(dates=dates_locale)

        self.parsed_datetime = datetime.datetime.now()
        self.date_short_fmt = stubydoo.double(
            parse=lambda f, x: self.parsed_datetime
        )

        stubydoo.stub(dates_locale, 'getFormatter').\
                with_args('date', 'short').and_return(self.date_short_fmt)
        stubydoo.stub(dates_locale, 'getFormatter').\
                with_args('date', 'medium').\
                and_return(stubydoo.double(parse='ignored'))
        stubydoo.stub(dates_locale, 'getFormatter').\
                with_args('dateTime', 'short').\
                and_return(stubydoo.double(parse='ignored'))
        stubydoo.stub(dates_locale, 'getFormatter').\
                with_args('dateTime', 'medium').\
                and_return(stubydoo.double(parse='ignored'))

        zope.component.provideAdapter(Publication)

def sessionSetUp(session_data_container_class=PersistentSessionDataContainer):
    placelesssetup.setUp()
    ztapi.provideAdapter(IRequest, IClientId, TestClientId)
    ztapi.provideAdapter(IRequest, ISession, Session)
    ztapi.provideUtility(IClientIdManager, CookieClientIdManager())
    sdc = session_data_container_class()
    ztapi.provideUtility(ISessionDataContainer, sdc, '')

    def setUp(self):
        placelesssetup.setUp(self)

        self.configuration = GlobalConfiguration(
            subscriber_name_xpath=u'',
            add_subscriber_preferences=False,
            subscriber_preferences_url_xpath=u'',
            subscriber_preferences_html=u'',
            add_subscriber_removal=True,
            subscriber_removal_url_xpath=u'',
            subscriber_removal_html=u'',
            inline_styles=False,
        )
        zope.component.provideUtility(self.configuration)

        self.newsletter_attributes = stubydoo.double()
        self.context = stubydoo.double()
        request = object()
        self.newsletter = newsletter.Newsletter(self.context,
                                                request,
                                                self.newsletter_attributes)

        self.message_factory = stubydoo.double(__call__=lambda x, c: c)

        @zope.component.adapter(None, None, None, None)
        @zope.interface.implementer(interfaces.IMessageFactory)
        def message_factory_factory(context, request, newsletter, subscriber):
            return self.message_factory

        zope.component.provideAdapter(message_factory_factory)

def setUpCategory(test):
    placelesssetup.setUp(test)
    ztapi.provideAdapter(IAttributeAnnotatable, IAnnotations,
                         AttributeAnnotations)
    container = SampleContainer()
    test.globs = {'my_container': container}
    directlyProvides(container, IAttributeAnnotatable)

    def setUp(self):
        placelesssetup.setUp(self)

        self.mailhost = stubydoo.double()

        class IPossibleSubscriberProvider(zope.interface.Interface):
            pass
        self.subscriber = stubydoo.double()
        self.subscribers = [self.subscriber]
        self.newsletter = stubydoo.double()
        self.message = stubydoo.double()

        stubydoo.stub(self.newsletter, 'compile').with_args(self.subscriber).\
            and_return(self.message)
        stubydoo.stub(self.mailhost, 'send').with_args(self.message)

        @zope.component.adapter(None)
        @zope.interface.implementer(interfaces.INewsletter)
        def newsletter_adapter(context):
            self.newsletter.context = context
            return self.newsletter
        zope.component.provideAdapter(newsletter_adapter)

        self.context = stubydoo.double()
        self.mailing = mailing.Mailing()

def setUpDebug(test):
    placelesssetup.setUp(test)
    test.real_stderr = sys.stderr
    test.real_argv = list(sys.argv)
    test.olddir = os.getcwd()
    os.chdir(os.path.join(os.path.dirname(__file__), 'testdata'))
    from zope.security.management import endInteraction
    endInteraction()

def setUp(test):
    print "\n---------- SETUP ----------", test
    placelesssetup.setUp()
    xmlconfig.string(zcml_slug)
    metadata.create_all(checkfirst=True)
    # placelesssetup.tearDown() clears the registry
    print "\n---------- register_generic_workflow_adapters -------------", test
    adapters.register_generic_workflow_adapters()

def processorSetUp(test):
    placelesssetup.setUp()
    ztapi.provideAdapter(IStore, IPaymentProcessor, OgoneStandardProcessor,
                         name='Ogone Payments')
    ztapi.provideAdapter(IStore, IOgoneStandardOptions, OgoneStandardOptions)
    ztapi.provideAdapter(annotation_interfaces.IAttributeAnnotatable,
                         annotation_interfaces.IAnnotations,
                         attribute.AttributeAnnotations)

def setUp(app):
    """A setup that includes the basic CA setup"""
    placelesssetup.setUp()
    import Products.Five
    zcml.load_config('meta.zcml', Products.Five)
    zcml.load_config('permissions.zcml', Products.Five)
    zcml.load_config('configure.zcml', Products.Five)
    base_setup(app)

def nonHTTPSessionTestCaseSetUp(sdc_class=PersistentSessionDataContainer):
    # I am getting an error with ClientId and not TestClientId
    placelesssetup.setUp()
    provideAdapter(ClientId, [IRequest], IClientId)
    provideAdapter(Session, [IRequest], ISession)
    provideUtility(CookieClientIdManager(), IClientIdManager)
    sdc = sdc_class()
    provideUtility(sdc, ISessionDataContainer, '')

def nonHTTPSessionTestCaseSetUp(sdc_class=PersistentSessionDataContainer):
    # I am getting an error with ClientId and not TestClientId
    placelesssetup.setUp()
    ztapi.provideAdapter(IRequest, IClientId, ClientId)
    ztapi.provideAdapter(IRequest, ISession, Session)
    ztapi.provideUtility(IClientIdManager, CookieClientIdManager())
    sdc = sdc_class()
    ztapi.provideUtility(ISessionDataContainer, sdc, '')

def lockingSetUp(test):
    placelesssetup.setUp(test)
    z3c.etree.testing.etreeSetup(test)

    # create principal
    participation = TestRequest(environ = {"REQUEST_METHOD": "PUT"})
    participation.setPrincipal(Principal("michael"))
    if queryInteraction() is not None:
        queryInteraction().add(participation)
    else:
        newInteraction(participation)

    events = test.globs["events"] = []
    zope.event.subscribers.append(events.append)

    gsm = zope.component.getGlobalSiteManager()

    gsm.registerAdapter(DemoKeyReference,
                        (IDemo,),
                        zope.app.keyreference.interfaces.IKeyReference)
    gsm.registerAdapter(PhysicallyLocatable, (Demo,))
    gsm.registerAdapter(PhysicallyLocatable, (DemoFolder,))
    gsm.registerAdapter(DemoKeyReference, (IDemoFolder,),
                        zope.app.keyreference.interfaces.IKeyReference)
    gsm.registerAdapter(SiteManagerAdapter,
                        (zope.interface.Interface,), IComponentLookup)
    gsm.registerAdapter(DemoAbsoluteURL,
                        (IDemo, zope.interface.Interface),
                        zope.traversing.browser.interfaces.IAbsoluteURL)
    gsm.registerAdapter(DemoAbsoluteURL,
                        (IDemoFolder, zope.interface.Interface),
                        zope.traversing.browser.interfaces.IAbsoluteURL)

    # register some IDAVWidgets so that we can render the activelock and
    # supportedlock widgets.
    gsm.registerAdapter(z3c.dav.widgets.ListDAVWidget,
                        (zope.schema.interfaces.IList,
                         z3c.dav.interfaces.IWebDAVRequest))
    gsm.registerAdapter(z3c.dav.widgets.ObjectDAVWidget,
                        (zope.schema.interfaces.IObject,
                         z3c.dav.interfaces.IWebDAVRequest))
    gsm.registerAdapter(z3c.dav.widgets.TextDAVWidget,
                        (zope.schema.interfaces.IText,
                         z3c.dav.interfaces.IWebDAVRequest))
    gsm.registerAdapter(z3c.dav.properties.OpaqueWidget,
                        (z3c.dav.properties.DeadField,
                         z3c.dav.interfaces.IWebDAVRequest))
    gsm.registerAdapter(z3c.dav.widgets.TextDAVWidget,
                        (zope.schema.interfaces.IURI,
                         z3c.dav.interfaces.IWebDAVRequest))

    # Need connection to a database to manage locking
    db = test.globs["db"] = ZODB.DB(ZODB.MappingStorage.MappingStorage())
    test.globs["conn"] = db.open()

    # expose these classes to the test
    test.globs["Demo"] = Demo
    test.globs["DemoFolder"] = DemoFolder

 def setUp(self):
     placelesssetup.setUp(self)
     self.cache = {}
     self.context_keys = double(link=lambda *a:None,
                                unlink=lambda *a:None,
                                unlinkContext=lambda *a:None,
                                __contains__=lambda *a:True)
     zope.component.provideUtility(self.cache, interfaces.ICache)
     zope.component.provideUtility(self.context_keys,
                                   interfaces.IContextKeys)
     self.cache_manager = caching.CacheManager()

def setUp(test):
    placelesssetup.setUp()
    testing.setUp()

    endInteraction()

    principal = principalregistry.UnauthenticatedPrincipal('anon','anon','')
    component.provideUtility(
        principal, IFallbackUnauthenticatedPrincipal)
    component.provideUtility(
        principalregistry.principalRegistry, IAuthentication)