def test_getweakrefs(self):
        o = C()
        ref1 = weakref.ref(o, self.callback)
        ref2 = weakref.ref(o, self.callback)
        del ref1
        test_support.gc_collect()
        self.assert_(weakref.getweakrefs(o) == [ref2],
                     "list of refs does not match")

        o = C()
        ref1 = weakref.ref(o, self.callback)
        ref2 = weakref.ref(o, self.callback)
        del ref2
        test_support.gc_collect()
        self.assert_(weakref.getweakrefs(o) == [ref1],
                     "list of refs does not match")

        del ref1
        test_support.gc_collect()
        self.assert_(weakref.getweakrefs(o) == [],
                     "list of refs not cleared")

        # assumes ints do not support weakrefs
        self.assert_(weakref.getweakrefs(1) == [],
                     "list of refs does not match for int")

    def test_getweakrefs(self):
        o = C()
        ref1 = weakref.ref(o, self.callback)
        ref2 = weakref.ref(o, self.callback)
        del ref1
        self.assert_(weakref.getweakrefs(o) == [ref2],
                     "list of refs does not match")

        o = C()
        ref1 = weakref.ref(o, self.callback)
        ref2 = weakref.ref(o, self.callback)
        del ref2
        self.assert_(weakref.getweakrefs(o) == [ref1],
                     "list of refs does not match")

	def del_Profile(self, profile, del_users=False, no_archive=False, batch=False):
		""" Delete a user profile (LMC.groups is an instance of
			GroupsController and is needed to delete the profile group). """

		assert ltrace(TRACE_PROFILES, '> del_Profile(%s)' % (profile.name))

		# we need to hold the users lock, in case we need to delete users.

		assert ltrace(TRACE_LOCKS, '  del_Profile locks: %s, %s, %s' % (self.lock, LMC.groups.lock, LMC.users.lock))

		with nested(self.lock, LMC.groups.lock, LMC.users.lock):

			# delete the reference in the controller.
			del self[profile.gid]

			# flush the controler data to disk.
			self.serialize()

			if profile.group.is_system_restricted:
				logging.info(_(u'Kept restricted system group %s.') %
															profile.groupName)
			else:
				try:
					LMC.groups.del_Group(profile.group, del_users=del_users,
						no_archive=no_archive, batch=batch,
						# this one is needed to avoid looping...
						check_profiles=False)
				except exceptions.DoesntExistException:
					logging.info('Group %s does not already exist, skipped.' %
															profile.groupName)

			name = profile.name

			assert ltrace(TRACE_GC, '  profile ref count before del: %d %s' % (
				sys.getrefcount(profile), gc.get_referrers(profile)))
			# delete the hopefully last reference to the object. This will
			# delete it from the reverse mapping caches too.
			import weakref
			print weakref.getweakrefs(profile)
			del profile

		# checkpoint, needed for multi-delete (users-groups-profile) operation,
		# to avoid collecting the deleted users at the end of the run, making
		# throw false-negative operation about non-existing groups.
		gc.collect()

		logging.notice(_(u'Deleted profile %s.') % stylize(ST_NAME, name))

		assert ltrace(TRACE_LOCKS, '  del_Profile locks: %s, %s, %s' % (self.lock, LMC.groups.lock, LMC.users.lock))

 def test_subclass_refs_dont_replace_standard_refs(self):
     class MyRef(weakref.ref):
         pass
     o = Object(42)
     r1 = MyRef(o)
     r2 = weakref.ref(o)
     self.assert_(r1 is not r2)
     self.assertEqual(weakref.getweakrefs(o), [r2, r1])
     self.assertEqual(weakref.getweakrefcount(o), 2)
     r3 = MyRef(o)
     self.assertEqual(weakref.getweakrefcount(o), 3)
     refs = weakref.getweakrefs(o)
     self.assertEqual(len(refs), 3)
     self.assert_(r2 is refs[0])
     self.assert_(r1 in refs[1:])
     self.assert_(r3 in refs[1:])

 def _disconnect(self, cat, slots, **options): #{{{
     numdel = int(options.get('count', 1))
     if numdel < 0:
         numdel = 0
     if isinstance(slots, dict):
         slots = slots.iteritems()
     sigcat = self._categories
     order, sigslot = sigcat[cat]
     if not slots:
         for name, (funchandler, funclist) in sigslot.iteritems():
             del funclist[:]
     else:
         for name, funclist in slots:
             slist = sigslot[name][1]
             slist_rem = slist.remove
             if not funclist:
                 del slist[:]
                 continue
             for f in funclist:
                 count = 0
                 proxies = [pf for pf in getweakrefs(f) if isinstance(pf, CallableProxyType)]
                 for flist in (proxies, repeat(f)):
                     for p in flist:
                         if numdel and count >= numdel:
                             break
                         try:
                             slist_rem(p)
                         except ValueError:
                             if p == f:
                                 break
                         else:
                             count = count + 1
     if cat in ('around', 'replace'):
         self.reload()

def simple_demo():
    class obj(object):
        def __init__(self, a):
            self.a = a
        def __repr__(self):
            return "obj:{0}".format(self.a)

    o = obj(3)
    r = weakref.ref(o)
    if r():
        print "weakref's referent is alive"
        print "weakref's reference's references/proxies is ", weakref.getweakrefs(o)
    del o
    if r():
        print "weakref's referent is not alive"
        print "weakref's reference's references/proxies is ", weakref.getweakrefs(o)

 def test_subclass_refs_dont_replace_standard_refs(self):
     class MyRef(weakref.ref):
         pass
     o = Object(42)
     r1 = MyRef(o)
     r2 = weakref.ref(o)
     self.assertTrue(r1 is not r2)
     self.assertEqual(weakref.getweakrefs(o), [r2, r1])
     self.assertEqual(weakref.getweakrefcount(o), 2)
     r3 = MyRef(o)
     self.assertEqual(weakref.getweakrefcount(o), 3)
     refs = weakref.getweakrefs(o)
     self.assertEqual(len(refs), 3)
     assert set(refs) == set((r1, r2, r3))
     if test_support.check_impl_detail():
         self.assertTrue(r2 is refs[0])
         self.assertIn(r1, refs[1:])
         self.assertIn(r3, refs[1:])

    def test_getweakrefs(self):
        o = C()
        ref1 = weakref.ref(o, self.callback)
        ref2 = weakref.ref(o, self.callback)
        del ref1
        self.assertEqual(weakref.getweakrefs(o), [ref2], "list of refs does not match")

        o = C()
        ref1 = weakref.ref(o, self.callback)
        ref2 = weakref.ref(o, self.callback)
        del ref2
        self.assertEqual(weakref.getweakrefs(o), [ref1], "list of refs does not match")

        del ref1
        self.assertEqual(weakref.getweakrefs(o), [], "list of refs not cleared")

        # assumes ints do not support weakrefs
        self.assertEqual(weakref.getweakrefs(1), [], "list of refs does not match for int")

 def test_subclass_refs_dont_replace_standard_refs(self):
     if test_support.due_to_ironpython_bug("http://www.codeplex.com/IronPython/WorkItem/View.aspx?WorkItemId=21116"):
         return
     class MyRef(weakref.ref):
         pass
     o = Object(42)
     r1 = MyRef(o)
     r2 = weakref.ref(o)
     self.assertTrue(r1 is not r2)
     self.assertEqual(weakref.getweakrefs(o), [r2, r1])
     self.assertEqual(weakref.getweakrefcount(o), 2)
     r3 = MyRef(o)
     self.assertEqual(weakref.getweakrefcount(o), 3)
     refs = weakref.getweakrefs(o)
     self.assertEqual(len(refs), 3)
     self.assertTrue(r2 is refs[0])
     self.assertIn(r1, refs[1:])
     self.assertIn(r3, refs[1:])

 def __eq__(self, other):
     # We want slots to compare equal if they reference the same function/method
     if isinstance(other, Slot):
         if self.method and not other.method or not self.method and other.method:
             return False
         elif self.method and other.method:
             return self.obj == other.obj and self.name == other.name
         else:
             return self.call == other.call
     # We also want slots to compare equal _to_ the function or method they reference
     else:
         if self.method:
             if hasattr(other, 'im_self'):
                 return self.obj in weakref.getweakrefs(other.im_self) and self.name == other.__name__ 
             else: # `other` is not a method
                 return False
         else:
             return self.call in weakref.getweakrefs(other)

 def test_subclass_refs_dont_conflate_callbacks(self):
     class MyRef(weakref.ref):
         pass
     o = Object(42)
     r1 = MyRef(o, id)
     r2 = MyRef(o, str)
     self.assertTrue(r1 is not r2)
     refs = list(weakref.getweakrefs(o))
     self.assertIn(r1, refs)
     self.assertIn(r2, refs)

 def test_subclass_refs_dont_conflate_callbacks(self):
     class MyRef(weakref.ref):
         pass
     o = Object(42)
     r1 = MyRef(o, id)
     r2 = MyRef(o, str)
     self.assert_(r1 is not r2)
     refs = weakref.getweakrefs(o)
     self.assert_(r1 in refs)
     self.assert_(r2 in refs)

 def tearDown(self):
     handler = self.loghandler
     # All this is necessary to properly shut down the logging system and
     # avoid a regrtest complaint.  Thanks to Vinay Sajip for the help.
     handler.close()
     logger.removeHandler(handler)
     for ref in weakref.getweakrefs(handler):
         logging._removeHandlerRef(ref)
     del self.loghandler
     logger.setLevel(self._old_level)
     super(LoggingCatcher, self).tearDown()

    def test_getweakrefs(self):
        def runTest():
            o = C()
            ref1 = weakref.ref(o, self.callback)
            ref2 = weakref.ref(o, self.callback)
            del ref1
            return o, ref2

        o, ref2 = runTest()
        test_support.force_gc_collect()
        self.assertTrue(weakref.getweakrefs(o) == [ref2],
                     "list of refs does not match")

        def runTest():
            def runInnerTest():
                o = C()
                ref1 = weakref.ref(o, self.callback)
                ref2 = weakref.ref(o, self.callback)
                del ref2
                return o, ref1

            o, ref1 = runInnerTest()
            test_support.force_gc_collect()
            self.assertTrue(weakref.getweakrefs(o) == [ref1],
                         "list of refs does not match")

            del ref1
            return o

        o = runTest()
        test_support.force_gc_collect()
        self.assertTrue(weakref.getweakrefs(o) == [],
                     "list of refs not cleared")

        # assumes ints do not support weakrefs
        self.assertTrue(weakref.getweakrefs(1) == [],
                     "list of refs does not match for int")

    def test_getweakrefs(self):
        o = C()
        ref1 = weakref.ref(o, self.callback)
        ref2 = weakref.ref(o, self.callback)
        del ref1
        extra_collect()
        self.assert_(weakref.getweakrefs(o) == [ref2],
                     "list of refs does not match")

        o = C()
        ref1 = weakref.ref(o, self.callback)
        ref2 = weakref.ref(o, self.callback)
        del ref2
        extra_collect()
        if test_support.is_jython:
            # XXX: Likely a Jython bug: the following inline declared
            # [ref1] list isn't garbage collected no matter how many
            # times we force gc.collect(), which prevents ref1 from
            # being garbage collected after it's del'd below. So we
            # explicitly delete our list
            ref1_list = [ref1]
            self.assert_(weakref.getweakrefs(o) == ref1_list,
            #self.assert_(weakref.getweakrefs(o) == [ref1],
                         "list of refs does not match")
            del ref1_list
        else:
            self.assert_(weakref.getweakrefs(o) == [ref1],
                         "list of refs does not match")

        del ref1
        extra_collect()
        self.assert_(weakref.getweakrefs(o) == [],
                     "list of refs not cleared")

        # assumes ints do not support weakrefs
        self.assert_(weakref.getweakrefs(1) == [],
                     "list of refs does not match for int")

        def runTest():
            def runInnerTest():
                o = C()
                ref1 = weakref.ref(o, self.callback)
                ref2 = weakref.ref(o, self.callback)
                del ref2
                return o, ref1

            o, ref1 = runInnerTest()
            test_support.force_gc_collect()
            self.assertTrue(weakref.getweakrefs(o) == [ref1],
                         "list of refs does not match")

            del ref1
            return o

def IsSame(o1, o2):
    '''
        This checks for the identity even if one of the parameters is a weak reference

        :param  o1:
            first object to compare

        :param  o2:
            second object to compare

        @raise
            RuntimeError if both of the passed parameters are weak references
    '''
    # get rid of weak refs (we only need special treatment for proxys)
    if IsWeakRef(o1):
        o1 = o1()
    if IsWeakRef(o2):
        o2 = o2()

    # simple case (no weak objects)
    if not IsWeakObj(o1) and not IsWeakObj(o2):
        return o1 is o2

    # all weak proxys
    if IsWeakProxy(o1) and IsWeakProxy(o2):
        if not o1 == o2:
            # if they are not equal, we know they're not the same
            return False

        # but we cannot say anything if they are the same if they are equal
        raise ReferenceError('Cannot check if object is same if both arguments passed are weak objects')

    # one is weak and the other is not
    if IsWeakObj(o1):
        weak = o1
        original = o2
    else:
        weak = o2
        original = o1

    weaks = weakref.getweakrefs(original)
    for w in weaks:
        if w is weak:  # check the weak object identity
            return True

    return False

 def __dealloc(self, o):
     for r in weakref.getweakrefs(o):
         self._item_refs.pop(r, None)

def _swap_refs(old, new, ignores):
    """Swap references from one object to another"""
    __internal_swaprefs_ignore__ = "swap_refs"    
    # Swap weak references
    refs = weakref.getweakrefs(old)
    if refs:
        try:
            newRef = weakref.ref(new)
        except ValueError:
            pass
        else:
            for oldRef in refs:
                _swap_refs(oldRef, newRef, ignores + (id(refs),))
    del refs

    deque, defaultdict = _bonus_containers()

    # Swap through garbage collector
    referrers = gc.get_referrers(old)
    for container in referrers:
        if id(container) in ignores:
            continue
        containerType = type(container)
        
        if containerType is list or containerType is deque:
            for index in _find_sequence_indices(container, old):
                container[index] = new
        
        elif containerType is tuple:
            # protect from recursive tuples
            orig = container
            if id(orig) in _recursive_tuple_swap:
                continue
            _recursive_tuple_swap.add(id(orig))
            try:
                container = list(container)
                for index in _find_sequence_indices(container, old):
                    container[index] = new
                container = tuple(container)
                _swap_refs(orig, container, ignores + (id(referrers),))
            finally:
                _recursive_tuple_swap.remove(id(orig))
        
        elif containerType is dict or containerType is defaultdict:
            if "__internal_swaprefs_ignore__" not in container:
                try:
                    if old in container:
                        container[new] = container.pop(old)
                except TypeError:  # Unhashable old value
                    pass
                for k,v in container.iteritems():
                    if v is old:
                        container[k] = new

        elif containerType is set:
            container.remove(old)
            container.add(new)

        elif containerType is type:
            if old in container.__bases__:
                bases = list(container.__bases__)
                bases[bases.index(old)] = new
                container.__bases__ = tuple(bases)
        
        elif type(container) is old:
            container.__class__ = new
        
        elif containerType is _InstanceType:
            if container.__class__ is old:
                container.__class__ = new

    def __weakref__(self):
        print "Inside weakref"

a = Example()
b = weakref.proxy(a)
# b = a
#b = weakref.ref(a)
print a,b

'''
c = Example()
Example.get_count()
'''
#print "EE =>", sys.getrefcount(Example())
#print "EAA=>", sys.getrefcount(Example)
b._dp("LL")
#b._dp("LL")
print a.__hash__
#del a
gc.collect()
print b.__hash__
print weakref.getweakrefcount(a)
print weakref.getweakrefs(a)
print "ID :a() =>", id(a)
print "ID :b() =>", id(b)
print "HASH :a() =>", hash(a)


#Proxy objects are not hashable regardless of the referent; this avoids a number of problems related to their fundamentally mutable nature, and prevent their use as dictionary keys.
print "HASH :b() =>", hash(b)