This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
Augment the user filter caching code so that if the user filter returns
[perl5.git] / t / op / incfilter.t
index 9e273c3..97ce37a 100644 (file)
@@ -12,8 +12,9 @@ BEGIN {
     require "test.pl";
 }
 use strict;
+use Filter::Util::Call;
 
-plan(tests => 12);
+plan(tests => 128);
 
 unshift @INC, sub {
     no warnings 'uninitialized';
@@ -23,7 +24,7 @@ unshift @INC, sub {
 my $fh;
 
 open $fh, "<", \'pass("Can return file handles from \@INC");';
-do $fh;
+do $fh or die;
 
 my @origlines = ("# This is a blank line\n",
                 "pass('Can return generators from \@INC');\n",
@@ -37,11 +38,11 @@ sub generator {
     return defined $_ ? 1 : 0;
 };
 
-do \&generator;
+do \&generator or die;
 
 @lines = @origlines;
 # Check that the array dereferencing works ready for the more complex tests:
-do [\&generator];
+do [\&generator] or die;
 
 do [sub {
        my $param = $_[1];
@@ -50,13 +51,125 @@ do [sub {
        return defined $_ ? 1 : 0;
     }, ["pass('Can return generators which take state');\n",
        "pass('And return multiple lines');\n",
-       ]];
+       ]] or die;
    
 
 open $fh, "<", \'fail("File handles and filters work from \@INC");';
 
-do [$fh, sub {s/fail/pass/}];
+do [$fh, sub {s/fail/pass/; return;}] or die;
 
 open $fh, "<", \'fail("File handles and filters with state work from \@INC");';
 
-do [$fh, sub {s/$_[1]/pass/}, 'fail'];
+do [$fh, sub {s/$_[1]/pass/; return;}, 'fail'] or die;
+
+print "# 2 tests with pipes from subprocesses.\n";
+
+open $fh, 'echo pass|' or die $!;
+
+do $fh or die;
+
+open $fh, 'echo fail|' or die $!;
+
+do [$fh, sub {s/$_[1]/pass/; return;}, 'fail'] or die;
+
+sub rot13_filter {
+    filter_add(sub {
+                  my $status = filter_read();
+                  tr/A-Za-z/N-ZA-Mn-za-m/;
+                  $status;
+              })
+}
+
+open $fh, "<", \<<'EOC';
+BEGIN {rot13_filter};
+cnff("This will rot13'ed prepend");
+EOC
+
+do $fh or die;
+
+open $fh, "<", \<<'EOC';
+ORTVA {ebg13_svygre};
+pass("This will rot13'ed twice");
+EOC
+
+do [$fh, sub {tr/A-Za-z/N-ZA-Mn-za-m/; return;}] or die;
+
+my $count = 32;
+sub prepend_rot13_filter {
+    filter_add(sub {
+                  my $previous = $_;
+                  # Filters should append to any existing data in $_
+                  # But (logically) shouldn't filter it twice.
+                  my $test = "fzrt!";
+                  $_ = $test;
+                  my $status = filter_read();
+                  my $got = substr $_, 0, length $test, '';
+                  is $got, $test, "Upstream didn't alter existing data";
+                  tr/A-Za-z/N-ZA-Mn-za-m/;
+                  $_ = $previous . $_;
+                  die "Looping infinitely" unless $count--;
+                  $status;
+              })
+}
+
+open $fh, "<", \<<'EOC';
+ORTVA {cercraq_ebg13_svygre};
+pass("This will rot13'ed twice");
+EOC
+
+do [$fh, sub {tr/A-Za-z/N-ZA-Mn-za-m/; return;}] or die;
+
+# This generates a heck of a lot of oks, but I think it's necessary.
+my $amount = 1;
+sub prepend_block_counting_filter {
+    filter_add(sub {
+                  my $output = $_;
+                  my $count = 256;
+                  while (--$count) {
+                      $_ = '';
+                      my $status = filter_read($amount);
+                      cmp_ok (length $_, '<=', $amount, "block mode works?");
+                      $output .= $_;
+                      if ($status <= 0 or /\n/s) {
+                          $_ = $output;
+                          return $status;
+                      }
+                  }
+                  die "Looping infinitely";
+                         
+              })
+}
+
+open $fh, "<", \<<'EOC';
+BEGIN {prepend_block_counting_filter};
+pass("one by one");
+pass("and again");
+EOC
+
+do [$fh, sub {return;}] or die;
+
+open $fh, "<", \<<'EOC';
+BEGIN {prepend_block_counting_filter};
+pas("SSS make s fast SSS");
+EOC
+
+do [$fh, sub {s/s/ss/gs; s/([\nS])/$1$1$1/gs; return;}] or die;
+
+sub prepend_line_counting_filter {
+    filter_add(sub {
+                  my $output = $_;
+                  $_ = '';
+                  my $status = filter_read();
+                  my $newlines = tr/\n//;
+                  cmp_ok ($newlines, '<=', 1, "1 line at most?");
+                  $_ = $output . $_ if defined $output;
+                  return $status;
+              })
+}
+
+open $fh, "<", \<<'EOC';
+BEGIN {prepend_line_counting_filter};
+pass("You should see this line thrice");
+EOC
+
+do [$fh, sub {$_ .= $_ . $_; return;}] or die;