/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to breezy/tests/test_lsprof.py

  • Committer: Jelmer Vernooij
  • Date: 2017-07-20 00:00:04 UTC
  • mfrom: (6690.5.2 bundle-guess)
  • Revision ID: jelmer@jelmer.uk-20170720000004-wlknc5gthdk3tokn
Merge lp:~jelmer/brz/bundle-guess.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_lsprof.py
1
 
# Copyright (C) 2005, 2006 Canonical Ltd
 
1
# Copyright (C) 2007, 2009, 2010, 2011 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
17
17
"""Tests for profiling data collection."""
18
18
 
19
19
 
20
 
import cPickle
21
 
import os
22
 
 
23
 
import bzrlib
24
 
from bzrlib import tests
25
 
 
26
 
 
27
 
class _LSProfFeature(tests.Feature):
28
 
 
29
 
    def available(self):
30
 
        try:
31
 
            from bzrlib import lsprof
32
 
        except ImportError:
33
 
            return False
34
 
        else:
35
 
            return True
36
 
 
37
 
 
38
 
LSProfFeature = _LSProfFeature()
 
20
try:
 
21
    import cPickle as pickle
 
22
except ImportError:
 
23
    import pickle
 
24
import threading
 
25
 
 
26
import breezy
 
27
from .. import errors, tests
 
28
from . import (
 
29
    features,
 
30
    )
39
31
 
40
32
 
41
33
_TXT_HEADER = "   CallCount    Recursive    Total(ms)   " + \
49
41
 
50
42
def _collect_stats():
51
43
    "Collect and return some dummy profile data."
52
 
    from bzrlib.lsprof import profile
 
44
    from breezy.lsprof import profile
53
45
    ret, stats = profile(_junk_callable)
54
46
    return stats
55
47
 
56
48
 
57
49
class TestStatsSave(tests.TestCaseInTempDir):
58
50
 
59
 
    _test_needs_features = [LSProfFeature]
 
51
    _test_needs_features = [features.lsprof_feature]
60
52
 
61
53
    def setUp(self):
62
54
        super(tests.TestCaseInTempDir, self).setUp()
64
56
 
65
57
    def _tempfile(self, ext):
66
58
        dir = self.test_dir
67
 
        return bzrlib.osutils.pathjoin(dir, "tmp_profile_data." + ext)
 
59
        return breezy.osutils.pathjoin(dir, "tmp_profile_data." + ext)
68
60
 
69
61
    def test_stats_save_to_txt(self):
70
62
        f = self._tempfile("txt")
77
69
        self.stats.save(f)
78
70
        lines = open(f).readlines()
79
71
        self.assertEqual(lines[0], "events: Ticks\n")
80
 
        f = bzrlib.osutils.pathjoin(self.test_dir, "callgrind.out.foo")
 
72
        f = breezy.osutils.pathjoin(self.test_dir, "callgrind.out.foo")
81
73
        self.stats.save(f)
82
74
        lines = open(f).readlines()
83
75
        self.assertEqual(lines[0], "events: Ticks\n")
90
82
    def test_stats_save_to_pickle(self):
91
83
        f = self._tempfile("pkl")
92
84
        self.stats.save(f)
93
 
        data1 = cPickle.load(open(f))
94
 
        self.assertEqual(type(data1), bzrlib.lsprof.Stats)
 
85
        data1 = pickle.load(open(f))
 
86
        self.assertEqual(type(data1), breezy.lsprof.Stats)
95
87
 
96
88
 
97
89
class TestBzrProfiler(tests.TestCase):
98
90
 
99
 
    _test_needs_features = [LSProfFeature]
 
91
    _test_needs_features = [features.lsprof_feature]
100
92
 
101
93
    def test_start_call_stuff_stop(self):
102
 
        profiler = bzrlib.lsprof.BzrProfiler()
 
94
        profiler = breezy.lsprof.BzrProfiler()
103
95
        profiler.start()
104
96
        try:
105
97
            def a_function():
111
103
        lines = [str(data) for data in stats.data]
112
104
        lines = [line for line in lines if 'a_function' in line]
113
105
        self.assertLength(1, lines)
 
106
 
 
107
    def test_block_0(self):
 
108
        # When profiler_block is 0, reentrant profile requests fail.
 
109
        self.overrideAttr(breezy.lsprof.BzrProfiler, 'profiler_block', 0)
 
110
        inner_calls = []
 
111
        def inner():
 
112
            profiler = breezy.lsprof.BzrProfiler()
 
113
            self.assertRaises(errors.BzrError, profiler.start)
 
114
            inner_calls.append(True)
 
115
        breezy.lsprof.profile(inner)
 
116
        self.assertLength(1, inner_calls)
 
117
 
 
118
    def test_block_1(self):
 
119
        # When profiler_block is 1, concurrent profiles serialise.
 
120
        # This is tested by manually acquiring the profiler lock, then
 
121
        # starting a thread that tries to profile, and releasing the lock. 
 
122
        # We know due to test_block_0 that two profiles at once hit the lock,
 
123
        # so while this isn't perfect (we'd want a callback on the lock being
 
124
        # entered to allow lockstep evaluation of the actions), its good enough
 
125
        # to be confident regressions would be caught. Alternatively, if this
 
126
        # is flakey, a fake Lock object can be used to trace the calls made.
 
127
        calls = []
 
128
        def profiled():
 
129
            calls.append('profiled')
 
130
        def do_profile():
 
131
            breezy.lsprof.profile(profiled)
 
132
            calls.append('after_profiled')
 
133
        thread = threading.Thread(target=do_profile)
 
134
        breezy.lsprof.BzrProfiler.profiler_lock.acquire()
 
135
        try:
 
136
            try:
 
137
                thread.start()
 
138
            finally:
 
139
                breezy.lsprof.BzrProfiler.profiler_lock.release()
 
140
        finally:
 
141
            thread.join()
 
142
        self.assertLength(2, calls)