def test_focus_on_function_using_tuples(self): recorder = TextStreamRecorder( text_stream=self.stream, filter_=lambda record: self.filename in record) def monitor_factory(functions=[]): return FocusedFunctionMonitor( functions=functions, recorder=recorder, record_type=tuple) helper = FocusedMonitoringHelper(monitor_factory) result = helper.run_on_function() self.assertEqual(result, 3) template = [ "0 call gcd 33 {0}", "1 call internal 40 {0}", "2 call boo 44 {0}", "3 return boo 45 {0}", "4 return internal 42 {0}", "5 call internal 40 {0}", "6 call boo 44 {0}", "7 return boo 45 {0}", "8 return internal 42 {0}", "9 return gcd 36 {0}"] self.check_records(template, self.stream) self.assertEqual(helper.monitor._code_trackers, {})
def test_focus_on_function_using_tuples(self): # local import to avoid errors when the optional depedency psutils is # not available from pikos.cymonitors.focused_function_memory_monitor import ( FocusedFunctionMemoryMonitor) recorder = ListRecorder( filter_=lambda record: self.filename in record) def monitor_factory(functions=[]): return FocusedFunctionMemoryMonitor( functions=functions, recorder=recorder, record_type=tuple) helper = FocusedMonitoringHelper(monitor_factory) result = helper.run_on_function() self.assertEqual(result, 3) template = [ "0 call gcd 33 {0}", "1 call internal 40 {0}", "2 call boo 44 {0}", "3 return boo 45 {0}", "4 return internal 42 {0}", "5 call internal 40 {0}", "6 call boo 44 {0}", "7 return boo 45 {0}", "8 return internal 42 {0}", "9 return gcd 36 {0}"] self.check_records(template, recorder) self.assertEqual(helper.monitor._code_trackers, {})
def setUp(self): self.maxDiff = None self.stream = StringIO.StringIO() def monitor_factory(functions=[]): return FocusedLineMonitor( functions=functions, recorder=self.recorder) self.helper = FocusedMonitoringHelper(monitor_factory) self.filename = self.helper.filename self.recorder = TextStreamRecorder( text_stream=self.stream)
def test_focus_on_function_using_tuples(self): recorder = ListRecorder() def monitor_factory(functions=[]): from pikos.cymonitors.focused_line_memory_monitor import ( FocusedLineMemoryMonitor) return FocusedLineMemoryMonitor( functions=functions, recorder=recorder, record_type=tuple) helper = FocusedMonitoringHelper(monitor_factory) result = helper.run_on_function() self.assertEqual(result, 3) template = [ "0 gcd 34 while x > 0: {0}", "1 gcd 35 x, y = internal(x, y) {0}", "2 gcd 34 while x > 0: {0}", "3 gcd 35 x, y = internal(x, y) {0}", "4 gcd 34 while x > 0: {0}", "5 gcd 36 return y {0}"] self.check_records(template, recorder)
def test_focus_on_function_with_tuple(self): recorder = TextStreamRecorder( text_stream=self.stream, filter_=lambda record: self.filename in record) def monitor_factory(functions=[]): return FocusedLineMonitor( functions=functions, recorder=recorder, record_type=tuple) helper = FocusedMonitoringHelper(monitor_factory) result = helper.run_on_function() self.assertEqual(result, 3) template = [ "0 gcd 34 while x > 0: {0}", "1 gcd 35 x, y = internal(x, y) {0}", "2 gcd 34 while x > 0: {0}", "3 gcd 35 x, y = internal(x, y) {0}", "4 gcd 34 while x > 0: {0}", "5 gcd 36 return y {0}"] self.check_records(template, self.stream)
def setUp(self): self.check_for_psutils() from pikos.monitors.focused_line_memory_monitor import ( FocusedLineMemoryMonitor) self.maxDiff = None self.stream = StringIO.StringIO() def monitor_factory(functions=[]): return FocusedLineMemoryMonitor( functions=functions, recorder=self.recorder) self.helper = FocusedMonitoringHelper(monitor_factory) self.filename = self.helper.filename self.recorder = ListRecorder()
def setUp(self): self.check_for_psutils() self.maxDiff = None # local import to avoid errors when the optional depedency psutils is # not available from pikos.monitors.focused_function_memory_monitor import ( FocusedFunctionMemoryMonitor) def monitor_factory(functions=[]): return FocusedFunctionMemoryMonitor( functions=functions, recorder=self.recorder) self.helper = FocusedMonitoringHelper(monitor_factory) self.filename = self.helper.filename self.recorder = ListRecorder( filter_=OnValue('filename', self.filename))
def setUp(self): self.check_for_psutils() try: from pikos.cymonitors.focused_function_memory_monitor import ( FocusedFunctionMemoryMonitor) except ImportError: self.skipTest( 'Cython FocusedFunctionMemoryMonitor is not available') self.maxDiff = None def monitor_factory(functions=[]): return FocusedFunctionMemoryMonitor( functions=functions, recorder=self.recorder) self.helper = FocusedMonitoringHelper(monitor_factory) self.filename = self.helper.filename self.recorder = ListRecorder( filter_=OnValue('filename', self.filename))
def setUp(self): self.check_for_psutils() try: from pikos.cymonitors.focused_line_memory_monitor import ( FocusedLineMemoryMonitor) except ImportError: self.skipTest('Cython LineMemoryMonitor is not available') self.maxDiff = None self.stream = StringIO.StringIO() def monitor_factory(functions=[]): return FocusedLineMemoryMonitor( functions=functions, recorder=self.recorder) self.helper = FocusedMonitoringHelper(monitor_factory) self.filename = self.helper.filename self.recorder = ListRecorder()
def setUp(self): try: from pikos.cymonitors.focused_function_monitor import ( FocusedFunctionMonitor) except ImportError: self.skipTest('Cython FocusedFunctionMonitor is not available') self.maxDiff = None self.stream = StringIO.StringIO() def monitor_factory(functions=[]): return FocusedFunctionMonitor( functions=functions, recorder=self.recorder) self.helper = FocusedMonitoringHelper(monitor_factory) self.filename = self.helper.filename self.recorder = TextStreamRecorder( text_stream=self.stream, filter_=OnValue('filename', self.filename))
class TestFocusedCFunctionMemoryMonitor(TestCase): def setUp(self): self.check_for_psutils() try: from pikos.cymonitors.focused_function_memory_monitor import ( FocusedFunctionMemoryMonitor) except ImportError: self.skipTest( 'Cython FocusedFunctionMemoryMonitor is not available') self.maxDiff = None def monitor_factory(functions=[]): return FocusedFunctionMemoryMonitor( functions=functions, recorder=self.recorder) self.helper = FocusedMonitoringHelper(monitor_factory) self.filename = self.helper.filename self.recorder = ListRecorder( filter_=OnValue('filename', self.filename)) def test_focus_on_function(self): result = self.helper.run_on_function() self.assertEqual(result, 3) template = [ "0 call gcd 33 {0}", "1 call internal 40 {0}", "2 call boo 44 {0}", "3 return boo 45 {0}", "4 return internal 42 {0}", "5 call internal 40 {0}", "6 call boo 44 {0}", "7 return boo 45 {0}", "8 return internal 42 {0}", "9 return gcd 36 {0}"] self.check_records(template, self.recorder) self.assertEqual(self.helper.monitor._code_trackers, {}) def test_focus_on_functions(self): result = self.helper.run_on_functions() self.assertEqual(result, 3) template = [ "0 call gcd 62 {0}", "1 call internal 67 {0}", "2 return internal 68 {0}", "3 call internal 67 {0}", "4 return internal 68 {0}", "5 return gcd 65 {0}", "6 call foo 73 {0}", "7 call boo 70 {0}", "8 return boo 71 {0}", "9 call boo 70 {0}", "10 return boo 71 {0}", "11 return foo 75 {0}", ] self.check_records(template, self.recorder) self.assertEqual(self.helper.monitor._code_trackers, {}) def test_focus_on_recursive(self): result = self.helper.run_on_recursive_function() self.assertEqual(result, 3) template = [ "0 call gcd 96 {0}", "1 call foo 103 {0}", "2 return foo 104 {0}", "3 call gcd 96 {0}", "4 call foo 103 {0}", "5 return foo 104 {0}", "6 return gcd 98 {0}", "7 return gcd 98 {0}"] self.check_records(template, self.recorder) self.assertEqual(self.helper.monitor._code_trackers, {}) def test_focus_on_decorated_function(self): result = self.helper.run_on_decorated() self.assertEqual(result, 3) template = [ "0 call container 137 {0}", "1 call gcd 123 {0}", "2 call internal 128 {0}", "3 call boo 132 {0}", "4 return boo 133 {0}", "5 return internal 130 {0}", "6 call internal 128 {0}", "7 call boo 132 {0}", "8 return boo 133 {0}", "9 return internal 130 {0}", "10 return gcd 126 {0}", "11 call boo 132 {0}", "12 return boo 133 {0}", "13 return container 141 {0}"] self.check_records(template, self.recorder) self.assertEqual(self.helper.monitor._code_trackers, {}) def test_focus_on_decorated_recursive(self): result = self.helper.run_on_decorated_recursive() self.assertEqual(result, 3) if sys.version_info[:2] == (2, 6): # Python 2.6 __enter__ is called through the CALL_FUNCTION # bytecode and thus the c __enter__ methods appear in the # function events while in 2.7 the behaviour has changed. template = [ "0 call gcd 157 {0}", "1 call foo 152 {0}", "2 return foo 153 {0}", "8 call gcd 157 {0}", "9 call foo 152 {0}", "10 return foo 153 {0}", "11 return gcd 160 {0}", "15 return gcd 160 {0}"] else: template = [ "0 call gcd 157 {0}", "1 call foo 152 {0}", "2 return foo 153 {0}", "6 call gcd 157 {0}", "7 call foo 152 {0}", "8 return foo 153 {0}", "9 return gcd 160 {0}", "13 return gcd 160 {0}"] self.check_records(template, self.recorder) self.assertEqual(self.helper.monitor._code_trackers, {}) def test_focus_on_function_using_tuples(self): # local import to avoid errors when the optional depedency psutils is # not available from pikos.cymonitors.focused_function_memory_monitor import ( FocusedFunctionMemoryMonitor) recorder = ListRecorder( filter_=lambda record: self.filename in record) def monitor_factory(functions=[]): return FocusedFunctionMemoryMonitor( functions=functions, recorder=recorder, record_type=tuple) helper = FocusedMonitoringHelper(monitor_factory) result = helper.run_on_function() self.assertEqual(result, 3) template = [ "0 call gcd 33 {0}", "1 call internal 40 {0}", "2 call boo 44 {0}", "3 return boo 45 {0}", "4 return internal 42 {0}", "5 call internal 40 {0}", "6 call boo 44 {0}", "7 return boo 45 {0}", "8 return internal 42 {0}", "9 return gcd 36 {0}"] self.check_records(template, recorder) self.assertEqual(helper.monitor._code_trackers, {}) def get_records(self, recorder): """ Remove the memory related fields. """ records = [] for record in recorder.records: filtered = record[:3] + record[5:] records.append(' '.join([str(item) for item in filtered])) return records def check_records(self, template, recorder): expected = [line.format(self.filename) for line in template] records = self.get_records(recorder) self.assertEqual(records, expected) def check_for_psutils(self): try: import psutil psutil except ImportError: self.skipTest('Could not import psutils, skipping test.')
class TestFocusedLineMemoryMonitor(TestCase): def setUp(self): self.check_for_psutils() try: from pikos.cymonitors.focused_line_memory_monitor import ( FocusedLineMemoryMonitor) except ImportError: self.skipTest('Cython LineMemoryMonitor is not available') self.maxDiff = None self.stream = StringIO.StringIO() def monitor_factory(functions=[]): return FocusedLineMemoryMonitor( functions=functions, recorder=self.recorder) self.helper = FocusedMonitoringHelper(monitor_factory) self.filename = self.helper.filename self.recorder = ListRecorder() def test_focus_on_function(self): result = self.helper.run_on_function() self.assertEqual(result, 3) template = [ "0 gcd 34 while x > 0: {0}", "1 gcd 35 x, y = internal(x, y) {0}", "2 gcd 34 while x > 0: {0}", "3 gcd 35 x, y = internal(x, y) {0}", "4 gcd 34 while x > 0: {0}", "5 gcd 36 return y {0}"] self.check_records(template, self.recorder) def test_focus_on_functions(self): result = self.helper.run_on_functions() self.assertEqual(result, 3) template = [ "0 gcd 63 while x > 0: {0}", "1 gcd 64 x, y = internal(x, y) {0}", "2 gcd 63 while x > 0: {0}", "3 gcd 64 x, y = internal(x, y) {0}", "4 gcd 63 while x > 0: {0}", "5 gcd 65 return y {0}", "6 foo 74 boo() {0}", "7 foo 75 boo() {0}"] self.check_records(template, self.recorder) def test_focus_on_recursive(self): result = self.helper.run_on_recursive_function() self.assertEqual(result, 3) template = [ "0 gcd 97 foo() {0}", "1 gcd 98 return x if y == 0 else gcd(y, (x % y)) {0}", # noqa "2 gcd 97 foo() {0}", "3 gcd 98 return x if y == 0 else gcd(y, (x % y)) {0}"] # noqa self.check_records(template, self.recorder) def test_focus_on_decorated_recursive_function(self): result = self.helper.run_on_decorated_recursive() self.assertEqual(result, 3) template = [ "0 gcd 159 foo() {0}", "1 gcd 160 return x if y == 0 else gcd(y, (x % y)) {0}", # noqa "2 gcd 159 foo() {0}", "3 gcd 160 return x if y == 0 else gcd(y, (x % y)) {0}"] # noqa self.check_records(template, self.recorder) def test_focus_on_decorated_function(self): result = self.helper.run_on_decorated() self.assertEqual(result, 3) template = [ "0 container 139 result = gcd(x, y) {0}", "1 gcd 124 while x > 0: {0}", "2 gcd 125 x, y = internal(x, y) {0}", "3 gcd 124 while x > 0: {0}", "4 gcd 125 x, y = internal(x, y) {0}", "5 gcd 124 while x > 0: {0}", "6 gcd 126 return y {0}", "7 container 140 boo() {0}", "8 container 141 return result {0}"] self.check_records(template, self.recorder) def test_focus_on_function_using_tuples(self): recorder = ListRecorder() def monitor_factory(functions=[]): from pikos.cymonitors.focused_line_memory_monitor import ( FocusedLineMemoryMonitor) return FocusedLineMemoryMonitor( functions=functions, recorder=recorder, record_type=tuple) helper = FocusedMonitoringHelper(monitor_factory) result = helper.run_on_function() self.assertEqual(result, 3) template = [ "0 gcd 34 while x > 0: {0}", "1 gcd 35 x, y = internal(x, y) {0}", "2 gcd 34 while x > 0: {0}", "3 gcd 35 x, y = internal(x, y) {0}", "4 gcd 34 while x > 0: {0}", "5 gcd 36 return y {0}"] self.check_records(template, recorder) def get_records(self, recorder): """ Remove the memory related fields. """ records = [] for record in recorder.records: filtered = record[:3] + record[5:] records.append(' '.join([str(item) for item in filtered])) return records def check_for_psutils(self): try: import psutil # noqa except ImportError: self.skipTest('Could not import psutils, skipping test.') def check_records(self, template, recorder): expected = [line.format(self.filename) for line in template] records = self.get_records(recorder) self.assertEqual(records, expected)
class TestFocusedFunctionMonitor(TestCase): def setUp(self): self.maxDiff = None self.stream = StringIO.StringIO() def monitor_factory(functions=[]): return FocusedFunctionMonitor( functions=functions, recorder=self.recorder) self.helper = FocusedMonitoringHelper(monitor_factory) self.filename = self.helper.filename self.recorder = TextStreamRecorder( text_stream=self.stream, filter_=OnValue('filename', self.filename)) def tearDown(self): sys.setprofile(None) def test_focus_on_function(self): result = self.helper.run_on_function() self.assertEqual(result, 3) template = [ "index type function lineNo filename", "-----------------------------------", "0 call gcd 33 {0}", "1 call internal 40 {0}", "2 call boo 44 {0}", "3 return boo 45 {0}", "4 return internal 42 {0}", "5 call internal 40 {0}", "6 call boo 44 {0}", "7 return boo 45 {0}", "8 return internal 42 {0}", "9 return gcd 36 {0}"] self.check_records(template, self.stream) self.assertEqual(self.helper.monitor._code_trackers, {}) def test_focus_on_functions(self): result = self.helper.run_on_functions() self.assertEqual(result, 3) template = [ "index type function lineNo filename", "-----------------------------------", "0 call gcd 62 {0}", "1 call internal 67 {0}", "2 return internal 68 {0}", "3 call internal 67 {0}", "4 return internal 68 {0}", "5 return gcd 65 {0}", "6 call foo 73 {0}", "7 call boo 70 {0}", "8 return boo 71 {0}", "9 call boo 70 {0}", "10 return boo 71 {0}", "11 return foo 75 {0}", ] self.check_records(template, self.stream) self.assertEqual(self.helper.monitor._code_trackers, {}) def test_focus_on_recursive(self): result = self.helper.run_on_recursive_function() self.assertEqual(result, 3) template = [ "index type function lineNo filename", "-----------------------------------", "0 call gcd 96 {0}", "1 call foo 103 {0}", "2 return foo 104 {0}", "3 call gcd 96 {0}", "4 call foo 103 {0}", "5 return foo 104 {0}", "6 return gcd 98 {0}", "7 return gcd 98 {0}"] self.check_records(template, self.stream) self.assertEqual(self.helper.monitor._code_trackers, {}) def test_focus_on_decorated_function(self): result = self.helper.run_on_decorated() self.assertEqual(result, 3) template = [ "index type function lineNo filename", "-----------------------------------", "0 call container 137 {0}", "1 call gcd 123 {0}", "2 call internal 128 {0}", "3 call boo 132 {0}", "4 return boo 133 {0}", "5 return internal 130 {0}", "6 call internal 128 {0}", "7 call boo 132 {0}", "8 return boo 133 {0}", "9 return internal 130 {0}", "10 return gcd 126 {0}", "11 call boo 132 {0}", "12 return boo 133 {0}", "13 return container 141 {0}"] self.check_records(template, self.stream) self.assertEqual(self.helper.monitor._code_trackers, {}) def test_focus_on_decorated_recursive(self): result = self.helper.run_on_decorated_recursive() self.assertEqual(result, 3) template = [ "index type function lineNo filename", "-----------------------------------", "0 call gcd 157 {0}", "1 call foo 152 {0}", "2 return foo 153 {0}", "10 call gcd 157 {0}", "11 call foo 152 {0}", "12 return foo 153 {0}", "13 return gcd 160 {0}", "21 return gcd 160 {0}"] self.check_records(template, self.stream) self.assertEqual(self.helper.monitor._code_trackers, {}) def test_focus_on_function_using_tuples(self): recorder = TextStreamRecorder( text_stream=self.stream, filter_=lambda record: self.filename in record) def monitor_factory(functions=[]): return FocusedFunctionMonitor( functions=functions, recorder=recorder, record_type=tuple) helper = FocusedMonitoringHelper(monitor_factory) result = helper.run_on_function() self.assertEqual(result, 3) template = [ "0 call gcd 33 {0}", "1 call internal 40 {0}", "2 call boo 44 {0}", "3 return boo 45 {0}", "4 return internal 42 {0}", "5 call internal 40 {0}", "6 call boo 44 {0}", "7 return boo 45 {0}", "8 return internal 42 {0}", "9 return gcd 36 {0}"] self.check_records(template, self.stream) self.assertEqual(helper.monitor._code_trackers, {}) def check_records(self, template, stream): expected = [line.format(self.filename) for line in template] records = ''.join(stream.buflist).splitlines() self.assertEqual(records, expected)
class TestFocusedLineMonitor(TestCase): def setUp(self): try: from pikos.cymonitors.focused_line_monitor import ( FocusedLineMonitor) except ImportError: self.skipTest('Cython LineMonitor is not available') self.maxDiff = None self.maxDiff = None self.stream = StringIO.StringIO() def monitor_factory(functions=[]): return FocusedLineMonitor( functions=functions, recorder=self.recorder) self.helper = FocusedMonitoringHelper(monitor_factory) self.filename = self.helper.filename self.recorder = TextStreamRecorder( text_stream=self.stream) def test_focus_on_function(self): result = self.helper.run_on_function() self.assertEqual(result, 3) template = [ "index function lineNo line filename", "-----------------------------------", "0 gcd 34 while x > 0: {0}", "1 gcd 35 x, y = internal(x, y) {0}", "2 gcd 34 while x > 0: {0}", "3 gcd 35 x, y = internal(x, y) {0}", "4 gcd 34 while x > 0: {0}", "5 gcd 36 return y {0}"] self.check_records(template, self.stream) def test_focus_on_functions(self): result = self.helper.run_on_functions() self.assertEqual(result, 3) template = [ "index function lineNo line filename", "-----------------------------------", "0 gcd 63 while x > 0: {0}", "1 gcd 64 x, y = internal(x, y) {0}", "2 gcd 63 while x > 0: {0}", "3 gcd 64 x, y = internal(x, y) {0}", "4 gcd 63 while x > 0: {0}", "5 gcd 65 return y {0}", "6 foo 74 boo() {0}", "7 foo 75 boo() {0}"] self.check_records(template, self.stream) def test_focus_on_recursive(self): result = self.helper.run_on_recursive_function() self.assertEqual(result, 3) template = [ "index function lineNo line filename", "-----------------------------------", "0 gcd 97 foo() {0}", "1 gcd 98 return x if y == 0 else gcd(y, (x % y)) {0}", # noqa "2 gcd 97 foo() {0}", "3 gcd 98 return x if y == 0 else gcd(y, (x % y)) {0}"] # noqa self.check_records(template, self.stream) def test_focus_on_decorated_function(self): result = self.helper.run_on_decorated() self.assertEqual(result, 3) template = [ "index function lineNo line filename", "-----------------------------------", "0 container 139 result = gcd(x, y) {0}", "1 gcd 124 while x > 0: {0}", "2 gcd 125 x, y = internal(x, y) {0}", "3 gcd 124 while x > 0: {0}", "4 gcd 125 x, y = internal(x, y) {0}", "5 gcd 124 while x > 0: {0}", "6 gcd 126 return y {0}", "7 container 140 boo() {0}", "8 container 141 return result {0}"] self.check_records(template, self.stream) def test_focus_on_decorated_recursive_function(self): result = self.helper.run_on_decorated_recursive() self.assertEqual(result, 3) template = [ "index function lineNo line filename", "-----------------------------------", "0 gcd 159 foo() {0}", "1 gcd 160 return x if y == 0 else gcd(y, (x % y)) {0}", # noqa "2 gcd 159 foo() {0}", "3 gcd 160 return x if y == 0 else gcd(y, (x % y)) {0}"] # noqa self.check_records(template, self.stream) def test_focus_on_function_with_tuple(self): from pikos.cymonitors.focused_line_monitor import FocusedLineMonitor recorder = TextStreamRecorder( text_stream=self.stream, filter_=lambda record: self.filename in record) def monitor_factory(functions=[]): return FocusedLineMonitor( functions=functions, recorder=recorder, record_type=tuple) helper = FocusedMonitoringHelper(monitor_factory) result = helper.run_on_function() self.assertEqual(result, 3) template = [ "0 gcd 34 while x > 0: {0}", "1 gcd 35 x, y = internal(x, y) {0}", "2 gcd 34 while x > 0: {0}", "3 gcd 35 x, y = internal(x, y) {0}", "4 gcd 34 while x > 0: {0}", "5 gcd 36 return y {0}"] self.check_records(template, self.stream) def check_records(self, template, stream): template = [line.format(self.filename) for line in template] records = ''.join(stream.buflist).splitlines() self.assertEqual(records, template)
class TestFocusedCFunctionMonitor(TestCase): def setUp(self): try: from pikos.cymonitors.focused_function_monitor import ( FocusedFunctionMonitor) except ImportError: self.skipTest('Cython FocusedFunctionMonitor is not available') self.maxDiff = None self.stream = StringIO.StringIO() def monitor_factory(functions=[]): return FocusedFunctionMonitor( functions=functions, recorder=self.recorder) self.helper = FocusedMonitoringHelper(monitor_factory) self.filename = self.helper.filename self.recorder = TextStreamRecorder( text_stream=self.stream, filter_=OnValue('filename', self.filename)) def tearDown(self): sys.setprofile(None) def test_focus_on_function(self): result = self.helper.run_on_function() self.assertEqual(result, 3) template = [ "index type function lineNo filename", "-----------------------------------", "0 call gcd 33 {0}", "1 call internal 40 {0}", "2 call boo 44 {0}", "3 return boo 45 {0}", "4 return internal 42 {0}", "5 call internal 40 {0}", "6 call boo 44 {0}", "7 return boo 45 {0}", "8 return internal 42 {0}", "9 return gcd 36 {0}"] self.check_records(template, self.stream) self.assertEqual(self.helper.monitor._code_trackers, {}) def test_focus_on_functions(self): result = self.helper.run_on_functions() self.assertEqual(result, 3) template = [ "index type function lineNo filename", "-----------------------------------", "0 call gcd 62 {0}", "1 call internal 67 {0}", "2 return internal 68 {0}", "3 call internal 67 {0}", "4 return internal 68 {0}", "5 return gcd 65 {0}", "6 call foo 73 {0}", "7 call boo 70 {0}", "8 return boo 71 {0}", "9 call boo 70 {0}", "10 return boo 71 {0}", "11 return foo 75 {0}", ] self.check_records(template, self.stream) self.assertEqual(self.helper.monitor._code_trackers, {}) def test_focus_on_recursive(self): result = self.helper.run_on_recursive_function() self.assertEqual(result, 3) template = [ "index type function lineNo filename", "-----------------------------------", "0 call gcd 96 {0}", "1 call foo 103 {0}", "2 return foo 104 {0}", "3 call gcd 96 {0}", "4 call foo 103 {0}", "5 return foo 104 {0}", "6 return gcd 98 {0}", "7 return gcd 98 {0}"] self.check_records(template, self.stream) self.assertEqual(self.helper.monitor._code_trackers, {}) def test_focus_on_decorated_function(self): result = self.helper.run_on_decorated() self.assertEqual(result, 3) template = [ "index type function lineNo filename", "-----------------------------------", "0 call container 137 {0}", "1 call gcd 123 {0}", "2 call internal 128 {0}", "3 call boo 132 {0}", "4 return boo 133 {0}", "5 return internal 130 {0}", "6 call internal 128 {0}", "7 call boo 132 {0}", "8 return boo 133 {0}", "9 return internal 130 {0}", "10 return gcd 126 {0}", "11 call boo 132 {0}", "12 return boo 133 {0}", "13 return container 141 {0}"] self.check_records(template, self.stream) self.assertEqual(self.helper.monitor._code_trackers, {}) def test_focus_on_decorated_recursive(self): result = self.helper.run_on_decorated_recursive() self.assertEqual(result, 3) if sys.version_info[:2] == (2, 6): # Python 2.6 __enter__ is called through the CALL_FUNCTION # bytecode and thus the c __enter__ methods appear in the # function events while in 2.7 the behaviour has changed. template = [ "index type function lineNo filename", "-----------------------------------", "0 call gcd 157 {0}", "1 call foo 152 {0}", "2 return foo 153 {0}", "8 call gcd 157 {0}", "9 call foo 152 {0}", "10 return foo 153 {0}", "11 return gcd 160 {0}", "15 return gcd 160 {0}"] else: template = [ "index type function lineNo filename", "-----------------------------------", "0 call gcd 157 {0}", "1 call foo 152 {0}", "2 return foo 153 {0}", "6 call gcd 157 {0}", "7 call foo 152 {0}", "8 return foo 153 {0}", "9 return gcd 160 {0}", "13 return gcd 160 {0}"] self.check_records(template, self.stream) self.assertEqual(self.helper.monitor._code_trackers, {}) def test_focus_on_function_using_tuples(self): from pikos.cymonitors.focused_function_monitor import ( FocusedFunctionMonitor) recorder = TextStreamRecorder( text_stream=self.stream, filter_=lambda record: self.filename in record) def monitor_factory(functions=[]): return FocusedFunctionMonitor( functions=functions, recorder=recorder, record_type=tuple) helper = FocusedMonitoringHelper(monitor_factory) result = helper.run_on_function() self.assertEqual(result, 3) template = [ "0 call gcd 33 {0}", "1 call internal 40 {0}", "2 call boo 44 {0}", "3 return boo 45 {0}", "4 return internal 42 {0}", "5 call internal 40 {0}", "6 call boo 44 {0}", "7 return boo 45 {0}", "8 return internal 42 {0}", "9 return gcd 36 {0}"] self.check_records(template, self.stream) self.assertEqual(helper.monitor._code_trackers, {}) def check_records(self, template, stream): expected = [line.format(self.filename) for line in template] records = ''.join(stream.buflist).splitlines() self.assertEqual(records, expected)