def __setattr__(self, attr, val, other_arg=2.1**10):
     print "__setattr__", attr, val
     print other_arg
     del C.__setattr__
     print other_arg
     sys._clear_type_cache()
     print other_arg

 def __delattr__(self, attr, other_arg=2.3**10):
     print "__delattr__"
     print other_arg
     del C.__delattr__
     print other_arg
     sys._clear_type_cache()
     print other_arg

 def enable(self, sandbox):
     # Blacklist all dict methods able to modify a dict, to protect
     # ReadOnlyBuiltins
     for name in (
     '__init__', 'clear', '__delitem__', 'pop', 'popitem',
     'setdefault', '__setitem__', 'update'):
         del self.dict_dict[name]
     if version_info < (3, 0):
         del self.function_dict['func_closure']
         del self.function_dict['func_globals']
         del self.function_dict['func_code']
         del self.function_dict['func_defaults']
     if version_info >= (2, 6):
         del self.function_dict['__closure__']
         del self.function_dict['__globals__']
         del self.function_dict['__code__']
         del self.function_dict['__defaults__']
     del self.frame_dict['f_locals']
     if ('code' not in sandbox.config.features) \
     and ('traceback' not in sandbox.config.features):
         del self.frame_dict['f_code']
     del self.type_dict['__subclasses__']
     del self.builtin_func_dict['__self__']
     if version_info >= (2, 6) \
     and ('code' not in sandbox.config.features):
         del self.generator_dict['gi_code']
     _clear_type_cache()

 def __set__(self, obj, value, other_arg=2.0**10):
     print "D.__set__", type(obj), value
     print other_arg
     del D.__set__
     print other_arg
     sys._clear_type_cache()
     print other_arg
     return 1

 def __get__(self, obj, type, other_arg=2.4**10):
     print "D.__get__"
     print other_arg
     del C.x
     print other_arg
     sys._clear_type_cache()
     print other_arg
     return 1

 def __getattr__(self, attr, other_arg=2.2**10):
     print "__getattr__"
     print other_arg
     del C.__getattr__
     print other_arg
     sys._clear_type_cache()
     print other_arg
     return attr

 def disable(self, sandbox):
     self.dict_dict.restore()
     self.function_dict.restore()
     self.frame_dict.restore()
     self.type_dict.restore()
     self.builtin_func_dict.restore()
     self.generator_dict.restore()
     # Python 2.6+ uses a method cache: clear it to avoid errors
     _clear_type_cache()

def dash_R_cleanup(fs, ps, pic, zdc, abcs):
    import gc, copy_reg
    import _strptime, linecache
    dircache = test_support.import_module('dircache', deprecated=True)
    import urlparse, urllib, urllib2, mimetypes, doctest
    import struct, filecmp
    from distutils.dir_util import _path_created

    # Clear the warnings registry, so they can be displayed again
    for mod in sys.modules.values():
        if hasattr(mod, '__warningregistry__'):
            del mod.__warningregistry__

    # Restore some original values.
    warnings.filters[:] = fs
    copy_reg.dispatch_table.clear()
    copy_reg.dispatch_table.update(ps)
    sys.path_importer_cache.clear()
    sys.path_importer_cache.update(pic)
    try:
        import zipimport
    except ImportError:
        pass # Run unmodified on platforms without zipimport support
    else:
        zipimport._zip_directory_cache.clear()
        zipimport._zip_directory_cache.update(zdc)

    # clear type cache
    sys._clear_type_cache()

    # Clear ABC registries, restoring previously saved ABC registries.
    for abc, registry in abcs.items():
        abc._abc_registry = registry.copy()
        abc._abc_cache.clear()
        abc._abc_negative_cache.clear()

    # Clear assorted module caches.
    _path_created.clear()
    re.purge()
    _strptime._regex_cache.clear()
    urlparse.clear_cache()
    urllib.urlcleanup()
    urllib2.install_opener(None)
    dircache.reset()
    linecache.clearcache()
    mimetypes._default_mime_types()
    filecmp._cache.clear()
    struct._clearcache()
    doctest.master = None

    # Collect cyclic trash.
    gc.collect()

def dash_R_cleanup(fs, ps, pic, abcs):
    import gc, copy_reg
    import _strptime, linecache
    dircache = test_support.import_module('dircache', deprecated=True)
    import urlparse, urllib, urllib2, mimetypes, doctest
    import struct, filecmp
    from distutils.dir_util import _path_created

    # Clear the warnings registry, so they can be displayed again
    for mod in sys.modules.values():
        if hasattr(mod, '__warningregistry__'):
            del mod.__warningregistry__

    # Restore some original values.
    warnings.filters[:] = fs
    copy_reg.dispatch_table.clear()
    copy_reg.dispatch_table.update(ps)
    sys.path_importer_cache.clear()
    sys.path_importer_cache.update(pic)

    # clear type cache
    sys._clear_type_cache()

    # Clear ABC registries, restoring previously saved ABC registries.
    for abc, registry in abcs.items():
        abc._abc_registry = registry.copy()
        abc._abc_cache.clear()
        abc._abc_negative_cache.clear()

    # Clear assorted module caches.
    _path_created.clear()
    re.purge()
    _strptime._regex_cache.clear()
    urlparse.clear_cache()
    urllib.urlcleanup()
    urllib2.install_opener(None)
    dircache.reset()
    linecache.clearcache()
    mimetypes._default_mime_types()
    filecmp._cache.clear()
    struct._clearcache()
    doctest.master = None

    if _llvm:
        code_types = (types.CodeType, types.FunctionType, types.MethodType)
        for obj in gc.get_objects():
            if isinstance(obj, code_types):
                _llvm.clear_feedback(obj)

    # Collect cyclic trash.
    gc.collect()

def remove_dangerous_attrs():
    """
    Removes all the methods not mentioned in the good_*_methods.py files.
    """
    for i in dangerous:
        for j in method_origin[i]:
            if not hasattr(j, i):
                not_expressed[j].append(i)
            saved[(j, i)] = dictionary_of(j)[i]
            del dictionary_of(j)[i]
            # make sure our modifications is mirrored in the types we modify
            # this is a specialised purpose
            sys._clear_type_cache()
            assert not hasattr(j, i), "{} still has {}".format(j, i)

def assert_no_dangling_Cclasses():
    global CheckForDanglingClasses
    global WorstDanglingCount
    sys._clear_type_cache()
    gc.collect()
    count =  proj_class_live_object_count()
    # Avoid cluttering the output up with redundant messages...
    if count > WorstDanglingCount and CheckForDanglingClasses:
        WorstDanglingCount = count
        if AssertOnDanglingClasses:
            dump_c_objects()
            raise AssertionError, "Dangling C-class objects - %d still around" % count
        else:
            print >> sys.stderr,  ("*****ERROR: Dangling C-class objects - %d still around" % count)

def replace_dangerous_attrs():
    """
    Replaces all the methods removed by :func:`remove_dangerous_attrs`.
    """
    for i in dangerous:
        for j in method_origin[i]:
            dictionary_of(j)[i] = saved[(j, i)]
            # make sure our modifications is mirrored in the types we modify
            # this is a specialised purpose
            sys._clear_type_cache()
            if i in not_expressed[j]:
                assert i in j.__dict__, "{} still doesn't' have {}" \
                    .format(j, i)
            else:
                assert hasattr(j, i), "{} still doesn't' have {}"\
                    .format(j, i)

    def enable(self, sandbox):
        if not sandbox.config.cpython_restricted:
            # Deny access to func.func_code to avoid an attacker to modify a
            # trusted function: replace the code of the function
            hide_func_code = True
        else:
            # CPython restricted mode already denies read and write access to
            # function attributes
            hide_func_code = False

        # Blacklist all dict methods able to modify a dict, to protect
        # ReadOnlyBuiltins
        for name in (
        '__init__', 'clear', '__delitem__', 'pop', 'popitem',
        'setdefault', '__setitem__', 'update'):
            del self.dict_dict[name]
        if version_info < (3, 0):
            # pysandbox stores trusted objects in closures: deny access to
            # closures to not leak these secrets
            del self.function_dict['func_closure']
            del self.function_dict['func_globals']
            if hide_func_code:
                del self.function_dict['func_code']
            del self.function_dict['func_defaults']
        if version_info >= (2, 6):
            del self.function_dict['__closure__']
            del self.function_dict['__globals__']
            if hide_func_code:
                del self.function_dict['__code__']
            del self.function_dict['__defaults__']
        del self.frame_dict['f_locals']

        # Hiding type.__bases__ crashs CPython 2.5 because of a infinite loop
        # in PyErr_ExceptionMatches(): it calls abstract_get_bases() but
        # abstract_get_bases() fails and call PyErr_ExceptionMatches() ...
        if version_info >= (2, 6):
            # Setting __bases__ crash Python < 3.3a2
            # http://bugs.python.org/issue14199
            del self.type_dict['__bases__']

        # object.__subclasses__ leaks the file type in Python 2
        # and (indirectly) the FileIO file in Python 3
        del self.type_dict['__subclasses__']
        del self.builtin_func_dict['__self__']
        _clear_type_cache()

def _refleak_cleanup():
    # Collect cyclic trash and read memory statistics immediately after.
    func1 = sys.getallocatedblocks
    try:
        func2 = sys.gettotalrefcount
    except AttributeError:
        func2 = lambda: 42

    # Flush standard output, so that buffered data is sent to the OS and
    # associated Python objects are reclaimed.
    for stream in (sys.stdout, sys.stderr, sys.__stdout__, sys.__stderr__):
        if stream is not None:
            stream.flush()

    sys._clear_type_cache()
    # This also clears the various internal CPython freelists.
    gc.collect()
    return func1(), func2()

def dash_R_cleanup(fs, ps, pic, zdc, abcs):
    import gc, copyreg
    import collections.abc
    from weakref import WeakSet

    # Restore some original values.
    warnings.filters[:] = fs
    copyreg.dispatch_table.clear()
    copyreg.dispatch_table.update(ps)
    sys.path_importer_cache.clear()
    sys.path_importer_cache.update(pic)
    try:
        import zipimport
    except ImportError:
        pass # Run unmodified on platforms without zipimport support
    else:
        zipimport._zip_directory_cache.clear()
        zipimport._zip_directory_cache.update(zdc)

    # clear type cache
    sys._clear_type_cache()

    # Clear ABC registries, restoring previously saved ABC registries.
    abs_classes = [getattr(collections.abc, a) for a in collections.abc.__all__]
    abs_classes = filter(isabstract, abs_classes)
    if 'typing' in sys.modules:
        t = sys.modules['typing']
        # These classes require special treatment because they do not appear
        # in direct subclasses of collections.abc classes
        abs_classes = list(abs_classes) + [t.ChainMap, t.Counter, t.DefaultDict]
    for abc in abs_classes:
        for obj in abc.__subclasses__() + [abc]:
            obj._abc_registry = abcs.get(obj, WeakSet()).copy()
            obj._abc_cache.clear()
            obj._abc_negative_cache.clear()

    clear_caches()

    # Collect cyclic trash and read memory statistics immediately after.
    func1 = sys.getallocatedblocks
    func2 = sys.gettotalrefcount
    gc.collect()
    return func1(), func2(), support.fd_count()

def assert_no_dangling_Cclasses(doassert=None):
    global CheckForDanglingClasses
    global WorstDanglingCount
    sys._clear_type_cache()
    if doassert is None:
        doassert = AssertOnDanglingClasses
    CMAinit.uninit()
    gc.collect()    # For good measure...
    count =  proj_class_live_object_count()
    #print >>sys.stderr, "CHECKING FOR DANGLING CLASSES (%d)..." % count
    # Avoid cluttering the output up with redundant messages...
    if count > WorstDanglingCount and CheckForDanglingClasses:
        WorstDanglingCount = count
        if doassert:
            print >> sys.stderr, 'STARTING OBJECT DUMP'
            dump_c_objects()
            print >> sys.stderr, 'OBJECT DUMP COMPLETE'
            print 'stdout OBJECT DUMP COMPLETE'
            raise AssertionError("Dangling C-class objects - %d still around" % count)
        else:
            print >> sys.stderr,  ("*****ERROR: Dangling C-class objects - %d still around" % count)

def dash_R_cleanup(fs, ps, pic, zdc, abcs):
    import gc, copyreg
    import collections.abc
    from weakref import WeakSet

    # Restore some original values.
    warnings.filters[:] = fs
    copyreg.dispatch_table.clear()
    copyreg.dispatch_table.update(ps)
    sys.path_importer_cache.clear()
    sys.path_importer_cache.update(pic)
    try:
        import zipimport
    except ImportError:
        pass # Run unmodified on platforms without zipimport support
    else:
        zipimport._zip_directory_cache.clear()
        zipimport._zip_directory_cache.update(zdc)

    # clear type cache
    sys._clear_type_cache()

    # Clear ABC registries, restoring previously saved ABC registries.
    for abc in [getattr(collections.abc, a) for a in collections.abc.__all__]:
        if not isabstract(abc):
            continue
        for obj in abc.__subclasses__() + [abc]:
            obj._abc_registry = abcs.get(obj, WeakSet()).copy()
            obj._abc_cache.clear()
            obj._abc_negative_cache.clear()

    clear_caches()

    # Collect cyclic trash and read memory statistics immediately after.
    func1 = sys.getallocatedblocks
    func2 = sys.gettotalrefcount
    gc.collect()
    return func1(), func2(), fd_count()

def reconfig():
    ''' Set global best configs, eg: gc and recursion limit '''
    cfg = {}
    cfg['sys.platform'] = sys.platform
    cfg['sys.maxsize'] = sys.maxsize
    cfg['sys.path'] = sys.path
    cfg['sys.excepthook'] = sys.excepthook
    cfg['old sys.checkinterval'] = sys.getcheckinterval()
    sys.setcheckinterval(BEST_CHECK_INTERVAL)

    cfg['new sys.checkinterval'] = sys.getcheckinterval()
    cfg['old sys.recursionlimit'] = sys.getrecursionlimit()
    sys.setrecursionlimit(BEST_RECURSION_LIMIT)

    cfg['new sys.recursionlimit'] = sys.getrecursionlimit()
    cfg['old gc.threshold'] = str(gc.get_threshold())
    gc.set_threshold(512, 8, 6)

    cfg['new gc.threshold'] = str(gc.get_threshold())
    sys._clear_type_cache()

    cfg['sys._clear_type_cache'] = True
    return cfg

def _cleanup():
    sys._clear_type_cache()
    gc.collect()

 def test_clear_type_cache(self):
     sys._clear_type_cache()