... which implies that the global variable $shbstatus was not restricted by the use strict call inside the first BEGIN block.

Why not?

strict is block scoped, so its effect stops at the end of the BEGIN block.

The following works:

use strict;
use warnings;


my $shbstatus;


BEGIN {
    $shbstatus = (-f "C:/shb") ? 1 : 0;
}


END {
    $shbstatus  ? print "shb identified\n"
                : print "shb was not identified\n";
}


print "XYZ\n";
print "$shbstatus\n";
[download]

Update: Things happen in the following order:

• use strict; is compiled.
• use strict; is executed. [*]
• use warnings; is compiled.
• use warnings; is executed. [*]
• my $shbstatus; is compiled, which creates $shbstatus.
• BEGIN { ... } is compiled. Closes over $shbstatus [**].
• BEGIN { ... } is executed.
• END { ... } is compiled. Closes over $shbstatus [**].
• print ... is compiled.
• my $shbstatus; is executed, which does nothing.
• print ... is executed.
• END { ... } is executed.

[*] It'll affect the current block (which is the current file) and nested blocks (which includes the BEGIN and END blocks, and sub definitions, loops, etc). It will *not* affect modules used/required by these blocks or subs called by these blocks.

[**] When a sub closes over a variable, it means the variable will be available to the sub (including special subs BEGIN and END) when the sub is executed, even if the variable is no longer in scope. Search for documentation on closures for more detail.

Thanks for the detailed response!

As for your goal, why not do something like:

#! perl

use strict;

my $filename = 'C:/shb';

my $action;
if ( -f $filename ) {
    $action = 'rename';
}
else {
    $action = 'create';
}

END {
    if ($action eq 'rename') {
    }
    else {
    }
}
[download]

If I understand you correctly, the END block can make use of lexical variables defined in the file before the END block itself. This would obviate the need for using a BEGIN block to test for the presence/absence on disk of a given file. It would also mean that I could place use strict; in its customary position.

The following little script should illustrate the point in various ways depending on whether the file present is indeed present and depending on whether the croak call is live or commented-out.

Read more... (1224 Bytes)

Update: While the solution above guarantees that the testing process is (more) non-destructive, it does have one drawback, AFACIT. When the croak occurs earlier in the file, (1) the total number of tests run is reduced by the quantity lying between the croak and the END block and (2) the numbers associated with the tests inside the END block are no longer at the end of the range predicted by the plan.

Revised example:

Read more... (1429 Bytes)

... produces (assuming that present was indeed present at the outset):

1..7
ok 1 - original file no longer present
ok 2 - hidden file present
Trick is false at end.pl line 28
ok 3 - hidden file no longer present
ok 4 - original file once again present
# Looks like you planned 7 tests but only ran 4.
# Looks like your test died just after 4.
[download]

Tests 3 and 4 above are not the third and fourth as you would intuitively predict from eyeballing the file. You become more dependent on the croak message in locating the error within the file.

Thanks!

Jim Keenan

Now, you move from having an issue with understanding how use and BEGIN work to an issue with how Test::More works. Modify your code as such:

unless ( $trick ) {
    SKIP: { skip 3, "About to croak!\n"; }
    croak;
}
else {
    # Do your three other tests here.
}
[download]

You just have to let Test::More know what's going on with regards to your test plan. It's called a plan for a reason.

---

My criteria for good software:

1. Does it work?
2. Can someone else come in, make a change, and be reasonably certain no bugs were introduced?

BEGIN {
    require strict;
    strict->import;
}
...other stuff...
[download]

Not so with perl in which the BEGIN block is intended for code that must be executed before anything else, perl would otherwise select certain code for processing (such as use or require of an external file), earlier than is indicated by its position in the program. The BEGIN block overrides that feature for its contents.

But the first line of code OUTSIDE any BEGIN block will still get executed before the file is opened, e.g.:

#!/usr/bin/perl

use strict;
use warnings;

my $file = '/path/file.dat';
my $exists = ( -e $file );
my $normal = ( -f $file );
$exists and (not $normal) and die "$file is unsuitable for this progra
+m";
my $iocmd = $normal ? "<$file" : ">$file";

# until now we could check the existence of the file
# and how to open it and we did not need BEGIN

open my $fh, $iocmd or die "$!, for $file";
my @content = $normal
    ? <$fh> # only now is the file read in if exists
    :( "I am\n", "the default\n", "contents\n" );
$normal or print $fh @content; # or printed to otherwise
close $fh or die "$!, for $file";

# now both the file and @content contain either tbe
# program default or previously stored content depending on 
# whether the file existed.
[download]