use Test::More qw(no_plan);

ok(test_foo() eq "bar");

sub print_foo_message {
    print "foo";
}
sub test_foo { 
    return "bar";
}
[download]

L-LL-L--L-LL-L--L-LL-L--
-R--R-RR-R--R-RR-R--R-RR
B--B--B--B--B--B--B--B--
H---H---H---H---H---H---
(the triplet paradiddle with high-hat)

Thanks, jeffa. I expected that printing from subroutines will be blamed here. :) But how you will test sub print_foo_message then? Of course, it's too simple, but it is just an example. I'm interested in testing the output, at least, I need to test the fact that something was printed.

--dda

You don't. :) It's just a canned message. Why do you need to test if something was printed? That's not very helpful. Instead test what is about to be printed, before you print it. In fact, you don't need to print anything at all from your test suite (except user interaction messages like "Test this?" and your own debugging when your test has "bugs").

Now, don't get me wrong - what you originally wanted can be done, but do you really want to go there?

use IO::Scalar;
use Test::More qw(no_plan);

my $string;
tie *STDOUT, 'IO::Scalar', \$string;

ok(test_foo() eq 'bar');
ok($string eq 'foo');
$string = '';

ok(test_bar() eq 'baz');
ok($string eq 'bar');
$string = '';

sub test_foo {
   print 'foo';
   return 'bar';
}

sub test_bar {
   print 'bar';
   return 'baz';
}
[download]

No thanks. :)

jeffa

L-LL-L--L-LL-L--L-LL-L--
-R--R-RR-R--R-RR-R--R-RR
B--B--B--B--B--B--B--B--
H---H---H---H---H---H---
(the triplet paradiddle with high-hat)

I've had this hanging around for ages, but I'm not happy with it yet. I should really generalise it into some sort of Test::Filehandle. However it may be of use as a starting point:

#! /usr/bin/perl -w

package Test::Output;
use 5.005;
use strict;
use Sub::Uplevel;
use Test::Builder;
use IO::File;
use Fcntl;
use Symbol qw(qualify_to_ref gensym);
use base qw(Exporter);


use vars qw($VERSION @EXPORT);
$VERSION = '0.01';
@EXPORT = qw(output_is output_isnt output_like output_unlike);


sub _try_as_caller {
    my ($sub, $level) = @_;
    eval { uplevel $level, $sub };
    return $@;
};


my $Last_output;

sub _get_output {
    my ($code, $fh, $level) = @_;
    $fh = qualify_to_ref($fh, caller);
    my $tmp = IO::File->new_tmpfile or die "no tmp file ($!)";
    my $old = gensym;
    *$old = *$fh;
    local *$fh = $tmp;
    my $exception = _try_as_caller($code, $level);
    *$fh = *$old;
    die if $exception;
    seek $tmp, SEEK_SET, 0 or die "could not seek ($!)";
    my $output = '';
    my $n;
    while ($n = read $tmp, $output, 1024, length($output)) {};
    die "could not read ($!)" unless defined($n);
    return($Last_output = $output);
};


sub _test_output {
    my ($method, $code, $expected, $fh, $name) = @_;
    my $builder = Test::Builder->new;
    my $todo = $builder->exported_to;
    local $Test::Builder::Level = 2;
    $builder->$method(_get_output($code, $fh, 6), $expected, $name);
};


sub output_is       (&$*;$) { _test_output('is_eq',  @_) };
sub output_isnt     (&$*;$) { _test_output('isnt_eq',@_) };
sub output_like     (&$*;$) { _test_output('like',   @_) };
sub output_unlike   (&$*;$) { _test_output('unlike', @_) };


sub last { $Last_output };

1;
[download]

Use something like:

  output_is     { hello() } "hello world\n", STDOUT, "hello world";
  output_isnt   { hello() } "goodbye",       STDOUT, "not goodbye";
  output_unlike { hello() } qr/bye/,         STDOUT, "didn't print bye
+";
  output_like   { hello() } qr/hello/,       STDOUT, "printed hello";
  like(Test::Output->last, qr/world/, "... and world");
[download]

(yes, I know,  _get_output sucks ;-)