[perl #122695] Fix line number for else{foo}
[perl.git] / lib / DB.t
1 #!./perl -Tw
2
3 BEGIN {
4         chdir 't' if -d 't';
5         @INC = '../lib';
6         require Config;
7         if (($Config::Config{'extensions'} !~ m!\bList/Util\b!) ){
8                 print "1..0 # Skip -- Perl configured without List::Util module\n";
9                 exit 0;
10         }
11 }
12
13 # symbolic references used later
14 use strict qw( vars subs );
15
16 # @DB::dbline values have both integer and string components (Benjamin Goldberg)
17 use Scalar::Util qw( dualvar );
18 my $dualfalse = dualvar(0, 'false');
19 my $dualtrue = dualvar(1, 'true');
20
21 use Test::More tests => 106;
22
23 # must happen at compile time for DB:: package variable localizations to work
24 BEGIN {
25         use_ok( 'DB' );
26 }
27
28 # test DB::sub()
29 {
30         my $callflag = 0;
31         local $DB::sub = sub {
32                 $callflag += shift || 1;
33                 my @vals = (1, 4, 9);
34                 return @vals;
35         };
36         my $ret = DB::sub;
37         is( $ret, 3, 'DB::sub() should handle scalar context' );
38         is( $callflag, 1, '... should call $DB::sub contents' );
39         $ret = join(' ', DB::sub(2));
40         is( $ret, '1 4 9', '... should handle scalar context' );
41         is( $callflag, 3, '... should pass along arguments to the sub' );
42         ok( defined($DB::ret),'$DB::ret should be defined after successful return');
43         DB::sub;
44         ok( !defined($DB::ret), '... should respect void context' );
45         $DB::sub = '::DESTROY';
46         ok( !defined($DB::ret), '... should return undef for DESTROY()' );
47 }
48
49 # test DB::DB()
50
51         ok( ! defined DB::DB(), 
52                 'DB::DB() should return undef if $DB::ready is false');
53         is( DB::catch(), 1, 'DB::catch() should work' );
54         is( DB->skippkg('foo'), 1, 'DB->skippkg() should push args' );
55
56         # change packages to mess with caller()
57         package foo;
58         ::ok( ! defined DB::DB(), 'DB::DB() should skip skippable packages' );
59
60         package main;
61         is( $DB::filename, $0, '... should set $DB::filename' );
62         is( $DB::lineno, __LINE__ - 4, '... should set $DB::lineno' );
63
64         DB::DB();
65         # stops at line 94
66 }
67
68 # test DB::save()
69 {
70        no warnings 'uninitialized';
71
72         # assigning a number to $! seems to produce an error message, when read
73         local ($@, $,, $/, $\, $^W, $!) = (1 .. 5);
74         DB::save();
75         is( "$@$!$,$/$\$^W", "1\n0", 'DB::save() should reset punctuation vars' );
76 }
77
78 # test DB::catch()
79 {
80         local $DB::signal;
81         DB::catch();
82         ok( $DB::signal, 'DB::catch() should set $DB::signal' );
83         # add clients and test to see if they are awakened
84 }
85
86 # test DB::_clientname()
87 is( DB::_clientname('foo=A(1)'), 'foo',
88     'DB::_clientname should return refname');
89 is( DB::_clientname('bar'), undef,
90         'DB::_clientname should not return non refname');
91
92 # test DB::next() and DB::step()
93 {
94         local $DB::single;
95         DB->next();
96         is( $DB::single, 2, 'DB->next() should set $DB::single to 2' );
97         DB->step();
98         is( $DB::single, 1, 'DB->step() should set $DB::single to 1' );
99 }
100
101 # test DB::cont()
102 {
103         # cannot test @stack
104
105         local $DB::single = 1;
106         my $fdb = FakeDB->new();
107         DB::cont($fdb, 2);
108         is( $fdb->{tbreak}, 2, 'DB::cont() should set tbreak in object' );
109         is( $DB::single, 0, '... should set $DB::single to 0' );
110 }
111
112 # test DB::ret()
113 {
114         # cannot test @stack
115
116         local $DB::single = 1;
117         DB::ret();
118         is( $DB::single, 0, 'DB::ret() should set $DB::single to 0' );
119 }
120
121 # test DB::backtrace()
122 {
123         local (@DB::args, $DB::signal);
124
125         my $line = __LINE__ + 1;
126         my @ret = eval { DB->backtrace() };
127         like( $ret[0], qr/file.+\Q$0\E/, 'DB::backtrace() should report current file');
128         like( $ret[0], qr/line $line/, '... should report calling line number' );
129         like( $ret[0], qr/eval\Q {...}/, '... should catch eval BLOCK' );
130
131         @ret = eval "one(2)";
132         is( scalar @ret, 1, '... should report from provided stack frame number' );
133         like( $ret[0], qr/\@ = &eval \'one.+?2\)\'/, #'
134                 '... should find eval STRING construct');
135         $ret[0] = check_context(1);
136         like( $ret[0], qr/\$ = &main::check_context/, 
137                 '... should respect context of calling construct');
138         
139         $DB::signal = 1;
140         @DB::args = (1, 7);
141         @ret = three(1);
142         is( scalar @ret, 1, '... should end loop if $DB::signal is true' );
143
144         # does not check 'require' or @DB::args mangling
145 }
146
147 sub check_context {
148         return (eval "one($_[0])")[-1];
149 }
150 sub one { DB->backtrace(@_) }
151 sub two { one(@_) }
152 sub three { two(@_) }
153
154 # test DB::trace_toggle
155 {
156         local $DB::trace = 0;
157         DB->trace_toggle;
158         ok( $DB::trace, 'DB::trace_toggle() should toggle $DB::trace' );
159         DB->trace_toggle;
160         ok( !$DB::trace, '... should toggle $DB::trace (back)' );
161 }
162
163 # test DB::subs()
164 {
165         local %DB::sub;
166         my $subs = DB->subs;
167         is( $subs, 0, 'DB::subs() should return keys of %DB::subs' );
168         %DB::sub = ( foo => 'foo:23-45' , bar => 'ba:r:7-890' );
169         $subs = DB->subs;
170         is( $subs, 2, '... same song, different key' );
171         my @subs = DB->subs( 'foo', 'boo', 'bar' );
172         is( scalar @subs, 2, '... should report only for requested subs' );
173         my @expected = ( [ 'foo', 23, 45 ], [ 'ba:r', 7, 890 ] );
174         ok( eq_array( \@subs, \@expected ), '... find file, start, end for subs' );
175 }
176
177 # test DB::filesubs()
178 {
179         local ($DB::filename, %DB::sub);
180         $DB::filename = 'baz';
181         %DB::sub = map { $_ => $_ } qw( bazbar bazboo boobar booboo boobaz );
182         my @ret = DB->filesubs();
183         is( scalar @ret, 2, 'DB::filesubs() should use $DB::filename with no args');
184         @ret = grep { /^baz/ } @ret;    
185         is( scalar @ret, 2, '... should pick up subs in proper file' );
186         @ret = DB->filesubs('boo');
187         is( scalar @ret, 3, '... should use argument to find subs' );
188         @ret = grep { /^boo/ } @ret;    
189         is( scalar @ret, 3, '... should pick up subs in proper file with argument');
190 }
191
192 # test DB::files()
193 {
194         my $dbf = () = DB::files();
195         my $main = () = grep ( m!^_<!, keys %main:: );
196         is( $dbf, $main, 'DB::files() should pick up filenames from %main::' );
197 }
198
199 # test DB::lines()
200 {
201         local @DB::dbline = ( 'foo' );
202         is( DB->lines->[0], 'foo', 'DB::lines() should return ref to @DB::dbline' );
203 }
204
205 # test DB::loadfile()
206 SKIP: {
207         local (*DB::dbline, $DB::filename);
208         ok( ! defined DB->loadfile('notafile'),
209                 'DB::loadfile() should not find unloaded file' );
210         my $file = (grep { m|^_<.+\.pm| } keys %main:: )[0];
211         skip('cannot find loaded file', 3) unless $file;
212         $file =~ s/^_<..//;
213
214         my $db = DB->loadfile($file);
215         like( $db, qr!$file\z!, '... should find loaded file from partial name');
216
217         is( *DB::dbline, *{ "_<$db" } , 
218                 '... should set *DB::dbline to associated glob');
219         is( $DB::filename, $db, '... should set $DB::filename to file name' );
220
221         # test clients
222 }
223
224 # test DB::lineevents()
225 {
226         use vars qw( *baz );
227
228         local $DB::filename = 'baz';
229         local *baz = *{ "main::_<baz" };
230         
231         @baz = map { dualvar(1, $_) } qw( one two three four five );
232         %baz = (
233                 1 => "foo\0bar",
234                 3 => "boo\0far",
235                 4 => "fazbaz",
236         );
237         my %ret = DB->lineevents();
238         is( scalar keys %ret, 3, 'DB::lineevents() should pick up defined lines' );
239
240         # array access in DB::lineevents() starts at element 1, not 0
241         is( join(' ', @{ $ret{1} }), 'two foo bar', '... should stash data in hash');
242 }
243
244 # test DB::set_break()
245 {
246         local ($DB::lineno, *DB::dbline, $DB::package);
247
248         %DB::dbline = (
249                 1 => "\0",
250                 2 => undef,
251                 3 => "123\0\0\0abc",
252                 4 => "\0abc",
253         );
254
255         *DB::dbline = [ $dualfalse, $dualtrue, $dualfalse, $dualfalse, $dualtrue ];
256
257         local %DB::sub = (
258                 'main::foo'     => 'foo:1-4',
259         );
260          
261         DB->set_break(1, 'foo');
262         is( $DB::dbline{1}, "foo\0", 'DB::set_break() should set break condition' );
263
264         $DB::lineno = 1;
265         DB->set_break(undef, 'bar');
266         is( $DB::dbline{1}, "bar\0", 
267                 '... should use $DB::lineno without specified line' );
268
269         DB->set_break(4);
270         is( $DB::dbline{4}, "1\0abc", '... should use default condition if needed');
271
272         local %DB::sub = (
273                 'main::foo'     => 'foo:1-4',
274         );
275         DB->set_break('foo', 'baz');
276         is( $DB::dbline{4}, "baz\0abc", 
277                 '... should use _find_subline() to resolve subname' );
278
279         my $db = FakeDB->new();
280         DB::set_break($db, 2);
281         like( $db->{output}, qr/2 not break/, '... should respect @DB::dbline' );
282
283         DB::set_break($db, 'nonfoo');
284         like( $db->{output}, qr/not found/, '... should warn on unfound sub' );
285 }
286
287 # test DB::set_tbreak()
288 {
289         local ($DB::lineno, *DB::dbline, $DB::package);
290         *DB::dbline = [ $dualfalse, $dualtrue, $dualfalse, $dualfalse, $dualtrue ];
291
292         DB->set_tbreak(1);
293         is( $DB::dbline{1}, ';9', 'DB::set_tbreak() should set tbreak condition' );
294
295         local %DB::sub = (
296                 'main::foo'     => 'foo:1-4',
297         );
298         DB->set_tbreak('foo', 'baz');
299         is( $DB::dbline{4}, ';9', 
300                 '... should use _find_subline() to resolve subname' );
301
302         my $db = FakeDB->new();
303         DB::set_tbreak($db, 2);
304         like( $db->{output}, qr/2 not break/, '... should respect @DB::dbline' );
305
306         DB::set_break($db, 'nonfoo');
307         like( $db->{output}, qr/not found/, '... should warn on unfound sub' );
308 }
309
310 # test DB::_find_subline()
311 {
312         my @foo;
313         local *{ "::_<foo" } = \@foo;
314
315         local $DB::package;
316         local %DB::sub = (
317                 'TEST::foo'     => 'foo:10-15',
318                 'main::foo'     => 'foo:11-12',
319                 'bar::bar'      => 'foo:10-16',
320         );
321
322         $foo[11] = $dualtrue;
323
324         is( DB::_find_subline('TEST::foo'), 11, 
325                 'DB::_find_subline() should find fully qualified sub' );
326         is( DB::_find_subline("TEST'foo"), 11, '... should handle old package sep');
327         is( DB::_find_subline('foo'), 11, 
328                 '... should resolve unqualified package name to main::' );
329
330         $DB::package = 'bar';
331         is( DB::_find_subline('bar'), 11, 
332                 '... should resolve unqualified name with $DB::package, if defined' );
333         
334         $foo[11] = $dualfalse;
335
336         is( DB::_find_subline('TEST::foo'), 15, 
337                 '... should increment past lines with no events' );
338                 
339         ok( ! defined DB::_find_subline('sirnotappearinginthisfilm'),
340                 '... should not find nonexistant sub' );
341 }
342
343 # test DB::clr_breaks()
344 {
345         local *DB::dbline;
346         my %lines = (
347                 1 => "\0",
348                 2 => undef,
349                 3 => "123\0\0\0abc",
350                 4 => "\0\0\0abc",
351         );
352
353         %DB::dbline = %lines;
354         DB->clr_breaks(1 .. 4);
355         is( scalar keys %DB::dbline, 3, 'DB::clr_breaks() should clear breaks' );
356         ok( ! exists($DB::dbline{1}), '... should delete empty actions' );
357         is( $DB::dbline{3}, "\0\0\0abc", '... should remove break, leaving action');
358         is( $DB::dbline{4}, "\0\0\0abc", '... should not remove set actions' );
359
360         local *{ "::_<foo" } = [ 0, 0, 0, 1 ];
361
362         local $DB::package;
363         local %DB::sub = (
364                 'main::foo'     => 'foo:1-3',
365         );
366
367         %DB::dbline = %lines;
368         DB->clr_breaks('foo');
369
370         is( $DB::dbline{3}, "\0\0\0abc", 
371                 '... should find lines via _find_subline()' );
372         
373         my $db = FakeDB->new();
374         DB::clr_breaks($db, 'abadsubname');
375         is( $db->{output}, "Subroutine not found.\n", 
376                 '... should output warning if sub cannot be found');
377
378         @DB::dbline = (1 .. 4);
379         %DB::dbline = (%lines, 5 => "\0" );
380
381         DB::clr_breaks();
382
383         is( scalar keys %DB::dbline, 4, 
384                 'Relying on @DB::dbline in DB::clr_breaks() should clear breaks' );
385         ok( ! exists($DB::dbline{1}), '... should delete empty actions' );
386         is( $DB::dbline{3}, "\0\0\0abc", '... should remove break, leaving action');
387         is( $DB::dbline{4}, "\0\0\0abc", '... should not remove set actions' );
388         ok( exists($DB::dbline{5}), 
389                 '... should only go to last index of @DB::dbline' );
390 }
391
392 # test DB::set_action()
393 {
394         local *DB::dbline;
395
396         %DB::dbline = (
397                 2 => "\0abc",
398         );
399
400         *DB::dbline = [ $dualfalse, $dualfalse, $dualtrue, $dualtrue ];
401
402         DB->set_action(2, 'def');
403         is( $DB::dbline{2}, "\0def", 
404                 'DB::set_action() should replace existing action' );
405         DB->set_action(3, '');
406         is( $DB::dbline{3}, "\0", '... should set new action' );
407
408         my $db = FakeDB->new();
409         DB::set_action($db, 'abadsubname');
410         is( $db->{output}, "Subroutine not found.\n", 
411                 '... should output warning if sub cannot be found');
412
413         DB::set_action($db, 1);
414         like( $db->{output}, qr/1 not action/, 
415                 '... should warn if line cannot be actionivated' );
416 }
417
418 # test DB::clr_actions()
419 {
420         local *DB::dbline;
421         my %lines = (
422                 1 => "\0",
423                 2 => undef,
424                 3 => "123\0abc",
425                 4 => "abc\0",
426         );
427
428         %DB::dbline = %lines;
429         *DB::dbline = [ ($dualtrue) x 4 ];
430
431         DB->clr_actions(1 .. 4);
432
433         is( scalar keys %DB::dbline, 2, 'DB::clr_actions() should clear actions' );
434         ok( ! exists($DB::dbline{1}), '... should delete empty actions' );
435         is( $DB::dbline{3}, "123", '... should remove action, leaving break');
436         is( $DB::dbline{4}, "abc\0", '... should not remove set breaks' );
437
438         local *{ "::_<foo" } = [ 0, 0, 0, 1 ];
439
440         local $DB::package;
441         local %DB::sub = (
442                 'main::foo'     => 'foo:1-3',
443         );
444
445         %DB::dbline = %lines;
446         DB->clr_actions('foo');
447
448         is( $DB::dbline{3}, "123", '... should find lines via _find_subline()' );
449         
450         my $db = FakeDB->new();
451         DB::clr_actions($db, 'abadsubname');
452         is( $db->{output}, "Subroutine not found.\n", 
453                 '... should output warning if sub cannot be found');
454
455         @DB::dbline = (1 .. 4);
456         %DB::dbline = (%lines, 5 => "\0" );
457
458         DB::clr_actions();
459
460         is( scalar keys %DB::dbline, 4, 
461                 'Relying on @DB::dbline in DB::clr_actions() should clear actions' );
462         ok( ! exists($DB::dbline{1}), '... should delete empty actions' );
463         is( $DB::dbline{3}, "123", '... should remove action, leaving break');
464         is( $DB::dbline{4}, "abc\0", '... should not remove set breaks' );
465         ok( exists($DB::dbline{5}), 
466                 '... should only go to last index of @DB::dbline' );
467 }
468
469 # test DB::prestop()
470 ok( ! defined DB::prestop('test'),
471         'DB::prestop() should return undef for undef value' );
472 DB::prestop('test', 897);
473 is( DB::prestop('test'), 897, '... should return value when set' );
474
475 # test DB::poststop(), not exactly parallel
476 ok( ! defined DB::poststop('tset'), 
477         'DB::prestop() should return undef for undef value' );
478 DB::poststop('tset', 987);
479 is( DB::poststop('tset'), 987, '... should return value when set' );
480
481 # test DB::evalcode()
482 ok( ! defined DB::evalcode('foo'),
483         'DB::evalcode() should return undef for undef value' );
484
485 DB::evalcode('foo', 'bar');
486 is( DB::evalcode('foo'), 'bar', '... should return value when set' );
487
488 # test DB::_outputall(), must create fake clients first
489 ok( DB::register( FakeDB->new() ), 'DB::register() should work' );
490 DB::register( FakeDB->new() ) for ( 1 .. 2);
491
492 DB::_outputall(1, 2, 3);
493 is( $FakeDB::output, '123123123', 
494         'DB::_outputall() should call output(@_) on all clients' );
495
496 # test virtual methods
497 for my $method (qw( cprestop cpoststop awaken init stop idle cleanup output )) {
498         ok( defined &{ "DB::$method" }, "DB::$method() should be defined" );
499 }
500
501 # DB::skippkg() uses lexical
502 # DB::ready() uses lexical
503
504 package FakeDB;
505
506 use vars qw( $output );
507
508 sub new {
509         bless({}, $_[0]);
510 }
511
512 sub set_tbreak {
513         my ($self, $val) = @_;
514         $self->{tbreak} = $val;
515 }
516
517 sub output {
518         my $self = shift;
519         if (ref $self) {
520                 $self->{output} = join('', @_);
521         } else {
522                 $output .= join('', @_);
523         }
524 }