SYMBOL INDEX (390 symbols across 15 files)

FILE: heap/__init__.py
  function fmt_addr (line 33) | def fmt_addr(addr):
  function fmt_addr (line 37) | def fmt_addr(addr):
  class WrongInferiorProcess (line 45) | class WrongInferiorProcess(RuntimeError):
    method __init__ (line 46) | def __init__(self, hint):
  function caching_lookup_type (line 53) | def caching_lookup_type(typename):
  function array_length (line 73) | def array_length(_gdbval):
  function offsetof (line 80) | def offsetof(typename, fieldname):
  class MissingDebuginfo (line 93) | class MissingDebuginfo(RuntimeError):
    method __init__ (line 94) | def __init__(self, module):
  function check_missing_debuginfo (line 97) | def check_missing_debuginfo(err, module):
  class WrappedValue (line 104) | class WrappedValue(object):
    method __init__ (line 109) | def __init__(self, gdbval):
    method field (line 116) | def field(self, attr):
    method __str__ (line 119) | def __str__(self):
    method address (line 124) | def address(self):
    method is_optimized_out (line 128) | def is_optimized_out(self):
    method type (line 132) | def type(self):
    method dynamic_type (line 136) | def dynamic_type(self):
    method is_lazy (line 140) | def is_lazy(self):
    method dereference (line 143) | def dereference(self):
    method is_null (line 149) | def is_null(self):
  class WrappedPointer (line 152) | class WrappedPointer(WrappedValue):
    method as_address (line 153) | def as_address(self):
    method __str__ (line 156) | def __str__(self):
    method cast (line 163) | def cast(self, type_):
    method categorize_refs (line 166) | def categorize_refs(self, usage_set, level=0, detail=None):
  function fmt_size (line 172) | def fmt_size(size):
  function as_hexdump_char (line 185) | def as_hexdump_char(b):
  function sign (line 193) | def sign(amt):
  class Category (line 200) | class Category(namedtuple('Category', ('domain', 'kind', 'detail'))):
    method __new__ (line 218) | def __new__(_cls, domain, kind, detail=None):
    method __str__ (line 221) | def __str__(self):
  class Usage (line 224) | class Usage(object):
    method __init__ (line 228) | def __init__(self, start, size, category=None, level=None, hd=None, ob...
    method __repr__ (line 240) | def __repr__(self):
    method ensure_category (line 250) | def ensure_category(self, usage_set=None):
    method ensure_hexdump (line 254) | def ensure_hexdump(self):
  function hexdump_as_bytes (line 259) | def hexdump_as_bytes(addr, size, chars_only=True):
  function hexdump_as_int (line 275) | def hexdump_as_int(addr, count):
  class Table (line 292) | class Table(object):
    method __init__ (line 294) | def __init__(self, columnheadings=None, rows=[]):
    method add_row (line 300) | def add_row(self, row):
    method write (line 304) | def write(self, out):
    method _calc_col_widths (line 314) | def _calc_col_widths(self):
    method _calc_col_width (line 320) | def _calc_col_width(self, idx):
    method _write_row (line 325) | def _write_row(self, out, colwidths, values):
    method _write_separator (line 333) | def _write_separator(self, out, colwidths):
  class UsageSet (line 340) | class UsageSet(object):
    method __init__ (line 341) | def __init__(self, usage_list):
    method set_addr_category (line 347) | def set_addr_category(self, addr, category, level=0, visited=None, deb...
  class PythonCategorizer (line 376) | class PythonCategorizer(object):
    method __init__ (line 381) | def __init__(self):
    method make (line 392) | def make(cls):
    method categorize (line 399) | def categorize(self, u, usage_set):
  function _get_register_state (line 476) | def _get_register_state():
  function lazily_get_usage_list (line 483) | def lazily_get_usage_list():
  function categorize_usage_list (line 511) | def categorize_usage_list(usage_list):
  function categorize (line 540) | def categorize(u, usage_set):
  function as_nul_terminated_string (line 588) | def as_nul_terminated_string(addr, size):
  class ProgressNotifier (line 598) | class ProgressNotifier(object):
    method __init__ (line 600) | def __init__(self, inner, msg):
    method __iter__ (line 605) | def __iter__(self):
    method __next__ (line 608) | def __next__(self):
  function iter_usage_with_progress (line 616) | def iter_usage_with_progress():
  class CachedInferiorState (line 620) | class CachedInferiorState(object):
    method __init__ (line 624) | def __init__(self):
    method add_arena_detector (line 627) | def add_arena_detector(self, detector):
    method detect_arena (line 630) | def detect_arena(self, ptr, chunksize):
  function iter_usage (line 643) | def iter_usage():
  function looks_like_ptr (line 689) | def looks_like_ptr(value):

FILE: heap/commands.py
  function need_debuginfo (line 31) | def need_debuginfo(f):
  class Heap (line 41) | class Heap(gdb.Command):
    method __init__ (line 43) | def __init__(self):
    method invoke (line 50) | def invoke(self, args, from_tty):
  class HeapSizes (line 91) | class HeapSizes(gdb.Command):
    method __init__ (line 93) | def __init__(self):
    method invoke (line 98) | def invoke(self, args, from_tty):
  class HeapUsed (line 128) | class HeapUsed(gdb.Command):
    method __init__ (line 130) | def __init__(self):
    method invoke (line 136) | def invoke(self, args, from_tty):
  class HeapFree (line 155) | class HeapFree(gdb.Command):
    method __init__ (line 157) | def __init__(self):
    method invoke (line 163) | def invoke(self, args, from_tty):
  class HeapAll (line 186) | class HeapAll(gdb.Command):
    method __init__ (line 188) | def __init__(self):
    method invoke (line 194) | def invoke(self, args, from_tty):
  class HeapLog (line 212) | class HeapLog(gdb.Command):
    method __init__ (line 214) | def __init__(self):
    method invoke (line 220) | def invoke(self, args, from_tty):
  class HeapLabel (line 236) | class HeapLabel(gdb.Command):
    method __init__ (line 238) | def __init__(self):
    method invoke (line 244) | def invoke(self, args, from_tty):
  class HeapDiff (line 249) | class HeapDiff(gdb.Command):
    method __init__ (line 251) | def __init__(self):
    method invoke (line 257) | def invoke(self, args, from_tty):
  class HeapSelect (line 270) | class HeapSelect(gdb.Command):
    method __init__ (line 272) | def __init__(self):
    method invoke (line 278) | def invoke(self, args, from_tty):
  class Hexdump (line 286) | class Hexdump(gdb.Command):
    method __init__ (line 288) | def __init__(self):
    method invoke (line 293) | def invoke(self, args, from_tty):
  class HeapArenas (line 317) | class HeapArenas(gdb.Command):
    method __init__ (line 319) | def __init__(self):
    method invoke (line 325) | def invoke(self, args, from_tty):
  class HeapArenaSelect (line 329) | class HeapArenaSelect(gdb.Command):
    method __init__ (line 331) | def __init__(self):
    method invoke (line 337) | def invoke(self, args, from_tty):
  function register_commands (line 345) | def register_commands():

FILE: heap/compat.py
  function execute (line 34) | def execute(command):
  function dump (line 57) | def dump():

FILE: heap/cplusplus.py
  function get_class_name (line 27) | def get_class_name(addr, size):
  function as_cplusplus_object (line 42) | def as_cplusplus_object(addr, size):

FILE: heap/cpython.py
  function INDEX2SIZE (line 19) | def INDEX2SIZE(I):
  function ROUNDUP (line 27) | def ROUNDUP(x):
  function POOL_OVERHEAD (line 30) | def POOL_OVERHEAD():
  class PyArenaPtr (line 33) | class PyArenaPtr(WrappedPointer):
    method from_addr (line 37) | def from_addr(cls, p, arenaobj):
    method __init__ (line 42) | def __init__(self, gdbval, arenaobj):
    method __str__ (line 57) | def __str__(self):
    method iter_pools (line 70) | def iter_pools(self):
    method iter_usage (line 86) | def iter_usage(self):
  class PyPoolPtr (line 104) | class PyPoolPtr(WrappedPointer):
    method from_addr (line 108) | def from_addr(cls, p):
    method __str__ (line 113) | def __str__(self):
    method gdb_type (line 119) | def gdb_type(cls):
    method block_size (line 123) | def block_size(self):
    method num_blocks (line 126) | def num_blocks(self):
    method _firstoffset (line 132) | def _firstoffset(self):
    method _maxnextoffset (line 135) | def _maxnextoffset(self):
    method iter_blocks (line 138) | def iter_blocks(self):
    method iter_usage (line 149) | def iter_usage(self):
    method iter_free_blocks (line 165) | def iter_free_blocks(self):
    method _free_blocks (line 178) | def _free_blocks(self):
    method iter_used_blocks (line 182) | def iter_used_blocks(self):
  class PyObjectPtr (line 215) | class PyObjectPtr(WrappedPointer):
    method from_pyobject_ptr (line 217) | def from_pyobject_ptr(cls, addr):
    method type (line 236) | def type(self):
    method safe_tp_name (line 239) | def safe_tp_name(self):
    method categorize (line 246) | def categorize(self):
    method as_malloc_addr (line 251) | def as_malloc_addr(self):
  function _PyObject_VAR_SIZE (line 262) | def _PyObject_VAR_SIZE(typeobj, nitems):
  function int_from_int (line 269) | def int_from_int(gdbval):
  class PyUnicodeObjectPtr (line 272) | class PyUnicodeObjectPtr(PyObjectPtr):
    method categorize_refs (line 279) | def categorize_refs(self, usage_set, level=0, detail=None):
  class PyDictObjectPtr (line 286) | class PyDictObjectPtr(PyObjectPtr):
    method categorize_refs (line 293) | def categorize_refs(self, usage_set, level=0, detail=None):
  class PyInstanceObjectPtr (line 300) | class PyInstanceObjectPtr(PyObjectPtr):
    method cl_name (line 303) | def cl_name(self):
    method categorize (line 310) | def categorize(self):
    method categorize_refs (line 313) | def categorize_refs(self, usage_set, level=0, detail=None):
  class PyTypeObjectPtr (line 340) | class PyTypeObjectPtr(PyObjectPtr):
  class HeapTypeObjectPtr (line 343) | class HeapTypeObjectPtr(PyObjectPtr):
    method categorize_refs (line 346) | def categorize_refs(self, usage_set, level=0, detail=None):
    method get_attr_dict (line 360) | def get_attr_dict(self):
  function is_pyobject_ptr (line 393) | def is_pyobject_ptr(addr):
  function obj_addr_to_gc_addr (line 426) | def obj_addr_to_gc_addr(addr):
  function as_python_object (line 433) | def as_python_object(addr):
  class ArenaObject (line 467) | class ArenaObject(WrappedPointer):
    method iter_arenas (line 474) | def iter_arenas(cls):
    method address (line 496) | def address(self):
    method __init__ (line 499) | def __init__(self, gdbval):
  class ArenaDetection (line 508) | class ArenaDetection(object):
    method __init__ (line 510) | def __init__(self):
    method as_arena (line 513) | def as_arena(self, ptr, chunksize):
  function python_categorization (line 529) | def python_categorization(usage_set):
  class HeapCPythonAllocators (line 591) | class HeapCPythonAllocators(gdb.Command):
    method __init__ (line 593) | def __init__(self):
    method invoke (line 599) | def invoke(self, args, from_tty):
  function register_commands (line 612) | def register_commands():

FILE: heap/glibc.py
  class MChunkPtr (line 33) | class MChunkPtr(WrappedPointer):
    method gdb_type (line 65) | def gdb_type(cls):
    method size (line 69) | def size(self):
    method chunksize (line 74) | def chunksize(self):
    method has_flag (line 77) | def has_flag(self, flag):
    method has_PREV_INUSE (line 80) | def has_PREV_INUSE(self):
    method has_IS_MMAPPED (line 83) | def has_IS_MMAPPED(self):
    method has_NON_MAIN_ARENA (line 86) | def has_NON_MAIN_ARENA(self):
    method __str__ (line 89) | def __str__(self):
    method as_mem (line 112) | def as_mem(self):
    method is_inuse (line 117) | def is_inuse(self):
    method next_chunk (line 126) | def next_chunk(self):
    method prev_chunk (line 136) | def prev_chunk(self):
  class MBinPtr (line 144) | class MBinPtr(MChunkPtr):
    method gdb_type (line 148) | def gdb_type(cls):
    method first (line 152) | def first(self):
    method last (line 155) | def last(self):
  class MFastBinPtr (line 158) | class MFastBinPtr(MChunkPtr):
  class MallocState (line 162) | class MallocState(WrappedValue):
    method fastbin (line 165) | def fastbin(self, idx):
    method bin_at (line 168) | def bin_at(self, i):
    method iter_chunks (line 185) | def iter_chunks(self):
    method iter_mmap_chunks (line 195) | def iter_mmap_chunks(self):
    method iter_sbrk_chunks (line 215) | def iter_sbrk_chunks(self):
    method iter_free_chunks (line 252) | def iter_free_chunks(self):
    method NFASTBINS (line 299) | def NFASTBINS(self):
  class MallocPar (line 303) | class MallocPar(WrappedValue):
    method get (line 306) | def get(cls):
  function sbrk_base (line 311) | def sbrk_base():
  function iter_mmap_heap_chunks (line 381) | def iter_mmap_heap_chunks(pid):
  class GlibcArenas (line 413) | class GlibcArenas(object):
    method __init__ (line 414) | def __init__(self):
    method get_main_arena (line 419) | def get_main_arena(self):
    method get_ms (line 422) | def get_ms(self, arena_dereference=None):
    method get_arenas (line 430) | def get_arenas(self):

FILE: heap/gobject.py
  function get_typenode_for_gtype (line 32) | def get_typenode_for_gtype(gtype):
  function is_typename_castable (line 52) | def is_typename_castable(typename):
  class GTypeInstancePtr (line 65) | class GTypeInstancePtr(WrappedPointer):
    method from_gtypeinstance_ptr (line 67) | def from_gtypeinstance_ptr(cls, addr, typenode):
    method get_class_for_typename (line 74) | def get_class_for_typename(cls, typename):
    method __init__ (line 80) | def __init__(self, addr, typenode, typename):
    method categorize (line 111) | def categorize(self):
    method get_type_name (line 115) | def get_type_name(cls, typenode):
  class GdkColormapPtr (line 119) | class GdkColormapPtr(GTypeInstancePtr):
    method categorize_refs (line 120) | def categorize_refs(self, usage_set, level=0, detail=None):
  class GdkImagePtr (line 125) | class GdkImagePtr(GTypeInstancePtr):
    method categorize_refs (line 126) | def categorize_refs(self, usage_set, level=0, detail=None):
  class GdkPixbufPtr (line 146) | class GdkPixbufPtr(GTypeInstancePtr):
    method categorize_refs (line 147) | def categorize_refs(self, usage_set, level=0, detail=None):
  class PangoCairoFcFontMapPtr (line 154) | class PangoCairoFcFontMapPtr(GTypeInstancePtr):
    method categorize_refs (line 155) | def categorize_refs(self, usage_set, level=0, detail=None):
  function as_gtype_instance (line 182) | def as_gtype_instance(addr, size):

FILE: heap/history.py
  class Snapshot (line 20) | class Snapshot(object):
    method __init__ (line 22) | def __init__(self, name, time):
    method _add_usage (line 29) | def _add_usage(self, u):
    method current (line 36) | def current(cls, name):
    method total_size (line 44) | def total_size(self):
    method summary (line 48) | def summary(self):
    method size_by_address (line 52) | def size_by_address(self, address):
  class History (line 55) | class History(object):
    method __init__ (line 57) | def __init__(self):
    method add (line 60) | def add(self, name):
  class Diff (line 65) | class Diff(object):
    method __init__ (line 67) | def __init__(self, old, new):
    method stats (line 74) | def stats(self):
    method as_changes (line 82) | def as_changes(self):
    method chunk_report (line 88) | def chunk_report(self, title, snapshot, set_of_usage):

FILE: heap/parser.py
  function t_ID (line 39) | def t_ID(t):
  function t_COMPARISON (line 48) | def t_COMPARISON(t):
  function t_LITERAL_NUMBER (line 52) | def t_LITERAL_NUMBER(t):
  function t_LITERAL_STRING (line 63) | def t_LITERAL_STRING(t):
  function t_newline (line 72) | def t_newline(t):
  function t_error (line 76) | def t_error(t):
  function p_expression_number (line 99) | def p_expression_number(t):
  function p_expression_string (line 103) | def p_expression_string(t):
  function p_comparison (line 107) | def p_comparison(t):
  function p_and (line 120) | def p_and(t):
  function p_or (line 124) | def p_or(t):
  function p_not (line 128) | def p_not(t):
  function p_expression_group (line 132) | def p_expression_group(t):
  function p_expression_name (line 136) | def p_expression_name(t):
  class ParserError (line 146) | class ParserError(Exception):
    method from_production (line 148) | def from_production(cls, p, val, msg):
    method from_token (line 155) | def from_token(cls, t, msg="Parse error"):
    method __init__ (line 161) | def __init__(self, input_, pos, value, msg):
    method __str__ (line 167) | def __str__(self):
  function p_error (line 173) | def p_error(t):
  function parse_query (line 182) | def parse_query(s):
  function test_lexer (line 189) | def test_lexer(s):

FILE: heap/pypy.py
  function pypy_categorizer (line 6) | def pypy_categorizer(addr, size):
  class ArenaCollection (line 9) | class ArenaCollection(WrappedPointer):
    method get_arenas (line 13) | def get_arenas(self):
  class ArenaReference (line 27) | class ArenaReference(WrappedPointer):
    method iter_usage (line 28) | def iter_usage(self):
  class ArenaDetection (line 32) | class ArenaDetection(object):
    method __init__ (line 34) | def __init__(self):
    method as_arena (line 51) | def as_arena(self, ptr, chunksize):

FILE: heap/query.py
  class Expression (line 19) | class Expression(object):
    method eval_ (line 20) | def eval_(self, u):
    method __eq__ (line 23) | def __eq__(self, other):
  class Constant (line 27) | class Constant(Expression):
    method __init__ (line 28) | def __init__(self, value):
    method __repr__ (line 31) | def __repr__(self):
    method eval_ (line 34) | def eval_(self, u):
  class GetAttr (line 37) | class GetAttr(Expression):
    method __init__ (line 38) | def __init__(self, attrname):
    method __repr__ (line 41) | def __repr__(self):
    method eval_ (line 44) | def eval_(self, u):
  class BinaryOp (line 51) | class BinaryOp(Expression):
    method __init__ (line 52) | def __init__(self, lhs, rhs):
  class Comparison (line 56) | class Comparison(BinaryOp):
    method __init__ (line 57) | def __init__(self, lhs, rhs):
    method __repr__ (line 60) | def __repr__(self):
    method eval_ (line 63) | def eval_(self, u):
    method cmp_ (line 68) | def cmp_(self, lhs, rhs):
  class Comparison__le__ (line 71) | class Comparison__le__(Comparison):
    method cmp_ (line 72) | def cmp_(self, lhs, rhs):
  class Comparison__lt__ (line 75) | class Comparison__lt__(Comparison):
    method cmp_ (line 76) | def cmp_(self, lhs, rhs):
  class Comparison__eq__ (line 79) | class Comparison__eq__(Comparison):
    method cmp_ (line 80) | def cmp_(self, lhs, rhs):
  class Comparison__ne__ (line 83) | class Comparison__ne__(Comparison):
    method cmp_ (line 84) | def cmp_(self, lhs, rhs):
  class Comparison__ge__ (line 87) | class Comparison__ge__(Comparison):
    method cmp_ (line 88) | def cmp_(self, lhs, rhs):
  class Comparison__gt__ (line 91) | class Comparison__gt__(Comparison):
    method cmp_ (line 92) | def cmp_(self, lhs, rhs):
  class And (line 96) | class And(BinaryOp):
    method __repr__ (line 97) | def __repr__(self):
    method eval_ (line 100) | def eval_(self, u):
  class Or (line 106) | class Or(BinaryOp):
    method __repr__ (line 107) | def __repr__(self):
    method eval_ (line 110) | def eval_(self, u):
  class Not (line 116) | class Not(Expression):
    method __init__ (line 117) | def __init__(self, inner):
    method __repr__ (line 119) | def __repr__(self):
    method eval_ (line 121) | def eval_(self, u):
  class Column (line 126) | class Column(object):
    method __init__ (line 127) | def __init__(self, name, getter, formatter):
  class Query (line 133) | class Query(object):
    method __init__ (line 134) | def __init__(self, filter_):
    method __iter__ (line 137) | def __iter__(self):
  function do_query (line 154) | def do_query(args):

FILE: heap/sqlite.py
  function categorize_sqlite3 (line 21) | def categorize_sqlite3(addr, usage_set, visited):

FILE: object-sizes.py
  class OldStyle (line 32) | class OldStyle:
    method __init__ (line 33) | def __init__(self, x, y):
  class NewStyle (line 37) | class NewStyle(object):
    method __init__ (line 38) | def __init__(self, x, y):
  class NewStyleWithSlots (line 42) | class NewStyleWithSlots(object):
    method __init__ (line 44) | def __init__(self, x, y):
  class OldStyleManyAttribs (line 60) | class OldStyleManyAttribs:
    method __init__ (line 61) | def __init__(self, **kwargs):
  class NewStyleManyAttribs (line 64) | class NewStyleManyAttribs(object):
    method __init__ (line 65) | def __init__(self, **kwargs):

FILE: resultparser.py
  function indent (line 7) | def indent(str_):
  class ColumnNotFound (line 11) | class ColumnNotFound(Exception):
    method __init__ (line 12) | def __init__(self, colname, table):
    method __str__ (line 16) | def __str__(self):
  class RowNotFound (line 20) | class RowNotFound(Exception):
    method __init__ (line 21) | def __init__(self, criteria, table):
    method __str__ (line 24) | def __str__(self):
  class Criteria (line 28) | class Criteria(object):
    method __init__ (line 30) | def __init__(self, table, kvs):
    method __str__ (line 35) | def __str__(self):
    method is_matched_by (line 39) | def is_matched_by(self, row):
  class ParsedTable (line 46) | class ParsedTable(object):
    method parse_lines (line 49) | def parse_lines(cls, data):
    method __init__ (line 69) | def __init__(self, sep_index, colmetrics, lines):
    method __str__ (line 85) | def __str__(self):
    method as_rst_grid_table (line 88) | def as_rst_grid_table(self):
    method get_cell (line 117) | def get_cell(self, x, y):
    method find_col (line 120) | def find_col(self, colname):
    method find_row (line 127) | def find_row(self, kvs):
    method find_cell (line 135) | def find_cell(self, kvs, attr2name):
    method _get_cell_value (line 140) | def _get_cell_value(self, cellstr):
    method _split_cells (line 157) | def _split_cells(self, line):
    method _find_separator_line (line 166) | def _find_separator_line(cls, lines):
  class ParserTests (line 207) | class ParserTests(unittest.TestCase):
    method test_table_data (line 208) | def test_table_data(self):
    method test_multiple_tables (line 246) | def test_multiple_tables(self):
    method test_rst (line 250) | def test_rst(self):

FILE: selftest.py
  class TestSource (line 54) | class TestSource(object):
    method __init__ (line 56) | def __init__(self):
    method add_line (line 62) | def add_line(self, code):
    method add_malloc (line 65) | def add_malloc(self, size, debug=False, typename=None):
    method add_realloc (line 83) | def add_realloc(self, varname, size, debug=False):
    method add_free (line 94) | def add_free(self, varname, debug=False):
    method add_breakpoint (line 97) | def add_breakpoint(self):
    method as_c_source (line 100) | def as_c_source(self):
  class TestProgram (line 117) | class TestProgram(object):
    method __init__ (line 118) | def __init__(self, name, source, is_cplusplus=False):
  class DebuggerTests (line 151) | class DebuggerTests(unittest.TestCase):
    method run_gdb (line 155) | def run_gdb(self, *args):
    method requires_binary (line 164) | def requires_binary(self, binary):
    method command_test (line 180) | def command_test(self, progargs, commands, breakpoint=None):
    method program_test (line 210) | def program_test(self, name, source, commands, is_cplusplus=False):
    method test_no_allocations (line 214) | def test_no_allocations(self):
    method test_small_allocations (line 227) | def test_small_allocations(self):
    method test_large_allocations (line 256) | def test_large_allocations(self):
    method test_mixed_allocations (line 282) | def test_mixed_allocations(self):
    method random_size (line 339) | def random_size(self):
    method test_random_allocations (line 349) | def test_random_allocations(self):
    method test_random_buffers (line 400) | def test_random_buffers(self):
    method test_cplusplus (line 417) | def test_cplusplus(self):
    method test_history (line 460) | def test_history(self):
    method assertHasRow (line 480) | def assertHasRow(self, table, kvs):
    method assertFoundCategory (line 484) | def assertFoundCategory(self, table, domain, kind, detail=None):
    method test_assertions (line 494) | def test_assertions(self):
    method test_gobject (line 508) | def test_gobject(self):
    method test_python2 (line 551) | def test_python2(self):
    method test_python3 (line 554) | def test_python3(self):
    method _impl_test_python (line 557) | def _impl_test_python(self, pyruntime, py3k):
    method test_pypy (line 678) | def test_pypy(self):
    method test_select (line 700) | def test_select(self):
    method test_select_by_size (line 752) | def test_select_by_size(self):
    method test_select_by_category (line 798) | def test_select_by_category(self):
    method test_heap_used (line 816) | def test_heap_used(self):
    method test_heap_all (line 830) | def test_heap_all(self):
  class QueryParsingTests (line 850) | class QueryParsingTests(unittest.TestCase):
    method assertParsesTo (line 851) | def assertParsesTo(self, s, result):
    method test_simple_comparisons (line 854) | def test_simple_comparisons(self):