def setUp(test):
    setup.placefulSetUp(True)
    setUpDublinCore()
    component.provideAdapter(storage.Storage)
    component.provideAdapter(AttributeAnnotations)

    hooks.setHooks()
    setup.setUpTraversal()
    setup.setUpSiteManagerLookup()
    setup.setUpTestAsModule(test, 'zojax.content.model.README')

    # generate extension
    ExtensionClass = ExtensionType(
        "content.model",
        IViewModelExtension, ViewModelExtension,
        "View Model", "View model extension.", layer=interface.Interface)

    # register adater
    component.provideAdapter(
        Wrapper(ExtensionClass),
        (interface.Interface, interface.Interface, ExtensionMarker),
        IViewModelExtension)

    # register vocabulary
    getVocabularyRegistry().register(
        'zojax.content.model-list', Models())

    component.provideAdapter(
        Renderer, (IViewModelSupport, interface.Interface),
        interface.Interface, name='index.html')

def setUp(test):
    site = setup.placefulSetUp(True)
    component.provideAdapter(storage.Storage)
    component.provideAdapter(AttributeAnnotations)
    component.provideUtility(expressions.path_translator, name='path')

    ext = extensiontype.ExtensionType(
        'portlets', interfaces.IPortletsExtension,
        extension.PortletsExtension, 'Portlets', u'')
    component.provideAdapter(ext, (IExtensible,), interfaces.IPortletsExtension)

    setup.setUpTestAsModule(test, name='zojax.portlet.TESTS')

    getVocabularyRegistry().register('zojax portlets', vocabulary.Portlets())

    def __call__(self):
        # Get the corresponding vocabulary
        vr = getVocabularyRegistry()
        vocabular = vr.get(None, self.field.vocabularyName)

        # Get the data to construct the store
        fields = ['value', 'title']
        data = list()
        for term in vocabular:
            entry = dict()
            entry['value'] = term.token
            entry['title'] = term.title
            data.append(entry)

        # Attributes for the combobox
        self.name = self.field.getName()
        self.fieldLabel = translate(self.field.title,
                                    context=self.recipe.request)
        self.emptyText = self.field.default
        self.allowBlank = not self.field.required
        self.valueField = 'value'
        self.displayField = 'title'
        self.queryMode = 'local'
        self.store = "Ext.create('Ext.data.Store', {fields: %s, data: %s})" % (json.dumps(fields, indent=' ' * 4), json.dumps(data, indent=' ' * 4))

        # Render the template
        tmpl = loader.load('combobox.json.tpl', cls=NewTextTemplate)
        stream = tmpl.generate(view=self)
        return stream.render()

    def setUp(self):
        super(TestAvailableListingViewsVocabulary, self).setUp()
        self.testcase_mocker = Mocker()

        provideUtility(tile.availableListingViewsVocabulary,
                       name= u"Available Listing Views")

        # mock the registry, so that we have a static
        # configuration in our tests. we test functionality,
        # not configuration..
        proxy = self.testcase_mocker.mock()
        proxy.listing_views
        self.testcase_mocker.result({
                'listing': 'List contents',
                'summary': 'Summarize contents'})
        self.testcase_mocker.count(0, None)

        registry = self.testcase_mocker.mock()
        provideUtility(provides=IRegistry, component=registry)
        registry.forInterface(IContentListingTileSettings)
        self.testcase_mocker.result(proxy)
        self.testcase_mocker.count(0, None)

        # we need to register the vocabulary utility in the
        # vocabulary registry manually at this point:
        vocabulary_registry = getVocabularyRegistry()
        try:
            vocabulary_registry.get(None, u"Available Listing Views")
        except VocabularyRegistryError:
            factory = getUtility(IVocabularyFactory,
                                 name=u"Available Listing Views")
            vocabulary_registry.register(u"Available Listing Views", factory)

        self.testcase_mocker.replay()

 def setUp(self):
     self.root = setup.placefulSetUp(site=True)
     conn_stub = ConnectionStub()
     def register(arg):
         """i just do not know what is this method doing :("""
     conn_stub.register = register
     self.root._p_jar = conn_stub
     provideAdapter(connectionOfPersistent, adapts=[IPersistent], provides=IConnection, )
     provideAdapter(KeyReferenceToPersistent, adapts=[IPersistent], provides=IKeyReference) 
     provideHandler(setQreatureSiteManager)
     provideHandler(setQuizUtilities)
     provideHandler(addQreatureIntIdSubscriber)
     provideAdapter(SiteManagerAdapter)
     provideAdapter(ResultInterval)
     quiz = Quiz(u'init title',u'init body')
     self.root.__setitem__('quiz', quiz)
     #the site is quiz! not the root
     hooks.siteinfo.site = quiz
     provideAdapter(ResultInterval,adapts=[interfaces.IQuizResult], provides=IResultInterval)
     provideAdapter(QuizAsXML,adapts=[interfaces.IQuiz], provides=interfaces.IQuizAsXML)
     provideAdapter(AttributeAnnotations, adapts=[interfaces.IQuizContainer], provides=IAnnotations)
     provideAdapter(QuizContainerNameChooser, adapts=[interfaces.IQuizContainer], provides=INameChooser)
     vocabulary.setVocabularyRegistry(vocabulary.VocabularyRegistry())
     vr = vocabulary.getVocabularyRegistry()
     vr.register('Quiz Results',depends_voc)
     vr.register('Percentage', percentage)
     vr.register('Quiz Leads', leads_voc)
     provideUtility(flatten, interfaces.IQreatureUtility, "Flatten")

 def js(self):
     value_type = self.field.value_type
     vocab = None
     if IChoice.providedBy(self.field.value_type):
         if value_type.vocabulary:
             vocab = value_type.vocabulary
         if value_type.vocabularyName:
             vocab = getVocabularyRegistry().get(
                 self.context, self.field.value_type.vocabularyName)
         values = [(term.token, term.value) for term in vocab]
         old_values = self._get_old_values(vocab)
     else:
         values = enumerate(self.context.portal_catalog.uniqueValuesFor('Subject'))
         old_values = enumerate(self.context.Subject())
     tags = ""
     old_tags = ""
     index = 0
     for index, value in values:
         tags += "{id: '%s', name: '%s'}" % (value.replace("'", "\\'"), value.replace("'", "\\'"))
         if values.index((index, value)) < len(values) - 1:
             tags += ", "
     old_index = 0  # XXX: this is not used
     #prepopulate
     for index, value in old_values:
         old_tags += u"{id: '%s', name: '%s'}" % (value.replace("'", "\\'"), value.replace("'", "\\'"))
         if old_values.index((index, value)) < len(old_values) - 1:
             old_tags += ", "
     result = self.js_template % dict(id=self.id,
         klass=self.klass,
         newtags=unicode(tags, errors='ignore'),
         oldtags=old_tags)
     return result

 def test_items_for_field_vocabulary(self):
     widget = self._getWidget(attribute_type="reference")
     vocab = getVocabularyRegistry().get(None, 'BuildableDistroSeries')
     value_fn = lambda item: canonical_url(
         item.value, force_local_path=True)
     expected_items = self._makeExpectedItems(vocab, value_fn=value_fn)
     self.assertEqual(simplejson.dumps(expected_items), widget.json_items)

    def test_site_layouts_vocabulary_and_manifest(self):
        from zope.schema.vocabulary import getVocabularyRegistry
        portal = self.layer['portal']

        vocab = getVocabularyRegistry().get(portal,
                                            'plone.availableSiteLayouts')
        vocab = list(vocab)
        vocab.sort(key=lambda t: t.token)

        self.assertEqual(len(vocab), 3)

        def _get_layout_vocab(token):
            for term in vocab:
                if term.token == token:
                    return term

        term = _get_layout_vocab('testlayout1/site.html')
        self.assertEqual(term.title, 'Testlayout1')
        self.assertEqual(term.value,
                         u'/++sitelayout++testlayout1/site.html')

        term = _get_layout_vocab('testlayout2/mylayout.html')
        self.assertEqual(term.title, 'My site layout')
        self.assertEqual(term.value,
                         u'/++sitelayout++testlayout2/mylayout.html')

        term = _get_layout_vocab('testlayout2/mylayout2.html')
        self.assertEqual(term.title, 'My site layout 2')
        self.assertEqual(term.value,
                         u'/++sitelayout++testlayout2/mylayout2.html')

 def vocabulary(self):
     # TODO: check if there are vocabularies that need to be protected
     name = self.request.form.get('name', None)
     vocab = ()
     try:
         # TODO: getUtility(IVocabularyFactory???)
         vr = getVocabularyRegistry()
         vocab = vr.get(self.context, name)
     except:
         # eat all exceptions
         pass
     if not vocab:
         # try IContextSourceBinder
         vocab = queryUtility(IContextSourceBinder, name=name)
         if vocab is None:
             return []
         vocab = vocab(self.context)
     result = []
     for term in vocab:
         data = {'token': term.token,
                 'title': term.title}
         if hasattr(term, 'data'):
             data.update(term.data)
         result.append(data)
     return result

 def setUp(self):
     from zope.schema.vocabulary import _clear
     from zope.schema.vocabulary import getVocabularyRegistry
     from zope.schema.tests.states import StateVocabulary
     _clear()
     vr = getVocabularyRegistry()
     vr.register("states", StateVocabulary)

    def setUp(self):
        super(TestArchiver, self).setUp()
        grok('opengever.dossier.archive')
        grok('opengever.dossier.behaviors.filing')

        file_path = os.path.join(
            os.path.dirname(opengever.dossier.__file__),
            'vdexvocabs',
            'type_prefixes.vdex')

        vocabulary_registry = getVocabularyRegistry()
        try:
            vocabulary_registry.get(None, 'opengever.dossier.type_prefixes')
        except VocabularyRegistryError:
            vocabulary_registry.register(
                'opengever.dossier.type_prefixes', VdexVocabulary(file_path))

        proxy = self.mocker.mock()
        proxy.client_id
        self.mocker.result('SKA ARCH')
        self.mocker.count(0, None)

        registry = self.mocker.mock()
        provideUtility(provides=IRegistry, component=registry)
        registry.forInterface(IBaseClientID)
        self.mocker.result(proxy)
        self.mocker.count(0, None)

    def map_with_vocab(self, behavior, fieldname, value):
        """Look in the schema for a vocab and return the mapped value
        """

        if type(value) == int:
            return str(value)

        portal = self.layer['portal']
        fields = getFieldsInOrder(behavior)
        for name, field in fields:
            if name == fieldname:

                # We have different types of fields, so we have to check,
                # that we become the vocabulary
                value_type = field

                if IList.providedBy(field) or ITuple.providedBy(field):
                    value_type = field.value_type

                if IChoice.providedBy(value_type):
                    if value_type.vocabulary:
                        vocab = value_type.vocabulary(portal)

                    else:
                        vocab = getVocabularyRegistry().get(
                            portal, value_type.vocabularyName)

                    value = vocab.getTerm(value).title

        return value

    def getDefaultLaTeXLayout(self):
        voc = getVocabularyRegistry().get(self, 'ftw.book.layoutsVocabulary')

        if len(voc) > 0:
            return voc.by_value.keys()[0]
        else:
            return None

 def prettyprint_country(self, country):
     context = aq_inner(self.context)
     vr = getVocabularyRegistry()
     countries_vocabulary = vr.get(context,
         'chromsystems.userdata.CountryList')
     term = countries_vocabulary.getTerm(country)
     return term.title

    def print_filing_prefixes(self):
        """Reutrns all filing prefixes and their translations"""
        voca = getVocabularyRegistry().get(
                self.context, 'opengever.dossier.type_prefixes')

        for term in voca:
            self.log('%s: %s' % (term.value, term.title))

 def course_types(self):
     context = aq_inner(self.context)
     vr = getVocabularyRegistry()
     vocab = vr.get(context, 'hph.lectures.CourseType')
     course_types = dict()
     for term in vocab:
         course_types[term.value] = term.title
     return course_types

 def set(self, value):
     vr = getVocabularyRegistry()
     vocabular = vr.get(None, self.field.vocabularyName)
     term = vocabular.getTermByToken(value)
     if term.value is None:
         self.field.set(self.model, None)
     else:
         self.field.set(self.model, term.value)

 def _vocabTermValues(self):
     """Return the token values for the vocab."""
     # XXX Abel Deuring 2010-05-21, bug 583502: We cannot simply iterate
     # over the items of AllUserTeamsPariticipationVocabulary, so
     # so iterate over all Persons and check membership.
     vocabulary_registry = getVocabularyRegistry()
     vocab = vocabulary_registry.get(None, 'AllUserTeamsParticipation')
     return [p for p in IStore(Person).find(Person) if p in vocab]

 def prettify_status(self, status):
     context = aq_inner(self.context)
     registry = getVocabularyRegistry()
     vocabulary = registry.get(context, 'wigo.statusapp.ComponentStatus')
     term = vocabulary.getTerm(status)
     info = {}
     info['title'] = term.title
     info['value'] = term.value
     return info

 def _getDistributionOrProductOrProjectGroup(self, name):
     """Return the matching distribution, product or project, or None."""
     vocabulary_registry = getVocabularyRegistry()
     vocab = vocabulary_registry.get(
         None, 'DistributionOrProductOrProjectGroup')
     try:
         return vocab.getTermByToken(name).value
     except LookupError:
         return None