class TrackClassTestCase(unittest.TestCase):
def setUp(self):
self.tracker = ClassTracker()
def tearDown(self):
self.tracker.stop_periodic_snapshots()
self.tracker.clear()
def test_type_errors(self):
"""Test invalid parameters for class tracking.
"""
i = 42
j = 'Foobar'
k = [i,j]
l = {i: j}
foo = Foo()
bar = Bar()
self.assertRaises(TypeError, self.tracker.track_class, i)
self.assertRaises(TypeError, self.tracker.track_class, j)
self.assertRaises(TypeError, self.tracker.track_class, k)
self.assertRaises(TypeError, self.tracker.track_class, l)
self.assertRaises(TypeError, self.tracker.track_class, foo)
self.assertRaises(TypeError, self.tracker.track_class, bar)
self.assert_(id(i) not in self.tracker.objects)
self.assert_(id(j) not in self.tracker.objects)
self.assert_(id(k) not in self.tracker.objects)
self.assert_(id(l) not in self.tracker.objects)
def test_track_class(self):
"""Test tracking objects through classes.
"""
self.tracker.track_class(Foo)
self.tracker.track_class(Bar)
self.tracker.track_class(Empty)
self.tracker.track_class(Foo)
foo = Foo()
bar = Bar()
empty = Empty()
self.assert_(id(foo) in self.tracker.objects)
self.assert_(id(bar) in self.tracker.objects)
self.assert_(id(empty) in self.tracker.objects)
def test_track_class_new(self):
"""Test tracking new style classes.
"""
self.tracker.track_class(FooNew)
self.tracker.track_class(BarNew)
foo = FooNew()
bar = BarNew()
self.assert_(id(foo) in self.tracker.objects)
self.assert_(id(bar) in self.tracker.objects)
def test_track_by_name(self):
"""Test registering objects by name.
"""
self.tracker.track_class(Foo, name='Foobar')
foo = Foo()
self.assert_('Foobar' in self.tracker.index )
self.assertEqual(self.tracker.index['Foobar'][0].ref(),foo)
def test_keep(self):
"""Test lifetime of tracked objects.
"""
self.tracker.track_class(Foo, keep=1)
self.tracker.track_class(Bar)
foo = Foo()
bar = Bar()
idfoo = id(foo)
idbar = id(bar)
del foo
del bar
self.assert_(self.tracker.objects[idfoo].ref() is not None)
self.assert_(self.tracker.objects[idbar].ref() is None)
def test_trace(self):
"""Test instantiation tracing of tracked objects.
"""
from inspect import stack
self.tracker.track_class(Foo, trace=True)
self.tracker.track_class(BarNew, trace=True)
foo = Foo()
bar = BarNew()
idfoo = id(foo)
idbar = id(bar)
trace = []
st = stack()
try:
for fr in st:
trace.insert(0, fr[1:])
finally:
del st
self.assertEqual(self.tracker.objects[idfoo].trace[-1][3][0].strip(),"foo = Foo()")
self.assertEqual(self.tracker.objects[idfoo].trace[:-1],trace[:-1], trace)
self.assertEqual(self.tracker.objects[idbar].trace[:-1],trace[:-1], trace)
def test_detach(self):
"""Test detaching from tracked classes.
"""
self.tracker.track_class(Foo)
self.tracker.track_class(Bar)
foo = Foo()
bar = Bar()
self.assert_(id(foo) in self.tracker.objects)
self.assert_(id(bar) in self.tracker.objects)
self.tracker.detach_class(Foo)
self.tracker.detach_class(Bar)
foo2 = Foo()
bar2 = Bar()
self.assert_(id(foo2) not in self.tracker.objects)
self.assert_(id(bar2) not in self.tracker.objects)
self.assertRaises(KeyError, self.tracker.detach_class, Foo)
def test_change_name(self):
"""Test modifying name.
"""
self.tracker.track_class(Foo, name='Foobar')
self.tracker.track_class(Foo, name='Baz')
foo = Foo()
self.assert_('Foobar' not in self.tracker.index)
self.assert_('Baz' in self.tracker.index)
self.assertEqual(self.tracker.index['Baz'][0].ref(),foo)
class LogTestCase(unittest.TestCase):
def setUp(self):
self.tracker = ClassTracker()
def tearDown(self):
self.tracker.stop_periodic_snapshots()
self.tracker.clear()
def test_dump(self):
"""Test serialization of log data.
"""
foo = Foo()
foo.data = range(1000)
bar = Bar()
self.tracker.track_object(foo, resolution_level=4)
self.tracker.track_object(bar)
self.tracker.create_snapshot('Footest')
f1 = StringIO()
f2 = StringIO()
ConsoleStats(tracker=self.tracker, stream=f1).print_stats()
tmp = BytesIO()
Stats(tracker=self.tracker).dump_stats(tmp, close=0)
self.tracker.clear()
stats = ConsoleStats(stream=f2)
self.assert_(stats.index is None)
self.assert_(stats.footprint is None)
tmp.seek(0)
stats.load_stats(tmp)
tmp.close()
self.assert_('Foo' in stats.index)
stats.print_stats()
self.assertEqual(f1.getvalue(), f2.getvalue())
# Test sort_stats and reverse_order
self.assertEqual(stats.sort_stats('size'), stats)
self.assertEqual(stats.sorted[0].classname, 'Foo')
stats.reverse_order()
self.assertEqual(stats.sorted[0].classname, 'Bar')
stats.sort_stats('classname', 'birth')
self.assertEqual(stats.sorted[0].classname, 'Bar')
self.assertRaises(ValueError, stats.sort_stats, 'name', 42, 'classn')
# Test partial printing
stats.stream = f3 = StringIO()
stats.sort_stats()
tolen = len(stats.sorted)
stats.print_stats(clsname='Bar',limit=0.5)
self.assertEqual(len(stats.sorted), tolen)
stats.print_summary()
clsname = f3.getvalue().split('\n')[0]
self.assertNotEqual(re.search('\.Bar', clsname), None, clsname)
self.assert_(len(f3.getvalue()) < len(f1.getvalue()))
f1.close()
f2.close()
f3.close()
def test_snapshots(self):
"""Test multiple snapshots.
"""
self.tracker.track_class(Foo, name='Foo')
self.tracker.track_class(Bar, name='Bar')
self.tracker.track_class(FooNew, name='FooNew')
self.tracker.create_snapshot()
f1 = Foo()
self.tracker.create_snapshot()
f2 = Foo()
f3 = FooNew()
self.tracker.create_snapshot()
b = Bar()
del b
self.tracker.create_snapshot()
stream = StringIO()
stats = ConsoleStats(tracker=self.tracker, stream=stream)
stats.print_stats()
stats.print_summary()
def test_merge(self):
"""Test merging of reference trees.
"""
self.tracker.track_class(FooNew, name='Foo', resolution_level=2)
f1 = FooNew()
f1.a = list(range(1000))
f2 = FooNew()
f2.a = list(range(100))
f2.b = 'This is some stupid spam.'
self.tracker.create_snapshot('Merge test')
sizer = Asizer()
sz1 = sizer.asized(f1)
sz2 = sizer.asized(f2)
stats = Stats(tracker=self.tracker)
for fp in stats.footprint:
if fp.desc == 'Merge test':
stats.annotate_snapshot(fp)
self.assert_(hasattr(fp, 'classes'))
self.assert_('Foo' in fp.classes, fp.classes)
self.assert_('merged' in fp.classes['Foo'])
fm = fp.classes['Foo']['merged']
self.assertEqual(fm.size, sz1.size + sz2.size, (fm.size, str(sz1), str(sz2)))
refs = {}
for ref in fm.refs:
refs[ref.name] = ref
self.assert_('__dict__' in refs.keys(), refs.keys())
refs2 = {}
for ref in refs['__dict__'].refs:
refs2[ref.name] = ref
self.assert_('[V] a' in refs2.keys(), refs2.keys())
self.assert_('[V] b' in refs2.keys(), refs2.keys())
self.assertEqual(refs2['[V] a'].size, asizeof(f1.a, f2.a))
def test_html(self):
"""Test emitting HTML statistics."""
self.tracker.track_class(Foo, name='Foo', resolution_level=2)
f1 = Foo()
f1.a = list(range(100000))
f2 = Foo()
f2.a = list(range(1000))
f2.b = 'This is some stupid spam.'
self.tracker.create_snapshot('Merge test')
stats = HtmlStats(tracker=self.tracker)
stats.create_html('tmp/data/footest.html')
def test_charts(self):
"""Test emitting graphic charts."""
self.tracker.track_class(Foo, name='Foo', resolution_level=2)
f1 = Foo()
f1.a = list(range(1000))
f2 = Foo()
f2.a = list(range(100))
f2.b = 'This is some stupid spam.'
self.tracker.create_snapshot('Merge test')
stats = Stats(tracker=self.tracker)
from pympler.gui import charts
charts.tracker_timespace('tmp/data/timespace.png', stats)
class SnapshotTestCase(unittest.TestCase):
def setUp(self):
self.tracker = ClassTracker()
def tearDown(self):
self.tracker.stop_periodic_snapshots()
self.tracker.clear()
def test_timestamp(self):
"""Test timestamp of snapshots.
"""
foo = Foo()
bar = Bar()
self.tracker.track_object(foo)
self.tracker.track_object(bar)
self.tracker.create_snapshot()
self.tracker.create_snapshot()
self.tracker.create_snapshot()
refts = [fp.timestamp for fp in self.tracker.footprint]
for to in self.tracker.objects.values():
ts = [t for (t,sz) in to.footprint[1:]]
self.assertEqual(ts,refts)
def test_snapshot_members(self):
"""Test existence and value of snapshot members.
"""
foo = Foo()
self.tracker.track_object(foo)
self.tracker.create_snapshot()
fp = self.tracker.footprint[0]
self.assert_(fp.overhead > 0, fp.overhead)
self.assert_(fp.tracked_total > 0, fp.tracked_total)
self.assert_(fp.asizeof_total > 0, fp.asizeof_total)
self.assert_(fp.asizeof_total >= fp.tracked_total)
if pympler.process.is_available():
self.assert_(fp.system_total.vsz > 0)
self.assert_(fp.system_total.rss > 0)
self.assert_(fp.system_total.vsz >= fp.system_total.rss)
self.assert_(fp.system_total.vsz > fp.overhead)
self.assert_(fp.system_total.vsz > fp.tracked_total)
self.assert_(fp.system_total.vsz > fp.asizeof_total)
def test_desc(self):
"""Test footprint description.
"""
self.tracker.create_snapshot()
self.tracker.create_snapshot('alpha')
self.tracker.create_snapshot(description='beta')
self.tracker.create_snapshot(42)
self.assertEqual(len(self.tracker.footprint), 4)
self.assertEqual(self.tracker.footprint[0].desc, '')
self.assertEqual(self.tracker.footprint[1].desc, 'alpha')
self.assertEqual(self.tracker.footprint[2].desc, 'beta')
self.assertEqual(self.tracker.footprint[3].desc, '42')
def test_background_monitoring(self):
"""Test background monitoring.
"""
import time
self.tracker.start_periodic_snapshots(0.1)
self.assertEqual(self.tracker._periodic_thread.interval, 0.1)
self.assertEqual(self.tracker._periodic_thread.getName(), 'BackgroundMonitor')
for x in range(10): # try to interfere
self.tracker.create_snapshot(str(x))
time.sleep(0.5)
self.tracker.start_periodic_snapshots(0.2)
self.assertEqual(self.tracker._periodic_thread.interval, 0.2)
self.tracker.stop_periodic_snapshots()
self.assert_(self.tracker._periodic_thread is None)
self.assert_(len(self.tracker.footprint) > 10)