Python conftest.gettestobjspace函数代码示例

    def make_class(cls):
        # XXX: this is (mostly) wrong: .compile() compiles the code object
        # using the host python compiler, but then in the tests we load it
        # with py.py. It works (mostly by chance) because the two functions
        # are very simple and the bytecodes are compatible enough.
        co = py.code.Source(
            """
        def get_name():
            return __name__
        def get_file():
            return __file__
        """
        ).compile()

        if cls.compression == ZIP_DEFLATED:
            space = gettestobjspace(usemodules=["zipimport", "zlib", "rctime", "struct"])
        else:
            space = gettestobjspace(usemodules=["zipimport", "rctime", "struct"])

        cls.space = space
        tmpdir = udir.ensure("zipimport_%s" % cls.__name__, dir=1)
        now = time.time()
        cls.w_now = space.wrap(now)
        test_pyc = cls.make_pyc(space, co, now)
        cls.w_test_pyc = space.wrap(test_pyc)
        cls.w_compression = space.wrap(cls.compression)
        cls.w_pathsep = space.wrap(cls.pathsep)
        # ziptestmodule = tmpdir.ensure('ziptestmodule.zip').write(
        ziptestmodule = tmpdir.join("somezip.zip")
        cls.w_tmpzip = space.wrap(str(ziptestmodule))
        cls.w_co = space.wrap(co)
        cls.tmpdir = tmpdir

 def setup_class(cls):
     # This imports support_test_sre as the global "s"
     try:
         cls.space = gettestobjspace(usemodules=('_locale',))
     except py.test.skip.Exception:
         cls.space = gettestobjspace(usemodules=('_rawffi',))
     init_globals_hack(cls.space)

def setup_module(mod):
    if os.name != 'nt':
        mod.space = gettestobjspace(usemodules=['posix', 'fcntl'])
    else:
        # On windows, os.popen uses the subprocess module
        mod.space = gettestobjspace(usemodules=['posix', '_rawffi', 'thread'])
    mod.path = udir.join('posixtestfile.txt')
    mod.path.write("this is a test")
    mod.path2 = udir.join('test_posix2-')
    pdir = udir.ensure('posixtestdir', dir=True)
    pdir.join('file1').write("test1")
    os.chmod(str(pdir.join('file1')), 0600)
    pdir.join('file2').write("test2")
    pdir.join('another_longer_file_name').write("test3")
    mod.pdir = pdir
    unicode_dir = udir.ensure('fi\xc5\x9fier.txt', dir=True)
    unicode_dir.join('somefile').write('who cares?')
    mod.unicode_dir = unicode_dir

    # in applevel tests, os.stat uses the CPython os.stat.
    # Be sure to return times with full precision
    # even when running on top of CPython 2.4.
    os.stat_float_times(True)

    # Initialize sys.filesystemencoding
    space.call_method(space.getbuiltinmodule('sys'), 'getfilesystemencoding')

 def setup_class(cls):
     try:
         cls.space = gettestobjspace(usemodules=('_locale',))
     except Skipped:
         cls.space = gettestobjspace(usemodules=('_rawffi',))
     # This imports support_test_sre as the global "s"
     init_globals_hack(cls.space)

    def test_hash_against_normal_tuple(self):
        N_space = gettestobjspace(**{"objspace.std.withspecialisedtuple": False})
        S_space = gettestobjspace(**{"objspace.std.withspecialisedtuple": True})
        
        def hash_test(values, must_be_specialized=True):
            N_values_w = [N_space.wrap(value) for value in values]
            S_values_w = [S_space.wrap(value) for value in values]
            N_w_tuple = N_space.newtuple(N_values_w)
            S_w_tuple = S_space.newtuple(S_values_w)

            if must_be_specialized:
                assert isinstance(S_w_tuple, W_SpecialisedTupleObject)
            assert isinstance(N_w_tuple, W_TupleObject)
            assert S_space.is_true(S_space.eq(N_w_tuple, S_w_tuple))
            assert S_space.is_true(S_space.eq(N_space.hash(N_w_tuple), S_space.hash(S_w_tuple)))

        hash_test([1,2])
        hash_test([1.5,2.8])
        hash_test([1.0,2.0])
        hash_test(['arbitrary','strings'])
        hash_test([1,(1,2,3,4)])
        hash_test([1,(1,2)])
        hash_test([1,('a',2)])
        hash_test([1,()])
        hash_test([1,2,3], must_be_specialized=False)

 def test_abi_tag(self):
     space1 = gettestobjspace(soabi='TEST')
     space2 = gettestobjspace(soabi='')
     if sys.platform == 'win32':
         assert importing.get_so_extension(space1) == '.TESTi.pyd'
         assert importing.get_so_extension(space2) == '.pyd'
     else:
         assert importing.get_so_extension(space1) == '.TESTi.so'
         assert importing.get_so_extension(space2) == '.so'

    def test_hash_agains_normal_tuple(self):
        normalspace = gettestobjspace(**{"objspace.std.withsmalltuple": False})
        w_tuple = normalspace.newtuple([self.space.wrap(1), self.space.wrap(2)])

        smallspace = gettestobjspace(**{"objspace.std.withsmalltuple": True})
        w_smalltuple = smallspace.newtuple([self.space.wrap(1), self.space.wrap(2)])

        assert isinstance(w_smalltuple, W_SmallTupleObject)
        assert isinstance(w_tuple, W_TupleObject)
        assert not normalspace.is_true(normalspace.eq(w_tuple, w_smalltuple))
        assert smallspace.is_true(smallspace.eq(w_tuple, w_smalltuple))
        assert smallspace.is_true(smallspace.eq(normalspace.hash(w_tuple), smallspace.hash(w_smalltuple)))

 def setup_class(cls):
     cls.space = gettestobjspace(usemodules=['cpyext', 'thread', '_rawffi'])
     cls.space.getbuiltinmodule("cpyext")
     from pypy.module.imp.importing import importhook
     importhook(cls.space, "os") # warm up reference counts
     state = cls.space.fromcache(RefcountState)
     state.non_heaptypes_w[:] = []

    def setup_class(cls):
        if option.runappdirect:
            py.test.skip("Can't run this test with -A")
        space = gettestobjspace(usemodules=('pypyjit',))
        cls.space = space
        w_f = space.appexec([], """():
        def f():
            pass
        return f
        """)
        ll_code = cast_instance_to_base_ptr(w_f.code)
        logger = Logger(MockSD())

        oplist = parse("""
        [i1, i2]
        i3 = int_add(i1, i2)
        guard_true(i3) []
        """, namespace={'ptr0': 3}).operations

        def interp_on_compile():
            pypyjitdriver.on_compile(logger, LoopToken(), oplist, 'loop',
                                     0, False, ll_code)

        def interp_on_compile_bridge():
            pypyjitdriver.on_compile_bridge(logger, LoopToken(), oplist, 0)
        
        cls.w_on_compile = space.wrap(interp2app(interp_on_compile))
        cls.w_on_compile_bridge = space.wrap(interp2app(interp_on_compile_bridge))

 def setup_class(cls):
     cls.space = gettestobjspace(**{"objspace.std.withmapdict": True})
     if option.runappdirect:
         py.test.skip("can only be run on py.py")
     def has_mapdict(space, w_inst):
         return space.wrap(w_inst._get_mapdict_map() is not None)
     cls.w_has_mapdict = cls.space.wrap(gateway.interp2app(has_mapdict))

    def setup_class(cls):
        if sys.platform == "win32":
            py.test.skip("select() doesn't work with pipes on win32")
        space = gettestobjspace(usemodules=("select",))
        cls.space = space

        # Wraps a file descriptor in an socket-like object
        cls.w_getpair = space.appexec(
            [],
            """():
        import os
        class FileAsSocket:
            def __init__(self, fd):
                self.fd = fd
            def fileno(self):
                return self.fd
            def send(self, data):
                return os.write(self.fd, data)
            def recv(self, length):
                return os.read(self.fd, length)
            def close(self):
                return os.close(self.fd)
        def getpair():
            s1, s2 = os.pipe()
            return FileAsSocket(s1), FileAsSocket(s2)
        return getpair""",
        )

 def setup_class(cls):
     space = gettestobjspace(usemodules=('_continuation', '_socket'))
     cls.space = space
     if option.runappdirect:
         cls.w_lev = space.wrap(14)
     else:
         cls.w_lev = space.wrap(2)

 def setup_class(cls):
     from pypy.interpreter import gateway
     cls.space = gettestobjspace(
         **{"objspace.std.withmapdict": True,
            "objspace.std.withmethodcachecounter": True,
            "objspace.opcodes.CALL_METHOD": True})
     #
     def check(space, w_func, name):
         w_code = space.getattr(w_func, space.wrap('func_code'))
         nameindex = map(space.str_w, w_code.co_names_w).index(name)
         entry = w_code._mapdict_caches[nameindex]
         entry.failure_counter = 0
         entry.success_counter = 0
         INVALID_CACHE_ENTRY.failure_counter = 0
         #
         w_res = space.call_function(w_func)
         assert space.eq_w(w_res, space.wrap(42))
         #
         entry = w_code._mapdict_caches[nameindex]
         if entry is INVALID_CACHE_ENTRY:
             failures = successes = 0
         else:
             failures = entry.failure_counter
             successes = entry.success_counter
         globalfailures = INVALID_CACHE_ENTRY.failure_counter
         return space.wrap((failures, successes, globalfailures))
     check.unwrap_spec = [gateway.ObjSpace, gateway.W_Root, str]
     cls.w_check = cls.space.wrap(gateway.interp2app(check))

    def setup_class(cls):
        space = gettestobjspace(usemodules=('_multiprocessing', 'thread', 'signal',
                                            'struct', 'array'))
        cls.space = space
        cls.w_connections = space.newlist([])

        def socketpair(space):
            "A socket.socketpair() that works on Windows"
            import socket, errno
            serverSocket = socket.socket()
            serverSocket.bind(('127.0.0.1', 0))
            serverSocket.listen(1)

            client = socket.socket()
            client.setblocking(False)
            try:
                client.connect(('127.0.0.1', serverSocket.getsockname()[1]))
            except socket.error, e:
                assert e.args[0] in (errno.EINPROGRESS, errno.EWOULDBLOCK)
            server, addr = serverSocket.accept()

            # keep sockets alive during the test
            space.call_method(cls.w_connections, "append", space.wrap(server))
            space.call_method(cls.w_connections, "append", space.wrap(client))

            return space.wrap((server.fileno(), client.fileno()))

 def setup_class(cls):
     cls.space = gettestobjspace(**{"objspace.std.withcelldict": True})
     cls.w_impl_used = cls.space.appexec([], """():
         import __pypy__
         def impl_used(obj):
             assert "ModuleDictImplementation" in __pypy__.internal_repr(obj)
         return impl_used
     """)
     def is_in_cache(space, w_code, w_globals, w_name):
         name = space.str_w(w_name)
         cache = get_global_cache(space, w_code, w_globals)
         index = [space.str_w(w_n) for w_n in w_code.co_names_w].index(name)
         return space.wrap(cache[index].w_value is not None)
     is_in_cache = gateway.interp2app(is_in_cache)
     cls.w_is_in_cache = cls.space.wrap(is_in_cache) 
     stored_builtins = []
     def rescue_builtins(space):
         w_dict = space.builtin.getdict()
         content = {}
         for key, cell in w_dict.implementation.content.iteritems():
             newcell = ModuleCell()
             newcell.w_value = cell.w_value
             content[key] = newcell
         stored_builtins.append(content)
     rescue_builtins = gateway.interp2app(rescue_builtins)
     cls.w_rescue_builtins = cls.space.wrap(rescue_builtins) 
     def restore_builtins(space):
         w_dict = space.builtin.getdict()
         if not isinstance(w_dict.implementation, ModuleDictImplementation):
             w_dict.implementation = ModuleDictImplementation(space)
         w_dict.implementation.content = stored_builtins.pop()
     restore_builtins = gateway.interp2app(restore_builtins)
     cls.w_restore_builtins = cls.space.wrap(restore_builtins)