def setUpBasicWidgets(test):
    testing.setUp(test)
    ztapi.provideAdapter((IChoice, Interface, Interface), IInputWidget, DropdownWidget)
    ztapi.provideAdapter((IChoice, Interface), IInputWidget, ChoiceInputWidget)
    ztapi.provideAdapter((ISet, IChoice, Interface), IInputWidget, ChoiceCollectionInputWidget)
    ztapi.provideAdapter((ISet, Interface, Interface), IInputWidget, MultiSelectSetWidget)
    ztapi.provideAdapter((ISet, Interface), IInputWidget, CollectionInputWidget)

def formSetUp(test):
    setUp(test)
    i18nSetUp(test)

    for field, widget in test.widgets:
        if isinstance(field, tuple):
            field = field + (IBrowserRequest,)
        else:
            field = (field, IBrowserRequest)
        provideAdapter(
            widget,
            field,
            IInputWidget)
        
    provideAdapter(
       WidgetInputErrorView,
        (IWidgetInputError,
         IBrowserRequest),
        IWidgetInputErrorView,
        )
    provideAdapter(
        InvalidErrorView,
        (Invalid,
         IBrowserRequest),
        IWidgetInputErrorView,
        )

    provideAdapter(TestTemplate, name='default')
    provideAdapter(requestToTZInfo)
    provideAdapter(
        form.render_submit_button, name='render')

def setUpIntegration(test):
    setUp(test)
    zope.configuration.xmlconfig.XMLConfig('meta.zcml', zope.component)()
    zope.configuration.xmlconfig.XMLConfig('meta.zcml', zope.security)()
    zope.configuration.xmlconfig.XMLConfig('meta.zcml', zope.i18n)()
    zope.configuration.xmlconfig.XMLConfig('meta.zcml', z3c.form)()
    zope.configuration.xmlconfig.XMLConfig('configure.zcml', z3c.form)()

def setUp(test):
    placelesssetup.setUp()

    # Attempt to initialize mappers only if their not already mapped.
    try:
        orm.class_mapper(schema.Content)
    except orm.exc.UnmappedClassError:
        schema.initialize_mapper()

    component.provideAdapter(transform.StringTransform)
    component.provideAdapter(transform.IntegerTransform)
    component.provideAdapter(transform.FloatTransform)
    component.provideAdapter(transform.DateTimeTransform)
    component.provideAdapter(transform.LinesTransform)
    component.provideAdapter(transform.BooleanTransform)
    component.provideAdapter(transform.FileTransform)
    component.provideAdapter(transform.PhotoTransform)
    component.provideAdapter(transform.ReferenceTransform)

    component.provideUtility(peer.PeerRegistry())
    component.provideAdapter(
        peer.PeerFactory,
        (interfaces.IMirrored, interfaces.ISchemaTransformer))

    component.provideAdapter(transform.SchemaTransformer,
                             (interfaces.IMirrored, interfaces.IMetaData))
    component.provideAdapter(serializer.Serializer, (interfaces.IMirrored,))
    component.provideAdapter(
        operation.OperationFactory, (interfaces.IMirrored,))
    component.provideUtility(operation.OperationBufferFactory())

    def setUp(cls):
        testing.setUp()
        zcml.load_config('meta.zcml', Products.Five)
        zcml.load_config('encrypt.zcml', Products.SQLPASPlugin)

        app = ZopeTestCase.app()

        # Create our sandbox
        app.manage_addFolder(SANDBOX_ID)
        sandbox = app[SANDBOX_ID]

        # Add a cache manager
        factory = sandbox.manage_addProduct['StandardCacheManagers']
        factory.manage_addRAMCacheManager(CACHE_MANAGER_ID)

        # Setup the DB connection and PAS instances
        cls.conn = cls.setupConnection(sandbox)
        cls.pas = cls.setupPAS(sandbox)

        # Update PAS to use test tables
        users = cls.pas[USERMANAGER_ID]
        users.manage_changeProperties(users_table=TESTING_USERS_TABLE)
        roles = cls.pas[ROLEMANAGER_ID]
        roles.manage_changeProperties(roles_table=TESTING_ROLES_TABLE)
        props = cls.pas[PROPERTYPROVIDER_ID]
        props.manage_changeProperties(users_table=TESTING_USERS_TABLE)

        # Create the tables tests
        cls.execute(cls.createTable(TESTING_USERS_TABLE,
                                    TESTING_USERS_COLUMNS))
        cls.execute(cls.createTable(TESTING_ROLES_TABLE,
                                    TESTING_ROLES_COLUMNS))

        transaction.commit()
        ZopeTestCase.close(app)

 def setUp(test):
     import importlib
     try:
         importlib.import_module(required_module)
     except ImportError: # pragma: no cover
         raise unittest.SkipTest("Required module %r missing" % (required_module,))
     testing.setUp(test)

    def setUp(self):
        from zope.interface import implementer
        from zope.security.tests import module
        try:
            from zope.component.testing import setUp
        except ImportError:
            pass
        else:
            setUp()
        defineDirectives()

        class B(object):
            def m1(self):
                return "m1"
            def m2(self):
                return "m2"
        @implementer(module.I)
        class C(B):
            def m3(self):
                return "m3"
            def m4(self):
                return "m4"
        module.test_base = B
        module.test_class = C
        module.test_instance = C()
        self.assertState()

def setUp(test=None):
    testing.setUp(test=test)
    zcml = ZCMLWrapper()
    zcml.include('schooltool.common', file="zcmlfiles.zcml")
    zcml.include('schooltool.traverser', file='meta.zcml')
    zcml.include('schooltool.traverser')
    test.globs['zcml'] = zcml

def configurationSetUp(self):
    """ Setup
    """
    setUp()
    XMLConfig('meta.zcml', zope.component)()
    XMLConfig('meta.zcml', zope.browserresource)()
    XMLConfig('configure.zcml', eea.faceted.vocabularies)()

    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):
     from zope.security.tests.exampleclass import ExampleClass
     try:
         del ExampleClass.__implements__
     except AttributeError:
         pass
     from zope.component.testing import setUp
     setUp()

def clearZCML(test=None):
    from zope.configuration.xmlconfig import XMLConfig
    import zope.component
    from zope.component.testing import setUp
    from zope.component.testing import tearDown
    tearDown()
    setUp()
    XMLConfig('meta.zcml', zope.component)()

def setUpCategoryTests(test):
    testing.setUp(test)
    # Setup our adapter from category to rating api
    ztapi.provideAdapter(IAttributeAnnotatable, IAnnotations,
                         AttributeAnnotations)
    container = SampleContainer()
    directlyProvides(container, IAttributeAnnotatable)
    test.globs = {'my_container': container}

def setUp(test=None):
    testing.setUp(test)
    zcml.load_config('meta.zcml', package=Products.Five)
    zcml.load_config('configure.zcml', package=Products.Five)
    zcml.load_config('meta.zcml', package=five.grok)
    zcml.load_config('configure.zcml', package=five.grok)
    zcml.load_config('configure.zcml', package=spear.ids)
    zcml.load_config('configure.zcml', package=spear.content)

def formSetUp(test):
    from zope.formlib.textwidgets import TextWidget
    from zope.formlib.interfaces import IInputWidget
    from zope.publisher.interfaces.browser import IBrowserRequest
    from zope.schema.interfaces import ITextLine
    testing.setUp(test)
    provideAdapter(
        TextWidget, [ITextLine, IBrowserRequest], IInputWidget, )

def setUpViewTests(test):
    setUp(test)
    # Setup our adapter from category to rating api
    ztapi.provideAdapter((IRatingCategory, Interface),
                             IRatingManager, RatingCategoryAdapter)
    ztapi.provideAdapter(IAttributeAnnotatable, IAnnotations,
                         AttributeAnnotations)
    container = SampleContainer()
    directlyProvides(container, IAttributeAnnotatable)
    test.globs = {'my_container': container}

def setUp(test):
    testing.setUp(test)
    provideAdapter(DefaultTraversable, (None,))
    provideAdapter(BrowserLanguages)
    provideAdapter(HTTPCharsets)

    import Products.Five
    import five.customerize
    load_config('configure.zcml', package=Products.Five)
    load_config('configure.zcml', package=five.customerize)
    setHooks()

def setUp(test, session_data_container_class=RAMSessionDataContainer):
    placelesssetup.setUp()
    component.provideAdapter(ClientId, (IRequest,), IClientId)
    component.provideAdapter(Session, (IRequest,), ISession)
    component.provideUtility(CookieClientIdManager(), IClientIdManager)
    sdc = session_data_container_class()
    for product_id in ('', 'products.foo', 'products.bar', 'products.baz'):
        component.provideUtility(sdc, ISessionDataContainer, product_id)
    request = TestRequest(BytesIO())
    test.globs['request'] = request
    return request

 def setUp(self):
     setUp()
     provideUtility(PDFConverter, IConverter, name='application/pdf')
     provideUtility(SplitterFactory, IFactory,
                    name='txng.splitters.default')
     provideUtility(SimpleSplitterFactory, IFactory,
                    name='txng.splitters.simple')
     provideUtility(EnglishParser(), IParser, name='txng.parsers.en')
     provideUtility(LexiconFactory, IFactory, name='txng.lexicons.default')
     provideUtility(StorageFactory, IFactory, name='txng.storages.default')
     provideUtility(Stopwords(), IStopwords)
     provideUtility(Normalizer(), INormalizer)

def setUp(self=None):
    from zope.component.testing import setUp
    setUp()

    import zope.component
    XMLConfig('meta.zcml', zope.component)()

    import plone.i18n.normalizer
    XMLConfig('configure.zcml', plone.i18n.normalizer)()

    from zope.publisher.browser import BrowserLanguages
    zope.component.provideAdapter(BrowserLanguages)