Use references instead:

use strict;
use warnings;

my @testlist=(\&test1, \&test2);

foreach (@testlist)
        {
    #call test
        $_->();
        }

sub test1 {
    print ("dear user test1 is currently running\n");
    #test1 code
    print "test1...done\n";
}
sub test2 {
    print ("dear user test2 is currently running\n");
    #test2 code
    print "test2...done\n";
}
[download]

I finally used this method, it fit the way I want to run/add/remove my tests.

Thanks for all your replies

dominus has three excellent articles on why "it's stupid to use a variable as a variable name".

My personal preference (and this can be done in just about any context that uses symblic refs) is to use a hash table instead. In your case, it would be something like:

my @tests = (
    { name => 'test1', 
      code => sub { print "this is test 1\n"; },
    },
    { name => 'test2', 
      code => sub { print "this is test 2\n"; },
    },
);
for my $t (@tests)
{
    print "Test $t->{name} is currently running\n";
    $t->{code}();
}
[download]

Another way of handling this situation is to use the line

my @testlist = (\&test1, \&test2);
[download]

{
    no strict 'refs';
    &$_();
}
[download]

for my $test ( qw( test1 test2 ))
{
    next unless my $test_sub = main->can( $test );
    print "Dear user, test $test is currently running.\n";
    $test_sub->();
}
[download]

Isn't this just a sneaky^Wintelligent way to use symbolic references? ;)

-QM
--
Quantum Mechanics: The dreams stuff is made of

Certainly you're still looking up a symbol name in a symbol table, but this is what Perl does internally when you call a subroutine anyway. No, knowing the name of the subroutine at compile-time doesn't allow any real optimization here.

At least this approach gives a bit more safety over calling the symbolic reference directly.

If you're reasonably comfortable with OO, another way to do it is by separating each test out into its own module, instantiating each module as an object, and then calling $obj->run_test() on each. This is actually very similar to my post on Tasks and TaskManagers which I expanded upon a bit in another post the same day.

I use this paradigm to set up tasks which I can really easily mix and match. I can easily whip up a script that calls different sets of tasks - a common example is where I want to call a subset of tasks from my main script so I can just test those tasks. By making each task as independant from one another as is reasonably possible, this becomes really quite trivial.

use strict;
use warnings;

my $test1 = sub  {
    print "test1...done\n";
};

my $test2 = sub  {
    print "test2...done\n";
};

my $testlist = { 1=>$test1,
                 2=>$test2 };

foreach (keys %$testlist) {
    print ("dear user test $_ is currently running\n");
    $testlist->{$_}();
}
[download]