Rev 132: Switch to using 'parents' for referrers and 'children' for referred to objects. in http://bazaar.launchpad.net/~meliae-dev/meliae/trunk
John Arbash Meinel
john at arbash-meinel.com
Fri Jan 8 22:20:38 GMT 2010
At http://bazaar.launchpad.net/~meliae-dev/meliae/trunk
------------------------------------------------------------
revno: 132
revision-id: john at arbash-meinel.com-20100108222026-oa7vumiv821whlrh
parent: john at arbash-meinel.com-20100108221036-f96y84kltx9ya10u
committer: John Arbash Meinel <john at arbash-meinel.com>
branch nick: trunk
timestamp: Fri 2010-01-08 16:20:26 -0600
message:
Switch to using 'parents' for referrers and 'children' for referred to objects.
-------------- next part --------------
=== modified file 'meliae/_loader.pyx'
--- a/meliae/_loader.pyx 2010-01-08 22:10:36 +0000
+++ b/meliae/_loader.pyx 2010-01-08 22:20:26 +0000
@@ -164,7 +164,7 @@
PyObject *type_str
# Consider making this unsigned long
long size
- RefList *ref_list
+ RefList *children
# Removed for now, since it hasn't proven useful
# int length
PyObject *value
@@ -180,7 +180,7 @@
PyObject *proxy
-cdef _MemObject *_new_mem_object(address, type_str, size, ref_list,
+cdef _MemObject *_new_mem_object(address, type_str, size, children,
value, name, parent_list, total_size) except NULL:
cdef _MemObject *new_entry
cdef PyObject *addr
@@ -195,7 +195,7 @@
new_entry.type_str = <PyObject *>type_str
Py_INCREF(new_entry.type_str)
new_entry.size = size
- new_entry.ref_list = _list_to_ref_list(ref_list)
+ new_entry.children = _list_to_ref_list(children)
# TODO: Was found wanting and removed
# if length is None:
# new_entry.length = -1
@@ -225,8 +225,8 @@
cur.address = NULL
Py_XDECREF(cur.type_str)
cur.type_str = NULL
- _free_ref_list(cur.ref_list)
- cur.ref_list = NULL
+ _free_ref_list(cur.children)
+ cur.children = NULL
Py_XDECREF(cur.value)
cur.value = NULL
# Py_XDECREF(cur.name)
@@ -246,7 +246,7 @@
cdef class _MemObjectProxy
-def _MemObjectProxy_from_args(address, type_str, size, ref_list=(), length=0,
+def _MemObjectProxy_from_args(address, type_str, size, children=(), length=0,
value=None, name=None, parent_list=(),
total_size=0):
"""Create a standalone _MemObjectProxy instance.
@@ -257,7 +257,7 @@
cdef _MemObject *new_entry
cdef _MemObjectProxy proxy
- new_entry = _new_mem_object(address, type_str, size, ref_list,
+ new_entry = _new_mem_object(address, type_str, size, children,
value, name, parent_list, total_size)
proxy = _MemObjectProxy(None)
proxy._obj = new_entry
@@ -283,7 +283,7 @@
:ivar size: The number of bytes consumed for just this object. So for a
dict, this would be the basic_size + the size of the allocated array to
store the reference pointers
- :ivar ref_list: A list of items referenced from this object
+ :ivar children: A list of items referenced from this object
:ivar num_refs: Count of references, you can also use len()
:ivar value: A PyObject representing the Value for this object. (For
strings, it is the first 100 bytes, it may be None if we have no value,
@@ -369,9 +369,9 @@
self._obj.total_size = value
def __len__(self):
- if self._obj.ref_list == NULL:
+ if self._obj.children == NULL:
return 0
- return self._obj.ref_list.size
+ return self._obj.children.size
property num_refs:
def __get__(self):
@@ -381,22 +381,22 @@
cdef long i
_set_default_ptr(cache, &self._obj.address)
_set_default_ptr(cache, &self._obj.type_str)
- if self._obj.ref_list != NULL:
- for i from 0 <= i < self._obj.ref_list.size:
- _set_default_ptr(cache, &self._obj.ref_list.refs[i])
+ if self._obj.children != NULL:
+ for i from 0 <= i < self._obj.children.size:
+ _set_default_ptr(cache, &self._obj.children.refs[i])
if self._obj.parent_list != NULL:
for i from 0 <= i < self._obj.parent_list.size:
_set_default_ptr(cache, &self._obj.parent_list.refs[i])
- property ref_list:
+ property children:
"""The list of objects referenced by this object."""
def __get__(self):
- return _ref_list_to_list(self._obj.ref_list)
+ return _ref_list_to_list(self._obj.children)
def __set__(self, value):
- _free_ref_list(self._obj.ref_list)
- self._obj.ref_list = _list_to_ref_list(value)
+ _free_ref_list(self._obj.children)
+ self._obj.children = _list_to_ref_list(value)
# TODO: deprecated for clarity
property referrers:
@@ -436,13 +436,13 @@
def __getitem__(self, offset):
cdef long off
- if self._obj.ref_list == NULL:
+ if self._obj.children == NULL:
raise IndexError('%s has no references' % (self,))
off = offset
- if off >= self._obj.ref_list.size:
+ if off >= self._obj.children.size:
raise IndexError('%s has only %d (not %d) references'
- % (self, self._obj.ref_list.size, offset))
- address = <object>self._obj.ref_list.refs[off]
+ % (self, self._obj.children.size, offset))
+ address = <object>self._obj.children.refs[off]
try:
return self.collection[address]
except KeyError:
@@ -451,10 +451,10 @@
raise
def __repr__(self):
- if self._obj.ref_list == NULL:
+ if self._obj.children == NULL:
refs = ''
else:
- refs = ' %drefs' % (self._obj.ref_list.size,)
+ refs = ' %drefs' % (self._obj.children.size,)
if self._obj.parent_list == NULL:
parent_str = ''
else:
@@ -485,7 +485,7 @@
def to_json(self):
"""Convert this back into json."""
refs = []
- for ref in sorted(self.ref_list):
+ for ref in sorted(self.children):
refs.append(str(ref))
# Note: We've lost the info about whether this was a value or a name
# We've also lost the 'length' field.
@@ -508,13 +508,13 @@
tries to expand that as much as possible.
"""
as_dict = {}
- ref_list = self.ref_list
+ children = self.children
if self.type_str not in ('dict', 'module'):
# Instance dicts end with a 'type' reference
- ref_list = ref_list[:-1]
- for idx in xrange(0, len(ref_list), 2):
- key = self.collection[ref_list[idx]]
- val = self.collection[ref_list[idx+1]]
+ children = children[:-1]
+ for idx in xrange(0, len(children), 2):
+ key = self.collection[children[idx]]
+ val = self.collection[children[idx+1]]
if key.value is not None:
key = key.value
# TODO: We should consider recursing if val is a 'known' type, such
@@ -738,7 +738,7 @@
return new_size
- def add(self, address, type_str, size, ref_list=(), length=0,
+ def add(self, address, type_str, size, children=(), length=0,
value=None, name=None, parent_list=(), total_size=0):
"""Add a new MemObject to this collection."""
cdef _MemObject **slot, *new_entry
@@ -751,7 +751,7 @@
assert False, "We don't support overwrite yet."
# TODO: These are fairy small and more subject to churn, maybe we
# should be using PyObj_Malloc instead...
- new_entry = _new_mem_object(address, type_str, size, ref_list,
+ new_entry = _new_mem_object(address, type_str, size, children,
value, name, parent_list, total_size)
if slot[0] == NULL:
=== modified file 'meliae/loader.py'
--- a/meliae/loader.py 2009-12-30 16:30:00 +0000
+++ b/meliae/loader.py 2010-01-08 22:20:26 +0000
@@ -1,4 +1,4 @@
-# Copyright (C) 2009 Canonical Ltd
+# Copyright (C) 2009, 2010 Canonical Ltd
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 3 as
@@ -65,7 +65,7 @@
obj = cls(address=val['address'],
type_str=str(val['type']),
size=val['size'],
- ref_list=val['refs'],
+ children=val['refs'],
length=val.get('len', None),
value=val.get('value', None),
name=val.get('name', None))
@@ -93,7 +93,7 @@
obj = cls(address=int(address),
type_str=type_str,
size=int(size),
- ref_list=refs,
+ children=refs,
length=length,
value=value,
name=name)
@@ -204,10 +204,10 @@
def __getitem__(self, address):
return self.objs[address]
- def compute_referrers(self):
+ def compute_parents(self):
"""For each object, figure out who is referencing it."""
- referrers = {}
- get_refs = referrers.get
+ parents = {}
+ get_refs = parents.get
total = len(self.objs)
tlast = timer()-20
enabled = gc.isenabled()
@@ -221,13 +221,13 @@
tnow = timer()
if tnow - tlast > 0.1:
tlast = tnow
- sys.stderr.write('compute referrers %8d / %8d \r'
+ sys.stderr.write('compute parents %8d / %8d \r'
% (idx, total))
address = obj.address
- for ref in obj.ref_list:
+ for ref in obj.children:
refs = get_refs(ref, None)
# This is ugly, so it should be explained.
- # To save memory pressure, referrers will point to one of 4
+ # To save memory pressure, parents will point to one of 4
# types.
# 1) A simple integer, representing a single referrer
# this saves the allocation of a separate structure
@@ -235,7 +235,7 @@
# 2) A tuple, slightly more efficient than a list, but
# requires creating a new tuple to 'add' an entry.
# 3) A list, as before, for things with lots of
- # referrers, we use a regular list to let it grow.
+ # parents, we use a regular list to let it grow.
# 4) None, no references from this object
t = type(refs)
if refs is None:
@@ -252,33 +252,33 @@
refs.append(address)
else:
raise TypeError('unknown refs type: %s\n' % (t,))
- referrers[ref] = refs
+ parents[ref] = refs
if self.show_progress:
- sys.stderr.write('compute referrers %8d / %8d \r'
+ sys.stderr.write('compute parents %8d / %8d \r'
% (idx, total))
for idx, obj in enumerate(self.objs.itervalues()):
if self.show_progress and idx & 0x3f == 0:
tnow = timer()
if tnow - tlast > 0.1:
tlast = tnow
- sys.stderr.write('set referrers %8d / %8d \r'
+ sys.stderr.write('set parents %8d / %8d \r'
% (idx, total))
try:
- refs = referrers.pop(obj.address)
+ refs = parents.pop(obj.address)
except KeyError:
- obj.referrers = ()
+ obj.parents = ()
else:
if refs is None:
- obj.referrers = ()
+ obj.parents = ()
elif type(refs) in (int, long):
- obj.referrers = (refs,)
+ obj.parents = (refs,)
else:
- obj.referrers = refs
+ obj.parents = refs
finally:
if enabled:
gc.enable()
if self.show_progress:
- sys.stderr.write('set referrers %8d / %8d \n'
+ sys.stderr.write('set parents %8d / %8d \n'
% (idx, total))
def remove_expensive_references(self):
@@ -302,7 +302,7 @@
continue
def _compute_total_size(self, obj):
- pending_descendents = list(obj.ref_list)
+ pending_descendents = list(obj.children)
seen = _intset.IDSet()
seen.add(obj.address)
total_size = obj.size
@@ -318,7 +318,7 @@
# everything. So for now, when we encounter them, don't add
# their references
total_size += next_obj.size
- pending_descendents.extend([ref for ref in next_obj.ref_list
+ pending_descendents.extend([ref for ref in next_obj.children
if ref not in seen])
## count = len(seen)
## # This single object references more than 10% of all objects, and
@@ -363,7 +363,7 @@
def get_all(self, type_str):
"""Return all objects that match a given type."""
all = [o for o in self.objs.itervalues() if o.type_str == type_str]
- all.sort(key=lambda x:(x.size, len(x), x.num_referrers),
+ all.sort(key=lambda x:(x.size, len(x), x.num_parents),
reverse=True)
return all
@@ -377,11 +377,6 @@
So we collapse those references back into the object, and grow its
'size' at the same time.
-
- :param update_referrers: When removing the instance's __dict__
- variable, update all references. If there are lots of things to
- update, it is often faster to collapse everything, and then update
- after-the-fact.
"""
# The instances I'm focusing on have a custom type name, and every
# instance has 2 pointers. The first is to __dict__, and the second is
@@ -427,14 +422,14 @@
else:
continue
extra_refs = [type_obj.address]
- if (dict_obj.num_referrers != 1
- or dict_obj.referrers[0] != address):
+ if (dict_obj.num_parents != 1
+ or dict_obj.parents[0] != address):
continue
collapsed += 1
# We found an instance \o/
- new_refs = list(dict_obj.ref_list)
+ new_refs = list(dict_obj.children)
new_refs.extend(extra_refs)
- obj.ref_list = new_refs
+ obj.children = new_refs
obj.size = obj.size + dict_obj.size
obj.total_size = 0
if obj.type_str == 'instance':
@@ -446,7 +441,7 @@
sys.stderr.write('checked %8d / %8d collapsed %8d \n'
% (item_idx, total, collapsed))
if collapsed:
- self.compute_referrers()
+ self.compute_parents()
def refs_as_dict(self, obj):
"""Expand the ref list considering it to be a 'dict' structure.
@@ -462,8 +457,8 @@
def refs_as_list(self, obj):
"""Expand the ref list, considering it to be a list structure."""
as_list = []
- ref_list = obj.ref_list
- for addr in ref_list:
+ children = obj.children
+ for addr in children:
val = self.objs[addr]
if val.type_str == 'bool':
val = (val.value == 'True')
@@ -646,27 +641,27 @@
# func_code, func_globals, func_module, func_defaults,
# func_doc, func_name, func_dict, func_closure
# We want to remove the reference to globals and module
- refs = list(obj.ref_list)
- obj.ref_list = refs[:1] + refs[3:] + [0]
+ refs = list(obj.children)
+ obj.children = refs[:1] + refs[3:] + [0]
yield (True, obj)
continue
elif obj.type_str == '_LRUNode':
# We remove the 'sideways' references
- obj.ref_list = [ref for ref in obj.ref_list
+ obj.children = [ref for ref in obj.children
if ref not in lru_objs]
yield (True, obj)
continue
- for ref in obj.ref_list:
+ for ref in obj.children:
if ref in noref_objs:
break
else:
# No bad references, keep going
yield (False, obj)
continue
- new_ref_list = [ref for ref in obj.ref_list
+ new_ref_list = [ref for ref in obj.children
if ref not in noref_objs]
new_ref_list.append(0)
- obj.ref_list = new_ref_list
+ obj.children = new_ref_list
yield (True, obj)
if show_progress:
sys.stderr.write('removed %d expensive refs from %d objs%s\n'
=== modified file 'meliae/tests/test__loader.py'
--- a/meliae/tests/test__loader.py 2009-12-29 22:16:42 +0000
+++ b/meliae/tests/test__loader.py 2010-01-08 22:20:26 +0000
@@ -1,4 +1,4 @@
-# Copyright (C) 2009 Canonical Ltd
+# Copyright (C) 2009, 2010 Canonical Ltd
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 3 as
@@ -245,7 +245,6 @@
mop = self.moc.add(addr, 'my ' + ' type', 256)
mop._intern_from_cache(cache)
self.assertTrue(addr in cache)
- # TODO: ref_list and referrers
self.assertTrue(mop.address is addr)
self.assertTrue(cache[addr] is addr)
t = cache['my type']
@@ -256,38 +255,38 @@
cache[addr876543] = addr876543
addr654321 = 654321
cache[addr654321] = addr654321
- mop.ref_list = [876542+1, 654320+1]
- mop.referrers = [876542+1, 654320+1]
+ mop.children = [876542+1, 654320+1]
+ mop.parents = [876542+1, 654320+1]
self.assertFalse(mop.address is addr)
self.assertFalse(mop.type_str is t)
- rl = mop.ref_list
+ rl = mop.children
self.assertFalse(rl[0] is addr876543)
self.assertFalse(rl[1] is addr654321)
- rfrs = mop.referrers
+ rfrs = mop.parents
self.assertFalse(rl[0] is addr876543)
self.assertFalse(rl[1] is addr654321)
mop._intern_from_cache(cache)
self.assertTrue(mop.address is addr)
self.assertTrue(mop.type_str is t)
- rl = mop.ref_list
+ rl = mop.children
self.assertTrue(rl[0] is addr876543)
self.assertTrue(rl[1] is addr654321)
- rfrs = mop.referrers
+ rfrs = mop.parents
self.assertTrue(rfrs[0] is addr876543)
self.assertTrue(rfrs[1] is addr654321)
- def test_ref_list(self):
- mop = self.moc.add(1234567, 'type', 256, ref_list=[1, 2, 3])
+ def test_children(self):
+ mop = self.moc.add(1234567, 'type', 256, children=[1, 2, 3])
self.assertEqual(3, len(mop))
self.assertEqual(3, mop.num_refs)
- self.assertEqual([1, 2, 3], mop.ref_list)
- mop.ref_list = [87654321, 23456]
- self.assertEqual([87654321, 23456], mop.ref_list)
+ self.assertEqual([1, 2, 3], mop.children)
+ mop.children = [87654321, 23456]
+ self.assertEqual([87654321, 23456], mop.children)
self.assertEqual(2, len(mop))
self.assertEqual(2, mop.num_refs)
def test__getitem__(self):
- mop = self.moc.add(1234567, 'type', 256, ref_list=[0, 255])
+ mop = self.moc.add(1234567, 'type', 256, children=[0, 255])
self.assertEqual(2, len(mop))
self.assertEqual(2, len(list(mop)))
mop0 = mop[0]
@@ -307,7 +306,7 @@
self.assertEqual(2**31+1, mop.total_size)
def test_parents(self):
- mop = self.moc.add(1234567, 'type', 256, ref_list=[0, 255])
+ mop = self.moc.add(1234567, 'type', 256, children=[0, 255])
mop0 = self.moc[0]
self.assertEqual((), mop0.parents)
self.assertEqual(0, mop0.num_parents)
@@ -321,20 +320,20 @@
self.assertEqual(1, mop255.num_parents)
self.assertEqual([1234567], mop255.parents)
- def test_referrers(self):
- mop = self.moc.add(1234567, 'type', 256, ref_list=[0, 255])
+ def test_parents(self):
+ mop = self.moc.add(1234567, 'type', 256, children=[0, 255])
mop0 = self.moc[0]
- self.assertEqual((), mop0.referrers)
- self.assertEqual(0, mop0.num_referrers)
+ self.assertEqual((), mop0.parents)
+ self.assertEqual(0, mop0.num_parents)
mop255 = self.moc[255]
- self.assertEqual((), mop255.referrers)
- self.assertEqual(0, mop255.num_referrers)
- mop0.referrers = [1234567]
- self.assertEqual(1, mop0.num_referrers)
- self.assertEqual([1234567], mop0.referrers)
- mop255.referrers = [1234567]
- self.assertEqual(1, mop255.num_referrers)
- self.assertEqual([1234567], mop255.referrers)
+ self.assertEqual((), mop255.parents)
+ self.assertEqual(0, mop255.num_parents)
+ mop0.parents = [1234567]
+ self.assertEqual(1, mop0.num_parents)
+ self.assertEqual([1234567], mop0.parents)
+ mop255.parents = [1234567]
+ self.assertEqual(1, mop255.num_parents)
+ self.assertEqual([1234567], mop255.parents)
def test__repr__(self):
mop = self.moc.add(1234, 'str', 24)
@@ -366,11 +365,11 @@
def test_expand_refs_as_dict(self):
self.moc.add(1, 'str', 25, value='a')
self.moc.add(2, 'int', 12, value=1)
- mop = self.moc.add(3, 'dict', 140, ref_list=[1, 2])
+ mop = self.moc.add(3, 'dict', 140, children=[1, 2])
as_dict = mop.refs_as_dict()
self.assertEqual({'a': 1}, mop.refs_as_dict())
# It should even work if there is a 'trailing' entry, as after
# collapse, instances have the dict inline, and end with the reference
# to the type
- mop = self.moc.add(4, 'MyClass', 156, ref_list=[2, 1, 8])
+ mop = self.moc.add(4, 'MyClass', 156, children=[2, 1, 8])
self.assertEqual({1: 'a'}, mop.refs_as_dict())
=== modified file 'meliae/tests/test_loader.py'
--- a/meliae/tests/test_loader.py 2010-01-03 21:04:49 +0000
+++ b/meliae/tests/test_loader.py 2010-01-08 22:20:26 +0000
@@ -1,4 +1,4 @@
-# Copyright (C) 2009 Canonical Ltd
+# Copyright (C) 2009, 2010 Canonical Ltd
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 3 as
@@ -169,12 +169,12 @@
', "refs": []}')
source = lambda:loader.iter_objs(lines)
mymod_dict = list(source())[8]
- self.assertEqual([10, 11], mymod_dict.ref_list)
+ self.assertEqual([10, 11], mymod_dict.children)
result = list(loader.remove_expensive_references(source))
null_obj = result[0][1]
self.assertEqual(0, null_obj.address)
self.assertEqual('<ex-reference>', null_obj.type_str)
- self.assertEqual([11, 0], result[9][1].ref_list)
+ self.assertEqual([11, 0], result[9][1].children)
class TestMemObj(tests.TestCase):
@@ -198,18 +198,18 @@
class TestObjManager(tests.TestCase):
- def test_compute_referrers(self):
+ def test_compute_parents(self):
manager = loader.load(_example_dump, show_prog=False)
- manager.compute_referrers()
+ manager.compute_parents()
objs = manager.objs
- self.assertEqual((), objs[1].referrers)
- self.assertEqual([1, 8], objs[2].referrers)
- self.assertEqual([1, 3], objs[3].referrers)
- self.assertEqual([2, 3, 7], objs[4].referrers)
- self.assertEqual([2, 3, 7], objs[5].referrers)
- self.assertEqual([2], objs[6].referrers)
- self.assertEqual([2], objs[7].referrers)
- self.assertEqual((), objs[8].referrers)
+ self.assertEqual((), objs[1].parents)
+ self.assertEqual([1, 8], objs[2].parents)
+ self.assertEqual([1, 3], objs[3].parents)
+ self.assertEqual([2, 3, 7], objs[4].parents)
+ self.assertEqual([2, 3, 7], objs[5].parents)
+ self.assertEqual([2], objs[6].parents)
+ self.assertEqual([2], objs[7].parents)
+ self.assertEqual((), objs[8].parents)
def test_compute_total_size(self):
manager = loader.load(_example_dump, show_prog=False)
@@ -248,13 +248,13 @@
', "refs": []}')
manager = loader.load(lines, show_prog=False)
mymod_dict = manager.objs[9]
- self.assertEqual([10, 11], mymod_dict.ref_list)
+ self.assertEqual([10, 11], mymod_dict.children)
manager.remove_expensive_references()
self.assertTrue(0 in manager.objs)
null_obj = manager.objs[0]
self.assertEqual(0, null_obj.address)
self.assertEqual('<ex-reference>', null_obj.type_str)
- self.assertEqual([11, 0], mymod_dict.ref_list)
+ self.assertEqual([11, 0], mymod_dict.children)
def test_collapse_instance_dicts(self):
manager = loader.load(_instance_dump, show_prog=False)
@@ -262,26 +262,26 @@
# @2 into the instance @1
instance = manager.objs[1]
self.assertEqual(32, instance.size)
- self.assertEqual([2, 3], instance.ref_list)
+ self.assertEqual([2, 3], instance.children)
inst_dict = manager.objs[2]
self.assertEqual(140, inst_dict.size)
- self.assertEqual([4, 5, 6, 7, 9, 10, 11, 12], inst_dict.ref_list)
+ self.assertEqual([4, 5, 6, 7, 9, 10, 11, 12], inst_dict.children)
mod = manager.objs[14]
- self.assertEqual([15], mod.ref_list)
+ self.assertEqual([15], mod.children)
mod_dict = manager.objs[15]
- self.assertEqual([5, 6, 9, 6], mod_dict.ref_list)
- manager.compute_referrers()
+ self.assertEqual([5, 6, 9, 6], mod_dict.children)
+ manager.compute_parents()
tpl = manager.objs[12]
- self.assertEqual([2], tpl.referrers)
- self.assertEqual([1], inst_dict.referrers)
- self.assertEqual([14], mod_dict.referrers)
+ self.assertEqual([2], tpl.parents)
+ self.assertEqual([1], inst_dict.parents)
+ self.assertEqual([14], mod_dict.parents)
manager.collapse_instance_dicts()
# The instance dict has been removed
- self.assertEqual([4, 5, 6, 7, 9, 10, 11, 12, 3], instance.ref_list)
+ self.assertEqual([4, 5, 6, 7, 9, 10, 11, 12, 3], instance.children)
self.assertEqual(172, instance.size)
self.assertFalse(2 in manager.objs)
- self.assertEqual([1], tpl.referrers)
- self.assertEqual([5, 6, 9, 6], mod.ref_list)
+ self.assertEqual([1], tpl.parents)
+ self.assertEqual([5, 6, 9, 6], mod.children)
self.assertFalse(15 in manager.objs)
def test_collapse_old_instance_dicts(self):
@@ -289,18 +289,18 @@
instance = manager.objs[1]
self.assertEqual('instance', instance.type_str)
self.assertEqual(36, instance.size)
- self.assertEqual([2, 3], instance.ref_list)
+ self.assertEqual([2, 3], instance.children)
inst_dict = manager[3]
self.assertEqual(140, inst_dict.size)
- self.assertEqual([4, 5, 6, 7], inst_dict.ref_list)
- manager.compute_referrers()
+ self.assertEqual([4, 5, 6, 7], inst_dict.children)
+ manager.compute_parents()
manager.collapse_instance_dicts()
# The instance dict has been removed, and its references moved into the
# instance, further, the type has been updated from generic 'instance'
# to being 'OldStyle'.
self.assertFalse(3 in manager.objs)
self.assertEqual(176, instance.size)
- self.assertEqual([4, 5, 6, 7, 2], instance.ref_list)
+ self.assertEqual([4, 5, 6, 7, 2], instance.children)
self.assertEqual('OldStyle', instance.type_str)
def test_expand_refs_as_dict(self):
@@ -310,7 +310,7 @@
manager = loader.load(_instance_dump, show_prog=False)
as_dict = manager.refs_as_dict(manager[15])
self.assertEqual({1: 'c', 'b': 'c'}, as_dict)
- manager.compute_referrers()
+ manager.compute_parents()
manager.collapse_instance_dicts()
self.assertEqual({1: 'c', 'b': 'c'}, manager.refs_as_dict(manager[14]))
self.assertEqual({'a': 1, 'c': manager[7], 'b': 'string',
More information about the bazaar-commits
mailing list