def test_set_pypy_opt_level():
    conf = get_pypy_config()
    set_pypy_opt_level(conf, '2')
    assert conf.objspace.std.withshadowtracking
    conf = get_pypy_config()
    set_pypy_opt_level(conf, '0')
    assert not conf.objspace.std.newshortcut

def test_set_pypy_opt_level():
    conf = get_pypy_config()
    set_pypy_opt_level(conf, '2')
    assert conf.objspace.std.getattributeshortcut
    conf = get_pypy_config()
    set_pypy_opt_level(conf, '0')
    assert not conf.objspace.std.getattributeshortcut

def test_set_pypy_opt_level():
    conf = get_pypy_config()
    set_pypy_opt_level(conf, '2')
    assert conf.objspace.std.withmultidict
    conf = get_pypy_config()
    set_pypy_opt_level(conf, '0')
    assert not conf.objspace.std.withmultidict

def test_stacklessgc_required():
    conf = get_pypy_config()
    conf.translation.gcrootfinder = "stackless"
    assert conf.translation.stackless
    assert conf.translation.type_system == "lltype"
    assert conf.translation.gctransformer == "framework"
    assert conf.translation.gc == "generation"
    conf = get_pypy_config()
    conf.translation.gc = "boehm"
    py.test.raises(ValueError, "conf.translation.gcrootfinder = 'stackless'")

def test_required():
    conf = get_pypy_config()
    assert not conf.translating

    assert conf.objspace.usemodules.gc

    conf.objspace.std.withmapdict = True
    assert conf.objspace.std.withmethodcache
    conf = get_pypy_config()
    conf.objspace.std.withmethodcache = False
    py.test.raises(ConfigError, "conf.objspace.std.withmapdict = True")

def test_required():
    conf = get_pypy_config()
    assert not conf.translating

    assert conf.objspace.usemodules.gc

    conf.objspace.std.withsmallint = True
    assert not conf.objspace.std.withprebuiltint
    conf = get_pypy_config()
    conf.objspace.std.withprebuiltint = True
    py.test.raises(ValueError, "conf.objspace.std.withsmallint = True")

def test_set_opt_level():
    conf = get_pypy_config()
    set_opt_level(conf, '0')
    assert conf.translation.gc == 'boehm'
    assert conf.translation.backendopt.none == True
    conf = get_pypy_config()
    set_opt_level(conf, '2')
    assert conf.translation.gc != 'boehm'
    assert not conf.translation.backendopt.none
    conf = get_pypy_config()
    set_opt_level(conf, 'mem')
    assert conf.translation.gc == 'markcompact'
    assert not conf.translation.backendopt.none

 def getcompiled(self, func, argstypelist = [],
                 annotatorpolicy=None):
     from pypy.config.pypyoption import get_pypy_config
     config = get_pypy_config(translating=True)
     config.translation.gc = self.gcpolicy
     config.translation.thread = self.use_threads
     if self.stacklessgc:
         config.translation.gcrootfinder = "stackless"
     config.translation.simplifying = True
     t = TranslationContext(config=config)
     self.t = t
     a = t.buildannotator(policy=annotatorpolicy)
     a.build_types(func, argstypelist)
     t.buildrtyper().specialize()
     t.checkgraphs()
     def compile():
         cbuilder = CExtModuleBuilder(t, func, config=config)
         c_source_filename = cbuilder.generate_source(
             defines = cbuilder.DEBUG_DEFINES)
         if conftest.option.view:
             t.view()
         cbuilder.compile()
         self._cleanups.append(cbuilder.cleanup) # schedule cleanup after test
         return cbuilder.get_entry_point(isolated=True)
     return compile()

    def config_role(name, rawtext, text, lineno, inliner, options={}, content=[]):
        from docutils import nodes
        from pypy.config.pypyoption import get_pypy_config
        from pypy.config.makerestdoc import get_cmdline

        txt = docdir.join("config", text + ".rst")
        html = docdir.join("config", text + ".html")
        assert txt.check()
        assert name == "config"
        sourcedir = py.path.local(inliner.document.settings._source).dirpath()
        curr = sourcedir
        prefix = ""
        while 1:
            relative = str(html.relto(curr))
            if relative:
                break
            curr = curr.dirpath()
            prefix += "../"
        config = get_pypy_config()
        # begin horror
        h, n = config._cfgimpl_get_home_by_path(text)
        opt = getattr(h._cfgimpl_descr, n)
        # end horror
        cmdline = get_cmdline(opt.cmdline, text)
        if cmdline is not None:
            shortest_long_option = "X" * 1000
            for cmd in cmdline.split():
                if cmd.startswith("--") and len(cmd) < len(shortest_long_option):
                    shortest_long_option = cmd
            text = shortest_long_option
        target = prefix + relative
        reference_node = nodes.reference(rawtext, text, name=text, refuri=target)
        return [reference_node], []

 def setup_class(cls):
     from pypy.translator.platform.maemo import check_scratchbox
     check_scratchbox()
     from pypy.config.pypyoption import get_pypy_config
     config = get_pypy_config(translating=True)
     config.translation.platform = 'maemo'
     cls.config = config

def checkmodule(*modnames, **kwds):
    translate_startup = kwds.pop('translate_startup', True)
    assert not kwds
    config = get_pypy_config(translating=True)
    space = FakeObjSpace(config)
    seeobj_w = []
    modules = []
    for modname in modnames:
        mod = __import__('pypy.module.%s' % modname, None, None, ['__doc__'])
        # force computation and record what we wrap
        module = mod.Module(space, W_Root())
        module.setup_after_space_initialization()
        module.init(space)
        modules.append(module)
        for name in module.loaders:
            seeobj_w.append(module._load_lazily(space, name))
        if hasattr(module, 'submodules'):
            for cls in module.submodules.itervalues():
                submod = cls(space, W_Root())
                for name in submod.loaders:
                    seeobj_w.append(submod._load_lazily(space, name))
    #
    def func():
        for mod in modules:
            mod.startup(space)
    if not translate_startup:
        func()   # call it now
        func = None
    space.translates(func, seeobj_w=seeobj_w,
                     **{'translation.list_comprehension_operations': True})

 def __init__(self, cpu):
     self.cpu = cpu
     self.profiler = EmptyProfiler()
     self.options = Fake()
     self.globaldata = Fake()
     self.config = get_pypy_config(translating=True)
     self.config.translation.jit_ffi = True

    def wrap_stackless_function(self, fn):
        def entry_point(argv):
            os.write(1, str(fn())+"\n")
            return 0

        from pypy.config.pypyoption import get_pypy_config
        config = get_pypy_config(translating=True)
        config.translation.gc = self.gcpolicy
        config.translation.stackless = True
        if self.stacklessgc:
            config.translation.gcrootfinder = "stackless"
        t = TranslationContext(config=config)
        self.t = t
        t.buildannotator().build_types(entry_point, [s_list_of_strings])
        t.buildrtyper().specialize()
        if self.backendopt:
            backend_optimizations(t)

        from pypy.translator.transform import insert_ll_stackcheck
        insert_ll_stackcheck(t)

        cbuilder = CStandaloneBuilder(t, entry_point, config=config)
        cbuilder.stackless = True
        cbuilder.generate_source()
        cbuilder.compile()
        res = cbuilder.cmdexec('')
        return int(res.strip())

def test_rweakref_required():
    conf = get_pypy_config()
    conf.translation.rweakref = False
    set_pypy_opt_level(conf, '3')

    assert not conf.objspace.std.withtypeversion
    assert not conf.objspace.std.withmethodcache

def test_rweakref_required():
    conf = get_pypy_config()
    conf.translation.rweakref = False
    conf.objspace.std.allopts = True

    assert not conf.objspace.std.withtypeversion
    assert not conf.objspace.std.withmethodcache
    assert not conf.objspace.std.withshadowtracking

 def setup_class(cls):
     init_extmodule_code()
     conf = get_pypy_config()
     conf.objspace.extmodules = 'testext.extmod'
     old_sys_path[:] = sys.path[:]
     sys.path.insert(0, str(udir))
     space = StdObjSpace(conf)
     cls.space = space

 def setup_class(cls):
     py.test.skip("TestMaemo: tests skipped for now")
     from pypy.translator.platform.maemo import check_scratchbox
     check_scratchbox()
     from pypy.config.pypyoption import get_pypy_config
     config = get_pypy_config(translating=True)
     config.translation.platform = 'maemo'
     cls.config = config

def make_config(cmdlineopt, **kwds):
    """ make a config from cmdline options (which overrides everything)
    and kwds """

    config = get_pypy_config(translating=False)
    for modname in kwds.pop("usemodules", []):
        setattr(config.objspace.usemodules, modname, True)
    config.set(**kwds)
    return config

 def __init__(self, tmpdir, translator, entrypoint, config=None):
     self.tmpdir = tmpdir
     self.translator = translator
     self.entrypoint = entrypoint
     self.db = self.Database(self)
     if config is None:
         from pypy.config.pypyoption import get_pypy_config
         config = get_pypy_config(translating=True)
     self.config = config

def get_standard_options():
    config = get_pypy_config()
    parser = to_optparse(config, useoptions=["objspace.*"],
                         extra_useage=extra_useage)
    parser.add_option(
        '-H', action="callback",
        callback=run_tb_server,
        help="use web browser for traceback info")
    return config, parser