def setUp(self):
        componenttesting.setUp()
        eventtesting.setUp()
        zcml.load_config("meta.zcml", zope.component)
        zcml.load_config("configure.zcml", Products.StandardCacheManagers)

        folder1, folder2 = self._initFolders()

        folder1.all_meta_types = folder2.all_meta_types = CACHE_META_TYPES

        self.folder1 = folder1
        self.folder2 = folder2

        self.policy = UnitTestSecurityPolicy()
        self.oldPolicy = SecurityManager.setSecurityPolicy(self.policy)

        cm_id = "cache"
        manager = self._makeOne(cm_id)
        self.folder1._setObject(cm_id, manager)
        self.cachemanager = self.folder1[cm_id]
        transaction.savepoint(optimistic=True)

        newSecurityManager(None, UnitTestUser().__of__(self.root))

        CopySupportTestBase.setUp(self)

 def setUp(self):
     super(BaseTileTestCase, self).setUp()
     eventtesting.setUp()
     self._register_tile()
     self.tile = PersistentCoverTile(self.cover, self.request)
     self.tile.__name__ = u'collective.cover.base'
     self.tile.id = u'test'

    def setUp(self):
        self.portal = self.layer['portal']
        self.request = self.layer['request']

        eventtesting.setUp()

        self.tile = PersistentCoverTile(self.portal, self.request)

    def setUp(self):
        self.portal = self.layer['portal']
        self.request = self.layer['request']

        eventtesting.setUp()

        self._register_tile()
        self.tile = PersistentCoverTile(self.portal, self.request)
        # XXX: tile initialization
        self.tile.__name__ = 'collective.cover.base'

def setup_test():
    eventtesting.setUp()
    load_zcml(os.path.join(
        os.path.dirname(dolmen.relations.__file__), 'configure.zcml'))
    load_zcml(os.path.join(
        os.path.dirname(dolmen.relations.__file__), 'subscribers.zcml'))
    sm = component.getGlobalSiteManager()
    sm.registerUtility(IntIds(), IIntIds)
    sm.registerAdapter(connectionOfPersistent, (IPersistent,), IConnection)
    sm.registerAdapter(KeyReferenceToPersistent, (IPersistent,), IKeyReference)

    def setUp(self):
        self.ideal = getUtility(IMollieIdeal)
        self.ideal.old_do_request = self.ideal._do_request
        self.ideal._do_request = MagicMock(
            side_effect=self._side_effect)

        self.foo = Foo()
        self.adapted = IMollieIdealPayment(self.foo)
        self.adapted._partner_id = '999999'
        self.adapted.transaction_id = '482d599bbcc7795727650330ad65fe9b'
        eventtesting.setUp()

def setUp(test):
    setup.placefulSetUp()
    setUpContents()

    eventtesting.setUp()
    component.provideAdapter(idgenerator.NameChooser)

    component.provideHandler(topic.topicIdAddedHandler)
    component.provideHandler(topic.topicModifiedHandler)
    component.provideHandler(topic.topicRemovedHandler)
    component.provideHandler(message.messageModifiedHandler)

    def setUp(self):
        from zope.component import provideHandler
        from zope.component.interfaces import IObjectEvent
        from Products.CMFCore.interfaces import ICookieCrumbler
        from Products.CMFCore.CookieCrumbler import handleCookieCrumblerEvent

        self._finally = None

        eventtesting.setUp()
        provideHandler(handleCookieCrumblerEvent,
                       adapts=(ICookieCrumbler, IObjectEvent))

    def setUp(self):
        """Custom shared utility setup for tests."""
        self.portal = self.layer['portal']
        self.ipn = queryAdapter(self.portal, IIPN)
        self.log = InstalledHandler('niteoweb.ipn.core')
        eventtesting.setUp()

        # create a test member and a test product group
        api.user.create(email='[email protected]')
        api.group.create(groupname='ipn_1')
        api.group.add_user(username='[email protected]', groupname='ipn_1')

    def setUp(self):
        """Custom shared utility setup for tests."""
        self.portal = self.layer['portal']
        self.request = self.layer['request']
        self.ipn = queryAdapter(self.portal, IIPN)
        self.log = InstalledHandler('niteoweb.ipn.core')
        eventtesting.setUp()

        # set a very long valid_to date for the test_user
        # in order to skip this one in our tests below
        test_user = api.user.get(username=TEST_USER_ID)
        test_user.setMemberProperties(
            mapping={'valid_to': DateTime('2020/01/01')})

def placefulSetUp(site=False):
    testing.setUp()
    eventtesting.setUp()
    traversingSetUp()
    setHooks()
    provideAdapter(ContainerTraversable,
                   (ISimpleReadContainer,), ITraversable)
    provideAdapter(SiteManagerAdapter, (Interface,), IComponentLookup)

    if site:
        root = rootFolder()
        createSiteManager(root, setsite=True)
        return root

    def setUp(self):
        ZCMLFileLayer.setUp(self)
        eventtesting.setUp()
        traversingSetUp()
        zope.component.hooks.setHooks()

        # Set up site manager adapter
        zope.component.provideAdapter(
            SiteManagerAdapter, (Interface,), IComponentLookup)

        # Set up site
        site = rootFolder()
        site.setSiteManager(LocalSiteManager(site))
        zope.component.hooks.setSite(site)

    def setUp(self):
        """Custom shared utility setup for tests."""
        self.portal = self.layer['portal']
        self.ipn = queryAdapter(self.portal, IIPN)
        self.log = InstalledHandler('niteoweb.ipn.core')
        eventtesting.setUp()

        # create test product groups and set their validity
        api.group.create(groupname='ipn_1')
        group = api.group.get(groupname='ipn_1')
        group.setGroupProperties(mapping={'validity': 31})

        api.group.create(groupname='ipn_2')
        group = api.group.get(groupname='ipn_2')
        group.setGroupProperties(mapping={'validity': 365})

    def setUp(self):
        testing.setUp()
        eventtesting.setUp()
        traversingSetUp()
        setHooks()
        provideAdapter(ContainerTraversable,
                       (ISimpleReadContainer,), ITraversable)
        provideAdapter(SiteManagerAdapter, (Interface,), IComponentLookup)

        self.root = rootFolder()
        createSiteManager(self.root, setsite=True)

        provideAdapter(connectionOfPersistent, (IPersistent, ), IConnection)
        provideAdapter(
            KeyReferenceToPersistent, (IPersistent, ), IKeyReference)

    def test_register_styles_record(self):
        registry = getUtility(IRegistry)
        record = 'collective.cover.controlpanel.ICoverSettings.styles'

        eventtesting.setUp()

        # just delete the existing record and rerun the handler to verify it
        # was added again
        del registry.records[record]
        eventtesting.clearEvents()
        register_styles_record(self.portal)
        events = eventtesting.getEvents(IRecordAddedEvent)
        self.assertNotEqual(len(events), 0)
        self.assertIn(record, registry.records)
        eventtesting.clearEvents()

    def _doSetUp(obj):
        obj._doSetUpSuper() # pylint:disable=protected-access
        setHooks() # zope.component.hooks registers a zope.testing.cleanup to reset these
        if obj.configure_events:
            if obj.set_up_packages:
                # If zope.component is being configured, we wind up with duplicates if we let
                # eventtesting fully configure itself
                component.provideHandler(eventtesting.events.append, (None,))
            else:
                eventtesting.setUp() # pragma: no cover

        obj.configuration_context = obj.configure_packages(
            set_up_packages=obj.set_up_packages,
            features=obj.features,
            context=obj.configuration_context,
            package=obj.get_configuration_package())

    def test_automatic_purging(self):
        # z3c.caching must purge objects automatically on modified,
        # moved, renamed or removed; testing the whole enchilada is out
        # of the scope of this package
        from z3c.caching.interfaces import IPurgeEvent
        from zope.component import eventtesting
        from zope.event import notify
        from zope.lifecycleevent import ObjectModifiedEvent
        eventtesting.setUp()

        # modifying the poll must fire a Purge event
        notify(ObjectModifiedEvent(self.poll))
        events = eventtesting.getEvents()
        # XXX: Purge event is fired more than once
        #      https://community.plone.org/t/6411?u=hvelarde
        self.assertEventFiredOnce(IPurgeEvent, events)

def setUp(test):
    cleanup.setUp()
    eventtesting.setUp()
    traversingSetUp()

    # resource namespace setup
    from zope.traversing.interfaces import ITraversable
    from zope.traversing.namespace import resource
    zope.component.provideAdapter(
        resource, (None,), ITraversable, name = "resource")
    zope.component.provideAdapter(
        resource, (None, None), ITraversable, name = "resource")

    from zope.browserpage import metaconfigure
    from zope.contentprovider import tales
    metaconfigure.registerType('provider', tales.TALESProviderExpression)

def setUp(test):
    cleanup.setUp()
    eventtesting.setUp()

    from zope.browserpage.metaconfigure import registerType
    from zope.contentprovider import tales
    registerType('provider', tales.TALESProviderExpression)

    # Make sure we are always reloading page template files ;-)
    global mtime_func
    mtime_func = os.path.getmtime
    def number(x):
        global counter
        counter += 1
        return counter
    os.path.getmtime = number

    def setUp(self):
        super(BaseFunctionRunnerTestCase, self).setUp()
        eventtesting.setUp()

        def dummy_func(*args, **kwargs):
            return 'Bar'

        self.dummy_func = dummy_func
        self.args = ['foo', 'bar']
        self.kwargs = {
            'authorized_userid': SITE_OWNER_NAME,
            'site_path': '/plone',
        }
        self.task_kwargs={'baz': 1}
        self.frunner = FunctionRunner(
            func=self.dummy_func,
            new_func=self.dummy_func,
            orig_args=self.args,
            orig_kw=self.kwargs,
            task_kw=self.task_kwargs,
        )