Lines Matching refs:self
103 def trace_dispatch(self, frame, event, arg):
104 self.currentbp = None
107 def set_break(self, filename, lineno, temporary=False, cond=None,
127 def get_stack(self, f, t):
128 self.stack, self.index = super().get_stack(f, t)
129 self.frame = self.stack[self.index][0]
130 return self.stack, self.index
132 def set_ignore(self, bpnum):
134 bp = self.get_bpbynumber(bpnum)
137 def set_enable(self, bpnum):
138 bp = self.get_bpbynumber(bpnum)
141 def set_disable(self, bpnum):
142 bp = self.get_bpbynumber(bpnum)
145 def set_clear(self, fname, lineno):
146 err = self.clear_break(fname, lineno)
150 def set_up(self):
152 if not self.index:
154 self.index -= 1
155 self.frame = self.stack[self.index][0]
157 def set_down(self):
159 if self.index + 1 == len(self.stack):
161 self.index += 1
162 self.frame = self.stack[self.index][0]
167 def __init__(self, expect_set, skip=None, dry_run=False, test_case=None):
169 self.expect_set = expect_set
170 self.dry_run = dry_run
171 self.header = ('Dry-run results for %s:' % test_case if
173 self.init_test()
175 def init_test(self):
176 self.cur_except = None
177 self.expect_set_no = 0
178 self.breakpoint_hits = None
179 self.expected_list = list(islice(self.expect_set, 0, None, 2))
180 self.set_list = list(islice(self.expect_set, 1, None, 2))
182 def trace_dispatch(self, frame, event, arg):
187 if self.cur_except is not None:
188 raise self.cur_except
195 self.cur_except = e
196 return self.trace_dispatch
200 def user_call(self, frame, argument_list):
204 if not self.stop_here(frame):
206 self.process_event('call', frame, argument_list)
207 self.next_set_method()
209 def user_line(self, frame):
210 self.process_event('line', frame)
212 if self.dry_run and self.breakpoint_hits:
217 self.delete_temporaries()
218 self.breakpoint_hits = None
220 self.next_set_method()
222 def user_return(self, frame, return_value):
223 self.process_event('return', frame, return_value)
224 self.next_set_method()
226 def user_exception(self, frame, exc_info):
227 self.exc_info = exc_info
228 self.process_event('exception', frame)
229 self.next_set_method()
231 def do_clear(self, arg):
233 bp_list = [self.currentbp]
234 self.breakpoint_hits = (bp_list, bp_list)
236 def delete_temporaries(self):
237 if self.breakpoint_hits:
238 for n in self.breakpoint_hits[1]:
239 self.clear_bpbynumber(n)
241 def pop_next(self):
242 self.expect_set_no += 1
244 self.expect = self.expected_list.pop(0)
248 self.expect_set_no)
249 self.set_tuple = self.set_list.pop(0)
251 def process_event(self, event, frame, *args):
256 tb = self.exc_info[2]
257 self.get_stack(frame, tb)
260 if self.currentbp is not None and not self.breakpoint_hits:
261 bp_list = [self.currentbp]
262 self.breakpoint_hits = (bp_list, [])
265 self.event= event
266 self.pop_next()
267 if self.dry_run:
268 self.print_state(self.header)
272 if self.expect:
273 self.check_equal(self.expect[0], event, 'Wrong event type')
274 self.check_lno_name()
277 self.check_expect_max_size(3)
278 elif len(self.expect) > 3:
280 bps, temporaries = self.expect[3]
282 if not self.breakpoint_hits:
283 self.raise_not_expected(
285 self.expect_set_no)
286 self.check_equal(bpnums, self.breakpoint_hits[0],
288 self.check_equal([bps[n] for n in bpnums],
289 [self.get_bpbynumber(n).hits for
290 n in self.breakpoint_hits[0]],
292 self.check_equal(sorted(temporaries), self.breakpoint_hits[1],
296 if not isinstance(self.exc_info[1], self.expect[3]):
297 self.raise_not_expected(
299 (self.expect_set_no, self.exc_info))
301 def check_equal(self, expected, result, msg):
304 self.raise_not_expected("%s at expect_set item %d, got '%s'" %
305 (msg, self.expect_set_no, result))
307 def check_lno_name(self):
309 s = len(self.expect)
311 lineno = self.lno_abs2rel()
312 self.check_equal(self.expect[1], lineno, 'Wrong line number')
314 self.check_equal(self.expect[2], self.frame.f_code.co_name,
317 def check_expect_max_size(self, size):
318 if len(self.expect) > size:
320 (self.event, self.expect))
322 def lno_abs2rel(self):
323 fname = self.canonic(self.frame.f_code.co_filename)
324 lineno = self.frame.f_lineno
325 return ((lineno - self.frame.f_code.co_firstlineno + 1)
326 if fname == self.canonic(__file__) else lineno)
328 def lno_rel2abs(self, fname, lineno):
329 return (self.frame.f_code.co_firstlineno + lineno - 1
330 if (lineno and self.canonic(fname) == self.canonic(__file__))
333 def get_state(self):
334 lineno = self.lno_abs2rel()
335 co_name = self.frame.f_code.co_name
336 state = "('%s', %d, '%s'" % (self.event, lineno, co_name)
337 if self.breakpoint_hits:
339 for n in self.breakpoint_hits[0]:
342 bps += '%s: %s' % (n, self.get_bpbynumber(n).hits)
344 bps = '(' + bps + ', ' + str(self.breakpoint_hits[1]) + ')'
346 elif self.event == 'exception':
347 state += ', ' + self.exc_info[0].__name__
349 return state.ljust(32) + str(self.set_tuple) + ','
351 def print_state(self, header=None):
352 if header is not None and self.expect_set_no == 1:
355 print('%d: %s' % (self.expect_set_no, self.get_state()))
357 def raise_not_expected(self, msg):
359 msg += ' Expected: %s\n' % str(self.expect)
360 msg += ' Got: ' + self.get_state()
363 def next_set_method(self):
364 set_type = self.set_tuple[0]
365 args = self.set_tuple[1] if len(self.set_tuple) == 2 else None
366 set_method = getattr(self, 'set_' + set_type)
373 set_method(self.frame)
378 lineno = self.lno_rel2abs(self.frame.f_code.co_filename,
380 set_method(self.frame, lineno)
389 lineno = self.lno_rel2abs(fname, lineno)
400 self.event= None
401 self.pop_next()
402 if self.dry_run:
403 self.print_state()
405 if self.expect:
406 self.check_lno_name()
407 self.check_expect_max_size(3)
408 self.next_set_method()
411 self.set_tuple)
416 def __init__(self, test_case, skip=None):
417 self.test_case = test_case
418 self.dry_run = test_case.dry_run
419 self.tracer = Tracer(test_case.expect_set, skip=skip,
420 dry_run=self.dry_run, test_case=test_case.id())
421 self._original_tracer = None
423 def __enter__(self):
426 self._original_tracer = sys.gettrace()
427 return self.tracer
429 def __exit__(self, type_=None, value=None, traceback=None):
431 sys.settrace(self._original_tracer)
434 if self.tracer.set_list:
437 self.tracer.expect_set_no)
445 if self.dry_run:
449 self.test_case.fail(err_msg)
454 if self.dry_run:
457 self.test_case.fail(not_empty)
580 def fail(self, msg=None):
583 raise self.failureException(msg) from None
588 def test_step(self):
589 self.expect_set = [
595 with TracerRun(self) as tracer:
598 def test_step_next_on_last_statement(self):
600 with self.subTest(set_type=set_type):
601 self.expect_set = [
609 with TracerRun(self) as tracer:
612 def test_next(self):
613 self.expect_set = [
620 with TracerRun(self) as tracer:
623 def test_next_over_import(self):
630 self.expect_set = [
634 with TracerRun(self) as tracer:
637 def test_next_on_plain_statement(self):
640 self.expect_set = [
646 with TracerRun(self) as tracer:
649 def test_next_in_caller_frame(self):
652 self.expect_set = [
659 with TracerRun(self) as tracer:
662 def test_return(self):
663 self.expect_set = [
671 with TracerRun(self) as tracer:
674 def test_return_in_caller_frame(self):
675 self.expect_set = [
682 with TracerRun(self) as tracer:
685 def test_until(self):
686 self.expect_set = [
693 with TracerRun(self) as tracer:
696 def test_until_with_too_large_count(self):
697 self.expect_set = [
703 with TracerRun(self) as tracer:
706 def test_until_in_caller_frame(self):
707 self.expect_set = [
714 with TracerRun(self) as tracer:
718 def test_skip(self):
735 self.expect_set = [
740 with TracerRun(self, skip=skip) as tracer:
743 def test_skip_with_no_name_module(self):
748 self.assertIs(bdb.is_skipped_module(None), False)
750 def test_down(self):
752 self.expect_set = [
755 with TracerRun(self) as tracer:
756 self.assertRaises(BdbError, tracer.runcall, tfunc_main)
758 def test_up(self):
759 self.expect_set = [
765 with TracerRun(self) as tracer:
771 def test_bp_on_non_existent_module(self):
772 self.expect_set = [
775 with TracerRun(self) as tracer:
776 self.assertRaises(BdbError, tracer.runcall, tfunc_import)
778 def test_bp_after_last_statement(self):
785 self.expect_set = [
788 with TracerRun(self) as tracer:
789 self.assertRaises(BdbError, tracer.runcall, tfunc_import)
791 def test_temporary_bp(self):
802 self.expect_set = [
811 with TracerRun(self) as tracer:
814 def test_disabled_temporary_bp(self):
825 self.expect_set = [
839 with TracerRun(self) as tracer:
842 def test_bp_condition(self):
853 self.expect_set = [
859 with TracerRun(self) as tracer:
862 def test_bp_exception_on_condition_evaluation(self):
872 self.expect_set = [
878 with TracerRun(self) as tracer:
881 def test_bp_ignore_count(self):
892 self.expect_set = [
899 with TracerRun(self) as tracer:
902 def test_ignore_count_on_disabled_bp(self):
913 self.expect_set = [
926 with TracerRun(self) as tracer:
929 def test_clear_two_bp_on_same_line(self):
941 self.expect_set = [
951 with TracerRun(self) as tracer:
954 def test_clear_at_no_bp(self):
955 self.expect_set = [
958 with TracerRun(self) as tracer:
959 self.assertRaises(BdbError, tracer.runcall, tfunc_import)
961 def test_load_bps_from_previous_Bdb_instance(self):
966 self.assertEqual(db1.get_all_breaks(), {fname: [1]})
972 self.assertEqual(db1.get_all_breaks(), {fname: [1]})
973 self.assertEqual(db2.get_all_breaks(), {fname: [1, 2, 3, 4]})
975 self.assertEqual(db1.get_all_breaks(), {fname: [1]})
976 self.assertEqual(db2.get_all_breaks(), {fname: [2, 3, 4]})
979 self.assertEqual(db1.get_all_breaks(), {fname: [1]})
980 self.assertEqual(db2.get_all_breaks(), {fname: [2, 3, 4]})
981 self.assertEqual(db3.get_all_breaks(), {fname: [2, 3, 4]})
983 self.assertEqual(db1.get_all_breaks(), {fname: [1]})
984 self.assertEqual(db2.get_all_breaks(), {fname: [3, 4]})
985 self.assertEqual(db3.get_all_breaks(), {fname: [2, 3, 4]})
989 self.assertEqual(db1.get_all_breaks(), {fname: [1]})
990 self.assertEqual(db2.get_all_breaks(), {fname: [3, 4]})
991 self.assertEqual(db3.get_all_breaks(), {fname: [2, 3, 4]})
992 self.assertEqual(db4.get_all_breaks(), {fname: [3, 4, 5]})
997 self.assertEqual(db1.get_all_breaks(), {fname: [1]})
998 self.assertEqual(db2.get_all_breaks(), {fname: [3, 4]})
999 self.assertEqual(db3.get_all_breaks(), {fname: [2, 3, 4]})
1000 self.assertEqual(db4.get_all_breaks(), {fname: [3, 4, 5]})
1001 self.assertEqual(db5.get_all_breaks(), {fname: [6]})
1007 def test_run_step(self):
1012 self.expect_set = [
1016 with TracerRun(self) as tracer:
1019 def test_runeval_step(self):
1027 self.expect_set = [
1035 with TracerRun(self) as tracer:
1041 def test_step_at_return_with_no_trace_in_caller(self):
1060 self.expect_set = [
1068 with TracerRun(self) as tracer:
1071 def test_next_until_return_in_generator(self):
1090 with self.subTest(set_type=set_type):
1092 self.expect_set = [
1100 self.expect_set.extend(
1106 self.expect_set.extend(
1109 with TracerRun(self) as tracer:
1112 def test_next_command_in_generator_for_loop(self):
1128 self.expect_set = [
1140 with TracerRun(self) as tracer:
1143 def test_next_command_in_generator_with_subiterator(self):
1161 self.expect_set = [
1171 with TracerRun(self) as tracer:
1174 def test_return_command_in_generator_with_subiterator(self):
1192 self.expect_set = [
1202 with TracerRun(self) as tracer:
1207 def test_format_stack_entry_no_lineno(self):
1209 self.assertIn('Warning: lineno is None',