[poe-commits] poe/tests/10_units/05_filters 01_block.t,1.1,1.2 04_line.t,1.1,1.2 07_reference.t,1.4,1.5 50_stackable.t,1.1,1.2 99_filterchange.t,1.1,1.2

[<rc...@us...>]

Update of /cvsroot/poe/poe/tests/10_units/05_filters
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv15243/tests/10_units/05_filters

Modified Files:
	01_block.t 04_line.t 07_reference.t 50_stackable.t 
	99_filterchange.t 
Log Message:
Deprecate the stinky old TestSetup library in favor of the shiny, and
way newer Test::More.  This finally resolves rt.cpan.org ticket 7558.


Index: 01_block.t
===================================================================
RCS file: /cvsroot/poe/poe/tests/10_units/05_filters/01_block.t,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** 01_block.t	4 Sep 2004 22:50:38 -0000	1.1
--- 01_block.t	28 Jun 2005 06:18:20 -0000	1.2
***************
*** 1,4 ****
--- 1,5 ----
  #!/usr/bin/perl -w
  # $Id$
+ # vim: filetype=perl
  
  # Exercises Filter::Block without the rest of POE.  Suddenly things
***************
*** 8,12 ****
  use lib qw(./mylib ../mylib ../lib ./lib);
  
! use TestSetup;
  
  sub POE::Kernel::ASSERT_DEFAULT () { 1 }
--- 9,13 ----
  use lib qw(./mylib ../mylib ../lib ./lib);
  
! use Test::More tests => 20;
  
  sub POE::Kernel::ASSERT_DEFAULT () { 1 }
***************
*** 14,143 ****
  sub POE::Kernel::TRACE_FILENAME () { "./test-output.err" }
  
! use POE::Filter::Block;
! 
! test_setup(44);
! 
! # Self-congratulatory backpatting.
! print "ok 1\n";
  
  # Test block filter in fixed-length mode.
! { my $filter = new POE::Filter::Block( BlockSize => 4 );
!   my $raw = $filter->put( [ '12345678' ] );
    my $cooked = $filter->get( $raw );
!   if (@$cooked == 2) {
!     print "ok 2\n";
!     print 'not ' unless length($cooked->[0]) == 4;
!     print "ok 3\n";
!     print 'not ' unless length($cooked->[1]) == 4;
!     print "ok 4\n";
!   }
!   else {
!     print "not ok 2\n";
!     print "not ok 3\n";
!     print "not ok 4\n";
!   }
!   $raw = $filter->put( $cooked );
!   if (@$raw == 1) {
!     print "ok 5\n";
!     print 'not ' unless length($raw->[0]) == 8;
!     print "ok 6\n";
!   }
!   else {
!     print "not ok 5\n";
!     print "not ok 6\n";
!   }
  }
  
  # Test block filter with get_one() functions.
! { my $filter = new POE::Filter::Block( BlockSize => 4 );
!   my $raw = $filter->put( [ '12345678' ] );
    $filter->get_one_start( $raw );
    my $cooked = $filter->get_one();
!   if (@$cooked == 1) {
!     print "ok 7\n";
!     print 'not ' unless length($cooked->[0]) == 4;
!     print "ok 8\n";
!   }
!   else {
!     print "not ok 7\n";
!     print "not ok 8\n";
!   }
!   $raw = $filter->put( $cooked );
!   if (@$raw == 1) {
!     print "ok 9\n";
!     print 'not ' unless length($raw->[0]) == 4;
!     print "ok 10\n";
!   }
!   else {
!     print "not ok 9\n";
!     print "not ok 10\n";
!   }
  }
  
  # Test block filter in variable-length mode, without a custom codec.
! { my $filter = new POE::Filter::Block( );
!   my $raw = $filter->put([ 'a', 'bc', 'def', 'ghij' ]);
    my $cooked = $filter->get( $raw );
!   if (@$cooked == 4) {
!     print "ok 11\n";
!     print 'not ' unless $cooked->[0] eq 'a';
!     print "ok 12\n";
!     print 'not ' unless $cooked->[1] eq 'bc';
!     print "ok 13\n";
!     print 'not ' unless $cooked->[2] eq 'def';
!     print "ok 14\n";
!     print 'not ' unless $cooked->[3] eq 'ghij';
!     print "ok 15\n";
!   }
!   else {
!     for (11..15) {
!       print "not ok $_\n";
!     }
!   }
  
    $cooked = $filter->get( [ "1" ] );
!   print 'not ' if @$cooked;
!   print "ok 16\n";
  
    $cooked = $filter->get( [ "0" ] );
!   print 'not ' if @$cooked;
!   print "ok 17\n";
  
    $cooked = $filter->get( [ "\0" ] );
!   print 'not ' if @$cooked;
!   print "ok 18\n";
  
    $cooked = $filter->get( [ "klmno" ] );
!   print 'not ' if @$cooked;
!   print "ok 19\n";
  
    $cooked = $filter->get( [ "pqrst" ] );
!   if (@$cooked == 1) {
!     print "ok 20\n";
!     print 'not ' unless $cooked->[0] eq 'klmnopqrst';
!     print "ok 21\n";
!   }
!   else {
!     print "not ok 20\n";
!     print "not ok 21\n";
!   }
  
    my $raw_two = $filter->put( [ qw(a bc def ghij) ] );
!   if (@$raw_two == 4) {
!     print "ok 22\n";
!     print 'not ' unless $raw_two->[0] eq "1\0a";
!     print "ok 23\n";
!     print 'not ' unless $raw_two->[1] eq "2\0bc";
!     print "ok 24\n";
!     print 'not ' unless $raw_two->[2] eq "3\0def";
!     print "ok 25\n";
!     print 'not ' unless $raw_two->[3] eq "4\0ghij";
!     print "ok 26\n";
!   }
!   else {
!     for (22..26) {
!       print "not ok $_\n";
!     }
!   }
  }
  
--- 15,77 ----
  sub POE::Kernel::TRACE_FILENAME () { "./test-output.err" }
  
! use_ok("POE::Filter::Block");
  
  # Test block filter in fixed-length mode.
! {
!   my $filter = new POE::Filter::Block( BlockSize => 4 );
!   my $raw    = $filter->put( [ "12345678" ] );
! 
    my $cooked = $filter->get( $raw );
!   is_deeply($cooked, [ "1234", "5678" ], "get() parses blocks");
! 
!   my $reraw = $filter->put( $cooked );
!   is_deeply($reraw, [ "12345678" ], "put() serializes blocks");
  }
  
  # Test block filter with get_one() functions.
! {
!   my $filter = new POE::Filter::Block( BlockSize => 4 );
!   my $raw = $filter->put( [ "12345678" ] );
! 
    $filter->get_one_start( $raw );
+ 
    my $cooked = $filter->get_one();
!   is_deeply($cooked, [ "1234" ], "get_one() parsed one block");
! 
!   my $reraw = $filter->put( $cooked );
!   is_deeply($reraw, [ "1234" ], "put() serialized one block");
  }
  
  # Test block filter in variable-length mode, without a custom codec.
! {
!   my $filter = new POE::Filter::Block( );
!   my $raw = $filter->put([ "a", "bc", "def", "ghij" ]);
! 
    my $cooked = $filter->get( $raw );
!   is_deeply(
!     $cooked, [ "a", "bc", "def", "ghij" ],
!     "get() parsed variable blocks"
!   );
  
    $cooked = $filter->get( [ "1" ] );
!   ok(!@$cooked, "get() doesn't return for partial input 1");
  
    $cooked = $filter->get( [ "0" ] );
!   ok(!@$cooked, "get() doesn't return for partial input 0");
  
    $cooked = $filter->get( [ "\0" ] );
!   ok(!@$cooked, "get() doesn't return for partial input end-of-header");
  
    $cooked = $filter->get( [ "klmno" ] );
!   ok(!@$cooked, "get() doesn't return for partial input payload");
  
    $cooked = $filter->get( [ "pqrst" ] );
!   is_deeply($cooked, [ "klmnopqrst" ], "get() returns payload");
  
    my $raw_two = $filter->put( [ qw(a bc def ghij) ] );
!   is_deeply(
!     $raw_two, [ "1\0a", "2\0bc", "3\0def", "4\0ghij" ],
!     "variable length put() serializes multiple blocks"
!   );
  }
  
***************
*** 161,234 ****
      LengthCodec => [ \&encoder, \&decoder ],
    );
!   my $raw = $filter->put([ 'a', 'bc', 'def', 'ghij' ]);
    my $cooked = $filter->get( $raw );
!   if (@$cooked == 4) {
!     print "ok 27\n";
!     print 'not ' unless $cooked->[0] eq 'a';
!     print "ok 28\n";
!     print 'not ' unless $cooked->[1] eq 'bc';
!     print "ok 29\n";
!     print 'not ' unless $cooked->[2] eq 'def';
!     print "ok 30\n";
!     print 'not ' unless $cooked->[3] eq 'ghij';
!     print "ok 31\n";
!   }
!   else {
!     for (27..31) {
!       print "not ok $_\n";
!     }
!   }
  
    $cooked = $filter->get( [ "\x00" ] );
!   print 'not ' if @$cooked;
!   print "ok 32\n";
  
    $cooked = $filter->get( [ "\x00" ] );
!   print 'not ' if @$cooked;
!   print "ok 33\n";
  
    $cooked = $filter->get( [ "\x00" ] );
!   print 'not ' if @$cooked;
!   print "ok 34\n";
  
    $cooked = $filter->get( [ "\x0a" ] );
!   print 'not ' if @$cooked;
!   print "ok 35\n";
  
    $cooked = $filter->get( [ "klmno" ] );
!   print 'not ' if @$cooked;
!   print "ok 36\n";
  
    $cooked = $filter->get( [ "pqrst" ] );
!   if (@$cooked == 1) {
!     print "ok 37\n";
!     print 'not ' unless $cooked->[0] eq 'klmnopqrst';
!     print "ok 38\n";
!   }
!   else {
!     print "not ok 37\n";
!     print "not ok 38\n";
!   }
  
    my $raw_two = $filter->put( [ qw(a bc def ghij) ] );
!   if (@$raw_two == 4) {
!     print "ok 39\n";
!     print 'not ' unless $raw_two->[0] eq "\x00\x00\x00\x01a";
!     print "ok 40\n";
!     print 'not ' unless $raw_two->[1] eq "\x00\x00\x00\x02bc";
!     print "ok 41\n";
!     print 'not ' unless $raw_two->[2] eq "\x00\x00\x00\x03def";
!     print "ok 42\n";
!     print 'not ' unless $raw_two->[3] eq "\x00\x00\x00\x04ghij";
!     print "ok 43\n";
!   }
!   else {
!     for (39..43) {
!       print "not ok $_\n";
!     }
!   }
  }
  
- print "ok 44\n";
- 
  exit;
--- 95,139 ----
      LengthCodec => [ \&encoder, \&decoder ],
    );
! 
!   my $raw = $filter->put([ "a", "bc", "def", "ghij" ]);
! 
    my $cooked = $filter->get( $raw );
!   is_deeply(
!     $cooked, [ "a", "bc", "def", "ghij" ],
!     "customi serializer parsed its own serialized data"
!   );
  
    $cooked = $filter->get( [ "\x00" ] );
!   ok(!@$cooked, "custom serializer did not parse partial header 1/4");
  
    $cooked = $filter->get( [ "\x00" ] );
!   ok(!@$cooked, "custom serializer did not parse partial header 2/4");
  
    $cooked = $filter->get( [ "\x00" ] );
!   ok(!@$cooked, "custom serializer did not parse partial header 3/4");
  
    $cooked = $filter->get( [ "\x0a" ] );
!   ok(!@$cooked, "custom serializer did not parse partial header 4/4");
  
    $cooked = $filter->get( [ "klmno" ] );
!   ok(!@$cooked, "custom serializer did not parse partial payload");
  
    $cooked = $filter->get( [ "pqrst" ] );
!   is_deeply(
!     $cooked, [ "klmnopqrst" ],
!     "custom serializer parsed full payload"
!   );
  
    my $raw_two = $filter->put( [ qw(a bc def ghij) ] );
!   is_deeply(
!     $raw_two, [
!       "\x00\x00\x00\x01a",
!       "\x00\x00\x00\x02bc",
!       "\x00\x00\x00\x03def",
!       "\x00\x00\x00\x04ghij",
!     ],
!     "custom serializer serialized multiple payloads"
!   );
  }
  
  exit;

Index: 04_line.t
===================================================================
RCS file: /cvsroot/poe/poe/tests/10_units/05_filters/04_line.t,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** 04_line.t	4 Sep 2004 22:50:38 -0000	1.1
--- 04_line.t	28 Jun 2005 06:18:20 -0000	1.2
***************
*** 1,4 ****
--- 1,5 ----
  #!/usr/bin/perl -w
  # $Id$
+ # vim: filetype=perl
  
  # Exercises Filter::Line without the rest of POE.
***************
*** 11,119 ****
  sub POE::Kernel::TRACE_FILENAME () { "./test-output.err" }
  
! use POE::Filter::Line;
  
! my ($filter, $received, $sent, $base);
  
! use TestSetup;
! &test_setup(47);
  
! # Self-congratulatory backpatting.
! print "ok 1\n";
  
! # Test the line filter in default mode.
! $base   = 2;
! $filter = POE::Filter::Line->new();
  
! $received = $filter->get( [ "a\x0D", "b\x0A", "c\x0D\x0A", "d\x0A\x0D" ] );
! if (@$received == 4) {
!   print "ok ", $base+0, "\n";
!   $sent = $filter->put( $received );
!   if (@$sent == 4) {
!     print "ok ", $base+1, "\n";
!     print 'not ' unless $sent->[0] eq "a\x0D\x0A"; print "ok ", $base+2, "\n";
!     print 'not ' unless $sent->[1] eq "b\x0D\x0A"; print "ok ", $base+3, "\n";
!     print 'not ' unless $sent->[2] eq "c\x0D\x0A"; print "ok ", $base+4, "\n";
!     print 'not ' unless $sent->[3] eq "d\x0D\x0A"; print "ok ", $base+5, "\n";
!   }
!   else {
!     for (1..5) { print "not ok ", $base+$_, "\n"; }
!   }
! }
! else {
!   for (0..5) { print "not ok ", $base+$_, "\n"; }
  }
  
  # Test the line filter in literal mode.
- $base   = 8;
- $filter = POE::Filter::Line->new( Literal => 'x' );
  
! $received = $filter->get( [ "axa", "bxb", "cxc", "dxd" ] );
! if (@$received == 4) {
!   print "ok ", $base+0, "\n";
!   $sent = $filter->put( $received );
!   if (@$sent == 4) {
!     print "ok ", $base+1, "\n";
!     print 'not ' unless $sent->[0] eq "ax";  print "ok ", $base+2, "\n";
!     print 'not ' unless $sent->[1] eq "abx"; print "ok ", $base+3, "\n";
!     print 'not ' unless $sent->[2] eq "bcx"; print "ok ", $base+4, "\n";
!     print 'not ' unless $sent->[3] eq "cdx"; print "ok ", $base+5, "\n";
!   }
!   else {
!     for (1..5) { print "not ok ", $base+$_, "\n"; }
!   }
! }
! else {
!   for (0..5) { print "not ok ", $base+$_, "\n"; }
  }
  
  # Test the line filter with different input and output literals.
! $base   = 14;
! $filter = POE::Filter::Line->new( InputLiteral  => 'x',
!                                   OutputLiteral => 'y',
!                                 );
  
! $received = $filter->get( [ "axa", "bxb", "cxc", "dxd" ] );
! if (@$received == 4) {
!   print "ok ", $base+0, "\n";
!   $sent = $filter->put( $received );
!   if (@$sent == 4) {
!     print "ok ", $base+1, "\n";
!     print 'not ' unless $sent->[0] eq "ay";  print "ok ", $base+2, "\n";
!     print 'not ' unless $sent->[1] eq "aby"; print "ok ", $base+3, "\n";
!     print 'not ' unless $sent->[2] eq "bcy"; print "ok ", $base+4, "\n";
!     print 'not ' unless $sent->[3] eq "cdy"; print "ok ", $base+5, "\n";
!   }
!   else {
!     for (1..5) { print "not ok ", $base+$_, "\n"; }
!   }
! }
! else {
!   for (0..5) { print "not ok ", $base+$_, "\n"; }
  }
  
  # Test the line filter with an input string regexp and an output
  # literal.
- $base   = 20;
- $filter = POE::Filter::Line->new( InputRegexp   => '[xy]',
-                                   OutputLiteral => '!',
-                                 );
  
! $received = $filter->get( [ "axa", "byb", "cxc", "dyd" ] );
! if (@$received == 4) {
!   print "ok ", $base+0, "\n";
!   $sent = $filter->put( $received );
!   if (@$sent == 4) {
!     print "ok ", $base+1, "\n";
!     print 'not ' unless $sent->[0] eq "a!";  print "ok ", $base+2, "\n";
!     print 'not ' unless $sent->[1] eq "ab!"; print "ok ", $base+3, "\n";
!     print 'not ' unless $sent->[2] eq "bc!"; print "ok ", $base+4, "\n";
!     print 'not ' unless $sent->[3] eq "cd!"; print "ok ", $base+5, "\n";
!   }
!   else {
!     for (1..5) { print "not ok ", $base+$_, "\n"; }
!   }
! }
! else {
!   for (0..5) { print "not ok ", $base+$_, "\n"; }
  }
  
--- 12,95 ----
  sub POE::Kernel::TRACE_FILENAME () { "./test-output.err" }
  
! use Test::More tests => 14;
  
! use_ok("POE::Filter::Line");
  
! # Test the line filter in default mode.
  
! {
!   my $filter = POE::Filter::Line->new();
  
!   my $received = $filter->get( [ "a\x0D", "b\x0A", "c\x0D\x0A", "d\x0A\x0D" ] );
!   is_deeply(
!     $received, [ "a", "b", "c", "d" ],
!     "line serializer stripped newlines on input"
!   );
  
!   my $sent = $filter->put($received);
!   is_deeply(
!     $sent, [ "a\x0D\x0A", "b\x0D\x0A", "c\x0D\x0A", "d\x0D\x0A" ],
!     "line serializer added newlines to output"
!   );
  }
  
  # Test the line filter in literal mode.
  
! {
!   my $filter = POE::Filter::Line->new( Literal => 'x' );
! 
!   my $received = $filter->get( [ "axa", "bxb", "cxc", "dxd" ] );
!   is_deeply(
!     $received, [ "a", "ab", "bc", "cd" ],
!     "literal mode line filter parsed input"
!   );
! 
!   my $sent = $filter->put( $received );
!   is_deeply(
!     $sent, [ "ax", "abx", "bcx", "cdx" ],
!     "literal mode line filter serialized output"
!   );
  }
  
  # Test the line filter with different input and output literals.
! {
!   my $filter = POE::Filter::Line->new(
!     InputLiteral  => 'x',
!     OutputLiteral => 'y',
!   );
  
!   my $received = $filter->get( [ "axa", "bxb", "cxc", "dxd" ] );
!   is_deeply(
!     $received, [ "a", "ab", "bc", "cd" ],
!     "different literals parsed input",
!   );
! 
!   my $sent = $filter->put( $received );
!   is_deeply(
!     $sent, [ "ay", "aby", "bcy", "cdy" ],
!     "different literals serialized output"
!   );
  }
  
  # Test the line filter with an input string regexp and an output
  # literal.
  
! {
!   my $filter = POE::Filter::Line->new(
!     InputRegexp   => '[xy]',
!     OutputLiteral => '!',
!   );
! 
!   my $received = $filter->get( [ "axa", "byb", "cxc", "dyd" ] );
!   is_deeply(
!     $received, [ "a", "ab", "bc", "cd" ],
!     "regexp parser parsed input"
!   );
! 
!   my $sent = $filter->put( $received );
!   is_deeply(
!     $sent, [ "a!", "ab!", "bc!", "cd!" ],
!     "regexp parser serialized output"
!   );
  }
  
***************
*** 121,256 ****
  # literal.
  
! $base = 26;
! my $compiled_regexp = eval "qr/[xy]/" if $] >= 5.005;
  
! if (defined $compiled_regexp) {
!   $filter = POE::Filter::Line->new( InputRegexp   => $compiled_regexp,
!                                     OutputLiteral => '!',
!                                   );
  
!   $received = $filter->get( [ "axa", "byb", "cxc", "dyd" ] );
!   if (@$received == 4) {
!     print "ok ", $base+0, "\n";
!     $sent = $filter->put( $received );
!     if (@$sent == 4) {
!       print "ok ", $base+1, "\n";
!       print 'not ' unless $sent->[0] eq "a!";  print "ok ", $base+2, "\n";
!       print 'not ' unless $sent->[1] eq "ab!"; print "ok ", $base+3, "\n";
!       print 'not ' unless $sent->[2] eq "bc!"; print "ok ", $base+4, "\n";
!       print 'not ' unless $sent->[3] eq "cd!"; print "ok ", $base+5, "\n";
!     }
!     else {
!       for (1..5) { print "not ok ", $base+$_, "\n"; }
!     }
!   }
!   else {
!     for (0..5) { print "not ok ", $base+$_, "\n"; }
!   }
! }
! else {
!   for (0..5) {
!     print( "ok ", $base+$_,
!            " # skipped: Perl $] does not support compiled regexps.\n"
!          );
!   }
  }
  
  # Test newline autodetection.  \x0D\x0A split between lines.
! $base   = 32;
! $filter = POE::Filter::Line->new( InputLiteral  => undef,
!                                   OutputLiteral => '!',
!                                 ); # autodetect
  
! my @received;
! foreach ("a\x0d", "\x0Ab\x0D\x0A", "c\x0A\x0D", "\x0A") {
!   my $local_received = $filter->get( [ $_ ] );
!   if (defined $local_received and @$local_received) {
!     push @received, @$local_received;
    }
- }
- 
- if (@received == 3) {
-   print "ok ", $base+0, "\n";
-   $sent = $filter->put( \@received );
  
!   if (@$sent == 3) {
!     print "ok ", $base+1, "\n";
!     print 'not ' unless $sent->[0] eq "a!";     print "ok ", $base+2, "\n";
!     print 'not ' unless $sent->[1] eq "b!";     print "ok ", $base+3, "\n";
!     print 'not ' unless $sent->[2] eq "c\x0A!"; print "ok ", $base+4, "\n";
!   }
!   else {
!     for (1..4) { print "not ok ", $base+$_, "\n"; }
!   }
! }
! else {
!   for (0..4) { print "not ok ", $base+$_, "\n"; }
  }
  
  # Test newline autodetection.  \x0A\x0D on first line.
! $base   = 37;
! $filter = POE::Filter::Line->new( InputLiteral  => undef,
!                                   OutputLiteral => '!',
!                                 ); # autodetect
  
! undef @received;
! foreach ("a\x0A\x0D", "\x0Db\x0A\x0D", "c\x0D", "\x0A\x0D") {
!   my $local_received = $filter->get( [ $_ ] );
!   if (defined $local_received and @$local_received) {
!     push @received, @$local_received;
    }
- }
- 
- if (@received == 3) {
-   print "ok ", $base+0, "\n";
-   $sent = $filter->put( \@received );
  
!   if (@$sent == 3) {
!     print "ok ", $base+1, "\n";
!     print 'not ' unless $sent->[0] eq "a!";     print "ok ", $base+2, "\n";
!     print 'not ' unless $sent->[1] eq "\x0Db!"; print "ok ", $base+3, "\n";
!     print 'not ' unless $sent->[2] eq "c\x0D!"; print "ok ", $base+4, "\n";
!   }
!   else {
!     for (1..4) { print "not ok ", $base+$_, "\n"; }
!   }
! }
! else {
!   for (0..4) { print "not ok ", $base+$_, "\n"; }
  }
  
  # Test newline autodetection.  \x0A by itself, with suspicion.
! $base   = 42;
! $filter = POE::Filter::Line->new( InputLiteral  => undef,
!                                   OutputLiteral => '!',
!                                 ); # autodetect
  
! undef @received;
! foreach ("a\x0A", "b\x0D\x0A", "c\x0D", "\x0A") {
!   my $local_received = $filter->get( [ $_ ] );
!   if (defined $local_received and @$local_received) {
!     push @received, @$local_received;
    }
- }
- 
- if (@received == 3) {
-   print "ok ", $base+0, "\n";
-   $sent = $filter->put( \@received );
  
!   if (@$sent == 3) {
!     print "ok ", $base+1, "\n";
!     print 'not ' unless $sent->[0] eq "a!";     print "ok ", $base+2, "\n";
!     print 'not ' unless $sent->[1] eq "b\x0D!"; print "ok ", $base+3, "\n";
!     print 'not ' unless $sent->[2] eq "c\x0D!"; print "ok ", $base+4, "\n";
!   }
!   else {
!     for (1..4) { print "not ok ", $base+$_, "\n"; }
!   }
! }
! else {
!   for (0..4) { print "not ok ", $base+$_, "\n"; }
  }
- 
- 
- # And one to grow on!
- print "ok 47\n";
--- 97,188 ----
  # literal.
  
! SKIP: {
!   skip("Perl $] doesn't support qr//", 2) if $] < 5.005;
  
!   my $compiled_regexp = qr/[xy]/;
!   my $filter = POE::Filter::Line->new(
!     InputRegexp   => $compiled_regexp,
!     OutputLiteral => '!',
!   );
  
!   my $received = $filter->get( [ "axa", "byb", "cxc", "dyd" ] );
!   is_deeply(
!     $received, [ "a", "ab", "bc", "cd" ],
!     "compiled regexp parser parsed input"
!   );
! 
!   my $sent = $filter->put( $received );
!   is_deeply(
!     $sent, [ "a!", "ab!", "bc!", "cd!" ],
!     "compiled regexp parser serialized output"
!   );
  }
  
  # Test newline autodetection.  \x0D\x0A split between lines.
! {
!   my $filter = POE::Filter::Line->new(
!     InputLiteral  => undef,
!     OutputLiteral => '!',
!   );
  
!   my @received;
!   foreach ("a\x0d", "\x0Ab\x0D\x0A", "c\x0A\x0D", "\x0A") {
!     my $local_received = $filter->get( [ $_ ] );
!     if (defined $local_received and @$local_received) {
!       push @received, @$local_received;
!     }
    }
  
!   my $sent = $filter->put( \@received );
!   is_deeply(
!     $sent,
!     [ "a!", "b!", "c\x0A!" ],
!     "autodetected MacOS newlines parsed and reserialized",
!   );
  }
  
  # Test newline autodetection.  \x0A\x0D on first line.
! {
!   my $filter = POE::Filter::Line->new(
!     InputLiteral  => undef,
!     OutputLiteral => '!',
!   ); # autodetect
  
!   my @received;
!   foreach ("a\x0A\x0D", "\x0Db\x0A\x0D", "c\x0D", "\x0A\x0D") {
!     my $local_received = $filter->get( [ $_ ] );
!     if (defined $local_received and @$local_received) {
!       push @received, @$local_received;
!     }
    }
  
!   my $sent = $filter->put( \@received );
!   is_deeply(
!     $sent,
!     [ "a!", "\x0Db!", "c\x0D!" ],
!     "autodetected network newline parsed and reserialized"
!   );
  }
  
  # Test newline autodetection.  \x0A by itself, with suspicion.
! {
!   my $filter = POE::Filter::Line->new(
!     InputLiteral  => undef,
!     OutputLiteral => '!',
!   ); # autodetect
  
!   my @received;
!   foreach ("a\x0A", "b\x0D\x0A", "c\x0D", "\x0A") {
!     my $local_received = $filter->get( [ $_ ] );
!     if (defined $local_received and @$local_received) {
!       push @received, @$local_received;
!     }
    }
  
!   my $sent = $filter->put( \@received );
!   is_deeply(
!     $sent,
!     [ "a!", "b\x0D!", "c\x0D!" ],
!     "autodetected Unix newlines parsed and reserialized"
!   );
  }

Index: 07_reference.t
===================================================================
RCS file: /cvsroot/poe/poe/tests/10_units/05_filters/07_reference.t,v
retrieving revision 1.4
retrieving revision 1.5
diff -C2 -d -r1.4 -r1.5
*** 07_reference.t	12 Nov 2004 14:51:53 -0000	1.4
--- 07_reference.t	28 Jun 2005 06:18:20 -0000	1.5
***************
*** 1,4 ****
--- 1,5 ----
  #!/usr/bin/perl -w
  # $Id$
+ # vim: set filetype=perl
  
  # Exercises Filter::Reference without the rest of POE.
***************
*** 11,43 ****
  sub POE::Kernel::TRACE_FILENAME () { "./test-output.err" }
  
  use POE::Filter::Reference;
  use Symbol qw(delete_package);
  
- use TestSetup;
- 
  # Determine whether we can run these tests.
! { local $SIG{__WARN__} = sub { };
    my $reference = eval { POE::Filter::Reference->new(); };
    if (length $@) {
!     &test_setup(
!       0,
!       "Storable, FreezeThaw, or YAML is required for these tests."
!     ) if $@ =~ /requires Storable/;
      $@ =~ s/ at .*$//s;
!     &test_setup(0, $@);
!     exit;
    }
  }
  
  # A trivial, special-case serializer and reconstitutor.
  
  sub MyFreezer::freeze {
    my $thing = shift;
!   if (ref($thing) eq 'SCALAR') {
!     return reverse(join "\0", ref($thing), $$thing);
!   }
!   elsif (ref($thing) eq 'Package') {
!     return reverse(join "\0", ref($thing), @$thing);
!   }
    die;
  }
--- 12,40 ----
  sub POE::Kernel::TRACE_FILENAME () { "./test-output.err" }
  
+ use Test::More;
  use POE::Filter::Reference;
  use Symbol qw(delete_package);
  
  # Determine whether we can run these tests.
! BEGIN: {
!   local $SIG{__WARN__} = sub { };
    my $reference = eval { POE::Filter::Reference->new(); };
    if (length $@) {
!     if ($@ =~ /requires Storable/) {
!       plan skip_all => "These tests require Storable, FreezeThaw, or YAML.";
!     }
      $@ =~ s/ at .*$//s;
!     plan skip_all => $@;
    }
  }
  
+ plan tests => 11;
+ 
  # A trivial, special-case serializer and reconstitutor.
  
  sub MyFreezer::freeze {
    my $thing = shift;
!   return reverse(join "\0", ref($thing), $$thing) if ref($thing) eq 'SCALAR';
!   return reverse(join "\0", ref($thing), @$thing) if ref($thing) eq 'Package';
    die;
  }
***************
*** 50,54 ****
      return \$scalar;
    }
!   elsif ($type eq 'Package') {
      return bless \@stuff, $type;
    }
--- 47,51 ----
      return \$scalar;
    }
!   if ($type eq 'Package') {
      return bless \@stuff, $type;
    }
***************
*** 56,65 ****
  }
  
- # Start our engines.
- &test_setup(109);
- 
  # Run some tests under a certain set of conditions.
  sub test_freeze_and_thaw {
!   my ($test_number, $freezer, $compression) = @_;
  
    my $scalar     = 'this is a test';
--- 53,59 ----
  }
  
  # Run some tests under a certain set of conditions.
  sub test_freeze_and_thaw {
!   my ($freezer, $compression) = @_;
  
    my $scalar     = 'this is a test';
***************
*** 75,134 ****
    };
  
!   if (length $@) {
!     $@ =~ s/[^\n]\n.*$//;
!     &many_not_ok($test_number, $test_number + 9, $@);
!     return;
!   }
! 
!   my $put = $filter->put( [ $scalar_ref, $object_ref ] );
!   my $got = $filter->get( $put );
! 
!   if (@$got == 2) {
!     &ok($test_number);
! 
!     if (ref($got->[0]) eq 'SCALAR') {
!       &ok($test_number + 1);
!       &ok_if($test_number + 2, ${$got->[0]} eq $scalar);
!     }
!     else {
!       &many_not_ok($test_number + 1, $test_number + 2);
      }
  
!     if (ref($got->[1]) eq 'Package') {
!       &ok($test_number + 3);
  
!       if (@{$got->[1]} == 5) {
!         &ok($test_number + 4);
!         &ok_if($test_number + 5, $got->[1]->[0] == 1);
!         &ok_if($test_number + 6, $got->[1]->[1] == 1);
!         &ok_if($test_number + 7, $got->[1]->[2] == 2);
!         &ok_if($test_number + 8, $got->[1]->[3] == 3);
!         &ok_if($test_number + 9, $got->[1]->[4] == 5);
!       }
!       else {
!         &many_not_ok( $test_number + 4, $test_number + 9);
!       }
!     }
!     else {
!       &many_not_ok($test_number + 3, $test_number + 9);
!     }
!   }
!   else {
!     &many_not_ok($test_number, $test_number + 9);
    }
  }
  
  # Test each combination of things.
! &test_freeze_and_thaw(  1, undef,            undef );
! &test_freeze_and_thaw( 11, undef,            9     );
! &test_freeze_and_thaw( 21, 'MyFreezer',      undef );
! &test_freeze_and_thaw( 31, 'MyFreezer',      9     );
! &test_freeze_and_thaw( 41, 'MyOtherFreezer', undef );
! &test_freeze_and_thaw( 51, 'MyOtherFreezer', 9     );
  
  my $freezer = MyOtherFreezer->new();
  
! &test_freeze_and_thaw( 61, $freezer,         undef );
! &test_freeze_and_thaw( 71, $freezer,         9     );
  
  # Test get_pending.
--- 69,102 ----
    };
  
!   SKIP: {
!     if (length $@) {
!       $@ =~ s/[^\n]\n.*$//;
!       skip $@, 1;
      }
  
!     my $put = $filter->put( [ $scalar_ref, $object_ref ] );
!     my $got = $filter->get( $put );
  
!     $freezer = "undefined" unless defined $freezer;
!     is_deeply(
!       $got,
!       [ $scalar_ref, $object_ref ],
!       "$freezer successfully froze and thawed"
!     );
    }
  }
  
  # Test each combination of things.
! test_freeze_and_thaw(undef,            undef);
! test_freeze_and_thaw(undef,            9    );
! test_freeze_and_thaw('MyFreezer',      undef);
! test_freeze_and_thaw('MyFreezer',      9    );
! test_freeze_and_thaw('MyOtherFreezer', undef);
! test_freeze_and_thaw('MyOtherFreezer', 9    );
  
  my $freezer = MyOtherFreezer->new();
  
! test_freeze_and_thaw($freezer,         undef);
! test_freeze_and_thaw($freezer,         9    );
  
  # Test get_pending.
***************
*** 139,154 ****
  my $pending_thing  = $pending_filter->get($pending_filter->get_pending());
  
! &ok_if( 81, @$pending_thing          == 2 );
! &ok_if( 82, @{$pending_thing->[0]}   == 3 );
! &ok_if( 83, @{$pending_thing->[1]}   == 3 );
! 
! &ok_if( 84, $pending_thing->[0]->[0] == 2 );
! &ok_if( 85, $pending_thing->[0]->[1] == 4 );
! &ok_if( 86, $pending_thing->[0]->[2] == 6 );
! 
! &ok_if( 87, $pending_thing->[1]->[0] == 2 );
! &ok_if( 88, $pending_thing->[1]->[1] == 4 );
! &ok_if( 89, $pending_thing->[1]->[2] == 6 );
! 
  
  # Drop MyOtherFreezer from the symbol table.
--- 107,114 ----
  my $pending_thing  = $pending_filter->get($pending_filter->get_pending());
  
! is_deeply(
!   $pending_thing, [ [ 2, 4, 6 ], [ 2, 4, 6 ] ],
!   "filter reports proper pending data"
! );
  
  # Drop MyOtherFreezer from the symbol table.
***************
*** 160,175 ****
  # are not present.
  eval q{
!     sub never_called
!     {
!         return MyOtherFreezer::thaw(MyOtherFreezer::freeze(@_));
!     }
  };
  die if $@;
  
  # Test each combination of things.
! &test_freeze_and_thaw( 90,  'MyOtherFreezer',            undef );
! &test_freeze_and_thaw( 100, 'MyOtherFreezer',            9     );
! 
! &results();
  
  exit;
--- 120,132 ----
  # are not present.
  eval q{
!   sub never_called {
!     return MyOtherFreezer::thaw(MyOtherFreezer::freeze(@_));
!   }
  };
  die if $@;
  
  # Test each combination of things.
! test_freeze_and_thaw('MyOtherFreezer', undef);
! test_freeze_and_thaw('MyOtherFreezer', 9    );
  
  exit;

Index: 50_stackable.t
===================================================================
RCS file: /cvsroot/poe/poe/tests/10_units/05_filters/50_stackable.t,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** 50_stackable.t	4 Sep 2004 22:50:38 -0000	1.1
--- 50_stackable.t	28 Jun 2005 06:18:20 -0000	1.2
***************
*** 1,4 ****
--- 1,5 ----
  #!/usr/bin/perl -w
  # $Id$
+ # vim: filetype=perl
  
  # Exercises Filter::Stack (and friends) without the rest of POE.
***************
*** 17,57 ****
  use POE::Filter::Line;
  
! use TestSetup;
! &test_setup(26);
  
  # Create a filter stack to test.
  
! my $filter_stack = POE::Filter::Stackable->new
!   ( Filters =>
!     [ POE::Filter::Line->new( Literal => "!" ),
  
!       # The next Map filter translates Put data from RecordBlock
!       # (arrayrefs) into scalars for Line.  On the Get side, it just
!       # wraps parens around whatever Line returns.
  
!       POE::Filter::Map->new ( Put => sub { @$_        }, # scalarify puts
!                               Get => sub { "((($_)))" }, # transform gets
!                             ),
!       POE::Filter::Grep->new( Put => sub { 1          }, # always put
!                               Get => sub { /1/        }, # only get /1/
!                             ),
  
!       # RecordBlock puts arrayrefs.  They pass through Grep->Put
!       # without change.  RecordBlock receives whatever-- lines in this
!       # case, but only ones that match /1/ from Grep->Get.
  
!       POE::Filter::RecordBlock->new( BlockSize => 2 ),
!     ]
!   );
  
! &ok_if( 1, defined $filter_stack );
  
  my $block = $filter_stack->get( [ "test one (1)!test two (2)!" ] );
! &ok_unless( 2, @$block );
  
  $block = $filter_stack->get( [ "test three (3)!test four (100)!" ] );
! &ok_if( 3, @$block == 1 );
! &ok_if( 4, $block->[0]->[0] eq '(((test one (1))))' );
! &ok_if( 5, $block->[0]->[1] eq '(((test four (100))))' );
  
  # Make a copy of the block.  Bad things happen when both blocks have
--- 18,60 ----
  use POE::Filter::Line;
  
! use Test::More tests => 22;
  
  # Create a filter stack to test.
  
! my $filter_stack = POE::Filter::Stackable->new(
!   Filters => [
!     POE::Filter::Line->new( Literal => "!" ),
  
!     # The next Map filter translates Put data from RecordBlock
!     # (arrayrefs) into scalars for Line.  On the Get side, it just
!     # wraps parens around whatever Line returns.
  
!     POE::Filter::Map->new(
!       Put => sub { @$_        }, # scalarify puts
!       Get => sub { "((($_)))" }, # transform gets
!     ),
!     POE::Filter::Grep->new(
!       Put => sub { 1          }, # always put
!       Get => sub { /1/        }, # only get /1/
!     ),
  
!     # RecordBlock puts arrayrefs.  They pass through Grep->Put
!     # without change.  RecordBlock receives whatever-- lines in this
!     # case, but only ones that match /1/ from Grep->Get.
  
!     POE::Filter::RecordBlock->new( BlockSize => 2 ),
!   ]
! );
  
! ok(defined($filter_stack), "filter stack created");
  
  my $block = $filter_stack->get( [ "test one (1)!test two (2)!" ] );
! ok(!@$block, "partial get returned nothing");
  
  $block = $filter_stack->get( [ "test three (3)!test four (100)!" ] );
! is_deeply(
!   $block, [ [ "(((test one (1))))", "(((test four (100))))" ] ],
!   "filter stack returned correct data"
! );
  
  # Make a copy of the block.  Bad things happen when both blocks have
***************
*** 59,66 ****
  
  my $stream = $filter_stack->put( [ $block, $block ] );
- &ok_if( 6, @$stream == 4 );
  
! &ok_if( 7, $stream->[0] eq $stream->[2] );
! &ok_if( 8, $stream->[1] eq $stream->[3] );
  
  # Test some of the discrete stackable filters by themselves.
--- 62,74 ----
  
  my $stream = $filter_stack->put( [ $block, $block ] );
  
! is_deeply(
!   $stream,
!   [
!     "(((test one (1))))!", "(((test four (100))))!",
!     "(((test one (1))))!", "(((test four (100))))!",
!   ],
!   "filter stack serialized correct data"
! );
  
  # Test some of the discrete stackable filters by themselves.
***************
*** 74,93 ****
  
  my $map_pending = join '', @{$map->get_pending()};
! &ok_if( 9, $map_pending eq '11235' );
  
- my $map_test_number = 10;
  foreach my $compare (@test_list) {
    my $next = $map->get_one();
! 
!   &ok_if( $map_test_number++,
!           ( defined($next) and
!             (@$next == 1)  and
!             ("((($compare)))" eq $next->[0])
!           )
!         );
  }
  
  my $map_next = $map->get_one();
! &ok_unless( $map_test_number, @$map_next );
  
  # Grep
--- 82,97 ----
  
  my $map_pending = join '', @{$map->get_pending()};
! ok($map_pending eq "11235", "map filter's parser buffer verifies");
  
  foreach my $compare (@test_list) {
    my $next = $map->get_one();
!   is_deeply(
!     $next, [ "((($compare)))" ],
!     "map filter get_one() returns ((($compare)))"
!   );
  }
  
  my $map_next = $map->get_one();
! ok(!@$map_next, "nothing left to get from map filter");
  
  # Grep
***************
*** 97,118 ****
  
  my $grep_pending = join '', @{$grep->get_pending()};
! &ok_if( 16, $grep_pending eq '11235' );
  
- my $grep_test_number = 17;
  foreach my $compare (@test_list) {
    next unless $compare & 1;
- 
    my $next = $grep->get_one();
! 
!   &ok_if( $grep_test_number++,
!           ( defined($next) and
!             (@$next == 1)  and
!             ($compare == $next->[0])
!           )
!         );
  }
  
  my $grep_next = $grep->get_one();
! &ok_unless( $grep_test_number, @$grep_next );
  
  ### Go back and test more of Stackable.
--- 101,114 ----
  
  my $grep_pending = join '', @{$grep->get_pending()};
! ok($grep_pending eq '11235', "grep filter's parser buffer verifies");
  
  foreach my $compare (@test_list) {
    next unless $compare & 1;
    my $next = $grep->get_one();
!   is_deeply($next, [ $compare ], "grep filter get_one() returns [$compare]");
  }
  
  my $grep_next = $grep->get_one();
! ok(!@$grep_next, "nothing left to get from grep filter");
  
  ### Go back and test more of Stackable.
***************
*** 123,140 ****
  my $filters_test = join ' --- ', @filters_should_be;
  
! &ok_if( 22, $filters_test eq $filters_are );
  
! my $filters_also_are  =
!   join ' --- ', map { ref($_) } $filter_stack->filters();
! my $filters_also_test =
!   join ' --- ', map { 'POE::Filter::' . $_ } @filters_should_be;
  
! &ok_if( 23, $filters_also_test eq $filters_also_are );
  
  my $filter_pop = $filter_stack->pop();
! &ok_if( 24, ref($filter_pop) eq 'POE::Filter::RecordBlock' );
  
  my $filter_shift = $filter_stack->shift();
! &ok_if( 25, ref($filter_shift) eq 'POE::Filter::Line' );
  
  $filter_stack->push( $filter_pop );
--- 119,147 ----
  my $filters_test = join ' --- ', @filters_should_be;
  
! ok($filters_test eq $filters_are, "filter types stacked correctly");
  
! my $filters_also_are  = (
!   join ' --- ', map { ref($_) } $filter_stack->filters()
! );
! my $filters_also_test = (
!   join ' --- ', map { 'POE::Filter::' . $_ } @filters_should_be
! );
  
! ok(
!   $filters_also_test eq $filters_also_are,
!   "filters stacked correctly"
! );
  
  my $filter_pop = $filter_stack->pop();
! ok(
!   ref($filter_pop) eq "POE::Filter::RecordBlock",
!   "popped the correct filter"
! );
  
  my $filter_shift = $filter_stack->shift();
! ok(
!   ref($filter_shift) eq 'POE::Filter::Line',
!   "shifted the correct filter"
! );
  
  $filter_stack->push( $filter_pop );
***************
*** 143,149 ****
  my $filters_are_again = join ' --- ', $filter_stack->filter_types();
  
! &ok_if( 26, $filters_test eq $filters_are_again );
! 
! &results;
  
  exit 0;
--- 150,157 ----
  my $filters_are_again = join ' --- ', $filter_stack->filter_types();
  
! ok(
!   $filters_test eq $filters_are_again,
!   "repushed, reshifted filters are in order"
! );
  
  exit 0;

Index: 99_filterchange.t
===================================================================
RCS file: /cvsroot/poe/poe/tests/10_units/05_filters/99_filterchange.t,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** 99_filterchange.t	4 Sep 2004 22:50:38 -0000	1.1
--- 99_filterchange.t	28 Jun 2005 06:18:20 -0000	1.2
***************
*** 1,4 ****
--- 1,5 ----
  #!/usr/bin/perl -w
  # $Id$
+ # vim: filetype=perl
  
  # Exercises filter changing.  A lot of this code comes from Philip
***************
*** 8,12 ****
  use lib qw(./mylib ../mylib ../lib ./lib);
  
! use TestSetup qw(ok not_ok results test_setup ok_if many_not_ok);
  use MyOtherFreezer;
  
--- 9,13 ----
  use lib qw(./mylib ../mylib ../lib ./lib);
  
! use Test::More;
  use MyOtherFreezer;
  
***************
*** 17,24 ****
  sub POE::Kernel::TRACE_FILENAME () { "./test-output.err" }
  
! use POE qw( Wheel::ReadWrite Driver::SysRW
!             Filter::Block Filter::Line Filter::Reference Filter::Stream
!             Pipe::OneWay Pipe::TwoWay
!           );
  
  # Showstopper here.  Try to build a pair of file handles.  This will
--- 18,26 ----
  sub POE::Kernel::TRACE_FILENAME () { "./test-output.err" }
  
! use POE qw(
!   Wheel::ReadWrite Driver::SysRW
!   Filter::Block Filter::Line Filter::Reference Filter::Stream
!   Pipe::OneWay Pipe::TwoWay
! );
  
  # Showstopper here.  Try to build a pair of file handles.  This will
***************
*** 28,39 ****
  
  # Socketpair.  Read and write handles are the same.
! my ($master_read, $master_write, $slave_read, $slave_write) =
!   POE::Pipe::TwoWay->new();
  unless (defined $master_read) {
!   &test_setup(0, "Could not create a pipe in any form.");
  }
  
  # Set up tests, and go.
! &test_setup(55);
  
  ### Skim down to PARTIAL BUFFER TESTS to find the partial buffer
--- 30,42 ----
  
  # Socketpair.  Read and write handles are the same.
! my ($master_read, $master_write, $slave_read, $slave_write) = (
!   POE::Pipe::TwoWay->new()
! );
  unless (defined $master_read) {
!   plan skip_all => "Could not create a pipe in any form."
  }
  
  # Set up tests, and go.
! plan tests => 41;
  
  ### Skim down to PARTIAL BUFFER TESTS to find the partial buffer
***************
*** 67,106 ****
  
  # Script that drives the master session.
! my @master_script =
!   ( DL, # line      -> line
!     'rot13 1 kyriel',
!     DS, # line      -> stream
!     'rot13 2 addi',
!     DS, # stream    -> stream
!     'rot13 3 attyz',
!     DL, # stream    -> line
!     'rot13 4 crimson',
!     DR, # line      -> reference
!     'rot13 5 crysflame',
!     DR, # reference -> reference
!     'rot13 6 dngor',
!     DL, # reference -> line
!     'rot13 7 freeside',
!     DB, # line      -> block
!     'rot13 8 halfjack',
!     DB, # block     -> block
!     'rot13 9 lenzo',
!     DS, # block     -> stream
!     'rot13 10 mendel',
!     DR, # stream    -> reference
!     'rot13 11 purl',
!     DB, # reference -> block
!     'rot13 12 roderick',
!     DR, # block     -> reference
!     'rot13 13 shizukesa',
!     DS, # reference -> stream
!     'rot13 14 simon',
!     DB, # stream    -> block
!     'rot13 15 sky',
!     DL, # o/` and that brings us back to line o/`
!     'rot13 16 stimps',
  
!     'done',
!   );
  
  ### Helpers to wrap payloads in mode-specific envelopes.  Stream and
--- 70,109 ----
  
  # Script that drives the master session.
! my @master_script = (
!   DL, # line      -> line
!   'rot13 1 kyriel',
!   DS, # line      -> stream
!   'rot13 2 addi',
!   DS, # stream    -> stream
!   'rot13 3 attyz',
!   DL, # stream    -> line
!   'rot13 4 crimson',
!   DR, # line      -> reference
!   'rot13 5 crysflame',
!   DR, # reference -> reference
!   'rot13 6 dngor',
!   DL, # reference -> line
!   'rot13 7 freeside',
!   DB, # line      -> block
!   'rot13 8 halfjack',
!   DB, # block     -> block
!   'rot13 9 lenzo',
!   DS, # block     -> stream
!   'rot13 10 mendel',
!   DR, # stream    -> reference
!   'rot13 11 purl',
!   DB, # reference -> block
!   'rot13 12 roderick',
!   DR, # block     -> reference
!   'rot13 13 shizukesa',
!   DS, # reference -> stream
!   'rot13 14 simon',
!   DB, # stream    -> block
!   'rot13 15 sky',
!   DL, # o/` and that brings us back to line o/`
!   'rot13 16 stimps',
  
!   'done',
! );
  
  ### Helpers to wrap payloads in mode-specific envelopes.  Stream and
***************
*** 120,128 ****
  sub unwrap_payload {
    my ($mode, $payload) = @_;
! 
!   if ($mode eq REFERENCE) {
!     $payload = $$payload;
!   }
! 
    return $payload;
  }
--- 123,127 ----
  sub unwrap_payload {
    my ($mode, $payload) = @_;
!   $payload = $$payload if $mode eq REFERENCE;
    return $payload;
  }
***************
*** 134,146 ****
    my $heap = $_[HEAP];
  
!   $heap->{wheel} = POE::Wheel::ReadWrite->new
!     ( InputHandle  => $slave_read,
!       OutputHandle => $slave_write,
!       Filter       => POE::Filter::Line->new(),
!       Driver       => POE::Driver::SysRW->new(),
!       InputEvent   => 'got_input',
!       FlushedEvent => 'got_flush',
!       ErrorEvent   => 'got_error',
!     );
  
    $heap->{current_mode} = LINE;
--- 133,145 ----
    my $heap = $_[HEAP];
  
!   $heap->{wheel} = POE::Wheel::ReadWrite->new(
!     InputHandle  => $slave_read,
!     OutputHandle => $slave_write,
!     Filter       => POE::Filter::Line->new(),
!     Driver       => POE::Driver::SysRW->new(),
!     InputEvent   => 'got_input',
!     FlushedEvent => 'got_flush',
!     ErrorEvent   => 'got_error',
!   );
  
    $heap->{current_mode} = LINE;
***************
*** 157,161 ****
    my ($heap, $input) = @_[HEAP, ARG0];
    my $mode = $heap->{current_mode};
!   $input = &unwrap_payload( $mode, $input );
    DEBUG and warn "S: got $mode input: $input\n";
  
--- 156,160 ----
    my ($heap, $input) = @_[HEAP, ARG0];
    my $mode = $heap->{current_mode};
!   $input = unwrap_payload( $mode, $input );
    DEBUG and warn "S: got $mode input: $input\n";
  
***************
*** 164,186 ****
      my $response = "will $1";
      if ($1 eq LINE) {
!       $heap->{wheel}->put( &wrap_payload( $mode, $response ) );
        $heap->{wheel}->set_filter( POE::Filter::Line->new() );
        $heap->{current_mode} = $1;
      }
      elsif ($1 eq STREAM) {
!       $heap->{wheel}->put( &wrap_payload( $mode, $response ) );
        $heap->{wheel}->set_filter( POE::Filter::Stream->new() );
        $heap->{current_mode} = $1;
      }
      elsif ($1 eq REFERENCE) {
!       $heap->{wheel}->put( &wrap_payload( $mode, $response ) );
!       $heap->{wheel}->set_filter( POE::Filter::Reference->new
!                                   ( 'MyOtherFreezer'
!                                   )
!                                 );
        $heap->{current_mode} = $1;
      }
      elsif ($1 eq BLOCK) {
!       $heap->{wheel}->put( &wrap_payload( $mode, $response ) );
        $heap->{wheel}->set_filter( POE::Filter::Block->new() );
        $heap->{current_mode} = $1;
--- 163,184 ----
      my $response = "will $1";
      if ($1 eq LINE) {
!       $heap->{wheel}->put( wrap_payload( $mode, $response ) );
        $heap->{wheel}->set_filter( POE::Filter::Line->new() );
        $heap->{current_mode} = $1;
      }
      elsif ($1 eq STREAM) {
!       $heap->{wheel}->put( wrap_payload( $mode, $response ) );
        $heap->{wheel}->set_filter( POE::Filter::Stream->new() );
        $heap->{current_mode} = $1;
      }
      elsif ($1 eq REFERENCE) {
!       $heap->{wheel}->put( wrap_payload( $mode, $response ) );
!       $heap->{wheel}->set_filter(
!         POE::Filter::Reference->new('MyOtherFreezer')
!       );
        $heap->{current_mode} = $1;
      }
      elsif ($1 eq BLOCK) {
!       $heap->{wheel}->put( wrap_payload( $mode, $response ) );
        $heap->{wheel}->set_filter( POE::Filter::Block->new() );
        $heap->{current_mode} = $1;
***************
*** 188,192 ****
      # Don't know; don't care; why bother?
      else {
!       $heap->{wheel}->put( &wrap_payload( $mode, "wont $response" ) );
      }
      DEBUG and warn "S: switched to $1 filter\n";
--- 186,190 ----
      # Don't know; don't care; why bother?
      else {
!       $heap->{wheel}->put( wrap_payload( $mode, "wont $response" ) );
      }
      DEBUG and warn "S: switched to $1 filter\n";
***************
*** 198,204 ****
      my ($test_number, $query, $response) = ($1, $2, $2);
      $response =~ tr[a-zA-Z][n-za-mN-ZA-M];
!     $heap->{wheel}->put( &wrap_payload( $mode,
!                                         "rot13 $test_number $query=$response"
!                                       ) );
      return;
    }
--- 196,202 ----
      my ($test_number, $query, $response) = ($1, $2, $2);
      $response =~ tr[a-zA-Z][n-za-mN-ZA-M];
!     $heap->{wheel}->put(
!       wrap_payload( $mode, "rot13 $test_number $query=$response" )
!     );
      return;
    }
***************
*** 207,211 ****
    if ($input eq 'done') {
      DEBUG and warn "S: shutting down upon request\n";
!     $heap->{wheel}->put( &wrap_payload( $mode, 'done' ) );
      $heap->{shutting_down} = 1;
      return;
--- 205,209 ----
    if ($input eq 'done') {
      DEBUG and warn "S: shutting down upon request\n";
!     $heap->{wheel}->put( wrap_payload( $mode, 'done' ) );
      $heap->{shutting_down} = 1;
      return;
***************
*** 217,221 ****
    }
    else {
!     $heap->{wheel}->put( &wrap_payload( $mode, 'oops' ) );
      $heap->{shutting_down} = 1;
    }
--- 215,219 ----
    }
    else {
!     $heap->{wheel}->put( wrap_payload( $mode, 'oops' ) );
      $heap->{shutting_down} = 1;
    }
***************
*** 245,257 ****
    my ($kernel, $heap) = @_[KERNEL, HEAP];
  
!   $heap->{wheel}   = POE::Wheel::ReadWrite->new
!     ( InputHandle  => $master_read,
!       OutputHandle => $master_write,
!       Filter       => POE::Filter::Line->new(),
!       Driver       => POE::Driver::SysRW->new(),
!       InputEvent   => 'got_input',
!       FlushedEvent => 'got_flush',
!       ErrorEvent   => 'got_error',
!     );
  
    $heap->{current_mode}  = LINE;
--- 243,255 ----
    my ($kernel, $heap) = @_[KERNEL, HEAP];
  
!   $heap->{wheel}   = POE::Wheel::ReadWrite->new(
!     InputHandle  => $master_read,
!     OutputHandle => $master_write,
!     Filter       => POE::Filter::Line->new(),
!     Driver       => POE::Driver::SysRW->new(),
!     InputEvent   => 'got_input',
!     FlushedEvent => 'got_flush',
!     ErrorEvent   => 'got_error',
!   );
  
    $heap->{current_mode}  = LINE;
***************
*** 271,275 ****
  
    my $mode = $heap->{current_mode};
!   $input = &unwrap_payload( $mode, $input );
    DEBUG and warn "M: got $mode input: $input\n";
  
--- 269,273 ----
  
    my $mode = $heap->{current_mode};
!   $input = unwrap_payload( $mode, $input );
    DEBUG and warn "M: got $mode input: $input\n";
  
***************
*** 285,292 ****
      }
      elsif ($1 eq REFERENCE) {
!       $heap->{wheel}->set_filter( POE::Filter::Reference->new
!                                   ( 'MyOtherFreezer'
!                                   )
!                                 );
        $heap->{current_mode} = $1;
      }
--- 283,289 ----
      }
      elsif ($1 eq REFERENCE) {
!       $heap->{wheel}->set_filter(
!         POE::Filter::Reference->new('MyOtherFreezer')
!       );
        $heap->{current_mode} = $1;
      }
***************
*** 309,321 ****
      my ($test_number, $query, $response) = ($1, $2, $3);
      $query =~ tr[a-zA-Z][n-za-mN-ZA-M];
!     if ($query eq $response) {
!       &ok($test_number);
!       DEBUG and warn "M: got ok rot13 response\n";
!     }
!     else {
!       &not_ok($test_number);
!       DEBUG and warn "M: got bad rot13 response\n";
!     }
! 
      $kernel->yield( 'do_cmd' );
      return;
--- 306,310 ----
      my ($test_number, $query, $response) = ($1, $2, $3);
      $query =~ tr[a-zA-Z][n-za-mN-ZA-M];
!     ok( $query eq $response, "got rot13 response $response" );
      $kernel->yield( 'do_cmd' );
      return;
***************
*** 333,337 ****
    }
    else {
!     $heap->{wheel}->put( &wrap_payload( $mode, 'oops' ) );
      $heap->{shutting_down} = 1;
    }
--- 322,326 ----
    }
    else {
!     $heap->{wheel}->put( wrap_payload( $mode, 'oops' ) );
      $heap->{shutting_down} = 1;
    }
***************
*** 343,352 ****
    my $script_step = $heap->{script_step}++;
    if ($script_step < @master_script) {
!     DEBUG and
!       warn "M: is sending cmd $script_step: $master_script[$script_step]\n";
!     $heap->{wheel}->put( &wrap_payload( $heap->{current_mode},
!                                         $master_script[$script_step],
!                                       )
!                        );
    }
    else {
--- 332,341 ----
    my $script_step = $heap->{script_step}++;
    if ($script_step < @master_script) {
!     DEBUG and warn(
!       "M: is sending cmd $script_step: $master_script[$script_step]\n"
!     );
!     $heap->{wheel}->put(
!       wrap_payload( $heap->{current_mode}, $master_script[$script_step] )
!     );
    }
    else {
***************
*** 383,408 ****
  # beyond it.  That's okay with handshaking (above), but not here.
  
! my @streamed_script =
!   ( DL, # line      -> line
!     'kyriel',
!     DR, # line      -> reference
!     'coral',
!     DR, # reference -> reference
!     'drforr',
!     DB, # reference -> block
!     'fimmtiu',
!     DB, # block     -> block
!     'sungo',
!     DR, # block     -> reference
!     'dynweb',
!     DL, # reference -> line
!     'sky',
!     DB, # line      -> block
!     'braderuna',
!     DL, # o/` and that brings us back to line o/`
!     'fletch',
  
!     'done',
!   );
  
  sub streamed_start {
--- 372,397 ----
  # beyond it.  That's okay with handshaking (above), but not here.
  
! my @streamed_script = (
!   DL, # line      -> line
!   'kyriel',
!   DR, # line      -> reference
!   'coral',
!   DR, # reference -> reference
!   'drforr',
!   DB, # reference -> block
!   'fimmtiu',
!   DB, # block     -> block
!   'sungo',
!   DR, # block     -> reference
!   'dynweb',
!   DL, # reference -> line
!   'sky',
!   DB, # line      -> block
!   'braderuna',
!   DL, # o/` and that brings us back to line o/`
!   'fletch',
  
!   'done',
! );
  
  sub streamed_start {
***************
*** 412,423 ****
    die $! unless defined $read;
  
!   $heap->{stream} = POE::Wheel::ReadWrite->new
!     ( InputHandle  => $read,
!       OutputHandle => $write,
!       Filter       => POE::Filter::Line->new(),
!       Driver       => POE::Driver::SysRW->new(),
!       InputEvent   => 'got_input',
!       ErrorEvent   => 'got_error',
!     );
  
    # Start in line mode.
--- 401,412 ----
    die $! unless defined $read;
  
!   $heap->{stream} = POE::Wheel::ReadWrite->new(
!     InputHandle  => $read,
!     OutputHandle => $write,
!     Filter       => POE::Filter::Line->new(),
!     Driver       => POE::Driver::SysRW->new(),
!     InputEvent   => 'got_input',
!     ErrorEvent   => 'got_error',
!   );
  
    # Start in line mode.
***************
*** 429,433 ****
  
      # Send whatever it is in the current mode.
!     $heap->{stream}->put( &wrap_payload( $current_mode, $step ) );
  
      # Switch to the next mode if we should.
--- 418,422 ----
  
      # Send whatever it is in the current mode.
!     $heap->{stream}->put( wrap_payload( $current_mode, $step ) );
  
      # Switch to the next mode if we should.
***************
*** 439,446 ****
        }
        elsif ($current_mode eq REFERENCE) {
!         $heap->{stream}->set_output_filter( POE::Filter::Reference->new
!                                             ( 'MyOtherFreezer'
!                                             )
!                                           ),
        }
        elsif ($current_mode eq BLOCK) {
--- 428,434 ----
        }
        elsif ($current_mode eq REFERENCE) {
!         $heap->{stream}->set_output_filter(
!           POE::Filter::Reference->new('MyOtherFreezer')
!         );
        }
        elsif ($current_mode eq BLOCK) {
***************
*** 457,465 ****
    my ($kernel, $heap, $wrapped_input) = @_[KERNEL, HEAP, ARG0];
  
!   my $input = &unwrap_payload( $heap->{current_mode}, $wrapped_input );
  
!   &ok_if( 37 + $heap->{current_step},
!           ($input eq $streamed_script[$heap->{current_step}++])
!         );
  
    if ($input =~ /^do (\S+)/) {
--- 445,454 ----
    my ($kernel, $heap, $wrapped_input) = @_[KERNEL, HEAP, ARG0];
  
!   my $input = unwrap_payload( $heap->{current_mode}, $wrapped_input );
  
!   ok(
!     $input eq $streamed_script[$heap->{current_step}++],
!     "unwrapped payload ($input) matches expectation"
!   );
  
    if ($input =~ /^do (\S+)/) {
***************
*** 470,477 ****
      }
      elsif ($current_mode eq REFERENCE) {
!       $heap->{stream}->set_input_filter( POE::Filter::Reference->new
!                                          ( 'MyOtherFreezer'
!                                          )
!                                        ),
      }
      elsif ($current_mode eq BLOCK) {
--- 459,465 ----
      }
      elsif ($current_mode eq REFERENCE) {
!       $heap->{stream}->set_input_filter(
!         POE::Filter::Reference->new('MyOtherFreezer')
!       );
      }
      elsif ($current_mode eq BLOCK) {
***************
*** 492,534 ****
  
  # Start the slave/server session first.
! POE::Session->create
!   ( inline_states =>
!     { _start    => \&slave_start,
!       _stop     => \&slave_stop,
!       got_input => \&slave_input,
!       got_flush => \&slave_flush,
!       got_error => \&slave_error,
!     }
!   );
  
  # Start the master/client session last.
! POE::Session->create
!   ( inline_states =>
!     { _start    => \&master_start,
!       _stop     => \&master_stop,
!       got_input => \&master_input,
!       got_flush => \&master_flush,
!       got_error => \&master_error,
!       do_cmd    => \&master_do_next_command,
!     }
!   );
  
  ### Streamed filter transition tests.  These are all run together.
  ### The object is to figure out how to unglom things.
  
! POE::Session->create
!   ( inline_states =>
!     { _start    => \&streamed_start,
!       _stop     => sub { }, # placeholder for stricture test
!       got_input => \&streamed_input,
!     }
!   );
  
  # Begin the handshaking and streaming tests.  I think this is an
  # improvement over forking.
  
! $poe_kernel->run();
! 
! &ok(17);
  
  ### PARTIAL BUFFER TESTS.  (1) Create each test filter; (2) stuff each
--- 480,520 ----
  
  # Start the slave/server session first.
! POE::Session->create(
!   inline_states => {
!     _start    => \&slave_start,
!     _stop     => \&slave_stop,
!     got_input => \&slave_input,
!     got_flush => \&slave_flush,
!     got_error => \&slave_error,
!   }
! );
  
  # Start the master/client session last.
! POE::Session->create(
!   inline_states => {
!     _start    => \&master_start,
!     _stop     => \&master_stop,
!     got_input => \&master_input,
!     got_flush => \&master_flush,
!     got_error => \&master_error,
!     do_cmd    => \&master_do_next_command,
!   }
! );
  
  ### Streamed filter transition tests.  These are all run together.
  ### The object is to figure out how to unglom things.
  
! POE::Session->create(
!   inline_states => {
!     _start    => \&streamed_start,
!     _stop     => sub { }, # placeholder for stricture test
!     got_input => \&streamed_input,
!   }
! );
  
  # Begin the handshaking and streaming tests.  I think this is an
  # improvement over forking.
  
! POE::Kernel->run();
  
  ### PARTIAL BUFFER TESTS.  (1) Create each test filter; (2) stuff each
***************
*** 539,610 ****
  
  # Line filter.
! { my $filter = POE::Filter::Line->new();
    my $return = $filter->get( [ "whole line\x0D\x0A", "partial line" ] );
!   if (defined $return) {
!     &ok(18);
!     &ok_if(19, @$return == 1);
!     &ok_if(20, $return->[0] eq 'whole line');
!     my $pending = $filter->get_pending();
!     if (defined $pending) {
!       &ok(21);
!       &ok_if(22, @$pending == 1);
!       &ok_if(23, $pending->[0] eq 'partial line');
!     }
!     else {
!       &many_not_ok(21, 23);
!     }
!   }
!   else {
!     &many_not_ok(18, 23);
!   }
  }
  
  # Block filter.
! { my $filter = POE::Filter::Block->new( BlockSize => 64 );
    my $return = $filter->get( [ pack('A64', "whole block"), "partial block" ] );
!   if (defined $return) {
!     &ok(24);
!     &ok_if(25, @$return == 1);
!     &ok_if(26, $return->[0] eq pack('A64', 'whole block'));
!     my $pending = $filter->get_pending();
!     if (defined $pending) {
!       &ok(27);
!       &ok_if(28, @$pending == 1);
!       &ok_if(29, $pending->[0] eq 'partial block');
!     }
!     else {
!       &many_not_ok(27, 29);
!     }
!   }
!   else {
!     &many_not_ok(24, 29);
!   }
  }
  
  # Reference filter.
! { my $filter = POE::Filter::Line->new();
!   my $return = $filter->get( [ "whole line\x0D\x0A", "partial line" ] );
!   if (defined $return) {
!     &ok(30);
!     &ok_if(31, @$return == 1);
!     &ok_if(32, $return->[0] eq 'whole line');
!     my $pending = $filter->get_pending();
!     if (defined $pending) {
!       &ok(33);
!       &ok_if(34, @$pending == 1);
!       &ok_if(35, $pending->[0] eq 'partial line');
!     }
!     else {
!       &many_not_ok(33, 35);
!     }
!   }
!   else {
!     &many_not_ok(30, 35);
!   }
! }
  
! &ok(36);
  
! &results;
  
  exit;
--- 525,582 ----
  
  # Line filter.
! {
!   my $filter = POE::Filter::Line->new();
    my $return = $filter->get( [ "whole line\x0D\x0A", "partial line" ] );
!   is_deeply(
!     $return, [ "whole line" ],
!     "parsed only whole line from input"
!   );
! 
!   my $pending = $filter->get_pending();
!   is_deeply(
!     $pending, [ "partial line" ],
!     "partial line is waiting in buffer"
!   );
  }
  
  # Block filter.
! {
!   my $filter = POE::Filter::Block->new( BlockSize => 64 );
    my $return = $filter->get( [ pack('A64', "whole block"), "partial block" ] );
!   is_deeply(
!     $return, [ pack("A64", "whole block") ],
!     "parsed only whole block from input"
!   );
! 
!   my $pending = $filter->get_pending();
!   is_deeply(
!     $pending, [ "partial block" ],
!     "partial block is waiting in buffer"
!   );
  }
  
  # Reference filter.
! {
!   my $filter = POE::Filter::Reference->new();
!   my $original_reference = \"whole_reference";
!   my $serialized_reference = $filter->put( [ $original_reference ] );
  
!   my $return = $filter->get(
!     [
!       $serialized_reference->[0], "100\0partial reference"
!     ]
!   );
  
!   is_deeply(
!     $return, [ $original_reference ],
!     "parsed only whole reference from input"
!   );
! 
!   my $pending = $filter->get_pending();
!   is_deeply(
!     $pending, [ "100\0partial reference" ],
!     "partial reference is waiting in buffer"
!   );
! }
  
  exit;