ext/PerlIO-scalar/t/scalar.t

   1 #!./perl
   2
   3 BEGIN {
   4     unless (find PerlIO::Layer 'perlio') {
   5         print "1..0 # Skip: not perlio\n";
   6         exit 0;
   7     }
   8     require Config;
   9     if (($Config::Config{'extensions'} !~ m!\bPerlIO/scalar\b!) ){
  10         print "1..0 # Skip -- Perl configured without PerlIO::scalar module\n";
  11         exit 0;
  12     }
  13 }
  14
  15 use Fcntl qw(SEEK_SET SEEK_CUR SEEK_END); # Not 0, 1, 2 everywhere.
  16
  17 $| = 1;
  18
  19 use Test::More tests => 55;
  20
  21 my $fh;
  22 my $var = "aaa\n";
  23 ok(open($fh,"+<",\$var));
  24
  25 is(<$fh>, $var);
  26
  27 ok(eof($fh));
  28
  29 ok(seek($fh,0,SEEK_SET));
  30 ok(!eof($fh));
  31
  32 ok(print $fh "bbb\n");
  33 is($var, "bbb\n");
  34 $var = "foo\nbar\n";
  35 ok(seek($fh,0,SEEK_SET));
  36 ok(!eof($fh));
  37 is(<$fh>, "foo\n");
  38 ok(close $fh, $!);
  39
  40 # Test that semantics are similar to normal file-based I/O
  41 # Check that ">" clobbers the scalar
  42 $var = "Something";
  43 open $fh, ">", \$var;
  44 is($var, "");
  45 #  Check that file offset set to beginning of scalar
  46 my $off = tell($fh);
  47 is($off, 0);
  48 # Check that writes go where they should and update the offset
  49 $var = "Something";
  50 print $fh "Brea";
  51 $off = tell($fh);
  52 is($off, 4);
  53 is($var, "Breathing");
  54 close $fh;
  55
  56 # Check that ">>" appends to the scalar
  57 $var = "Something ";
  58 open $fh, ">>", \$var;
  59 $off = tell($fh);
  60 is($off, 10);
  61 is($var, "Something ");
  62 #  Check that further writes go to the very end of the scalar
  63 $var .= "else ";
  64 is($var, "Something else ");
  65
  66 $off = tell($fh);
  67 is($off, 10);
  68
  69 print $fh "is here";
  70 is($var, "Something else is here");
  71 close $fh;
  72
  73 # Check that updates to the scalar from elsewhere do not
  74 # cause problems
  75 $var = "line one\nline two\line three\n";
  76 open $fh, "<", \$var;
  77 while (<$fh>) {
  78     $var = "foo";
  79 }
  80 close $fh;
  81 is($var, "foo");
  82
  83 # Check that dup'ing the handle works
  84
  85 $var = '';
  86 open $fh, "+>", \$var;
  87 print $fh "xxx\n";
  88 open $dup,'+<&',$fh;
  89 print $dup "yyy\n";
  90 seek($dup,0,SEEK_SET);
  91 is(<$dup>, "xxx\n");
  92 is(<$dup>, "yyy\n");
  93 close($fh);
  94 close($dup);
  95
  96 open $fh, '<', \42;
  97 is(<$fh>, "42", "reading from non-string scalars");
  98 close $fh;
  99
 100 { package P; sub TIESCALAR {bless{}} sub FETCH { "shazam" } }
 101 tie $p, P; open $fh, '<', \$p;
 102 is(<$fh>, "shazam", "reading from magic scalars");
 103
 104 {
 105     use warnings;
 106     my $warn = 0;
 107     local $SIG{__WARN__} = sub { $warn++ };
 108     open my $fh, '>', \my $scalar;
 109     print $fh "foo";
 110     close $fh;
 111     is($warn, 0, "no warnings when writing to an undefined scalar");
 112 }
 113
 114 {
 115     use warnings;
 116     my $warn = 0;
 117     local $SIG{__WARN__} = sub { $warn++ };
 118     for (1..2) {
 119         open my $fh, '>', \my $scalar;
 120         close $fh;
 121     }
 122     is($warn, 0, "no warnings when reusing a lexical");
 123 }
 124
 125 {
 126     use warnings;
 127     my $warn = 0;
 128     local $SIG{__WARN__} = sub { $warn++ };
 129
 130     my $fetch = 0;
 131     {
 132         package MgUndef;
 133         sub TIESCALAR { bless [] }
 134         sub FETCH { $fetch++; return undef }
 135     }
 136     tie my $scalar, MgUndef;
 137
 138     open my $fh, '<', \$scalar;
 139     close $fh;
 140     is($warn, 0, "no warnings reading a magical undef scalar");
 141     is($fetch, 1, "FETCH only called once");
 142 }
 143
 144 {
 145     use warnings;
 146     my $warn = 0;
 147     local $SIG{__WARN__} = sub { $warn++ };
 148     my $scalar = 3;
 149     undef $scalar;
 150     open my $fh, '<', \$scalar;
 151     close $fh;
 152     is($warn, 0, "no warnings reading an undef, allocated scalar");
 153 }
 154
 155 my $data = "a non-empty PV";
 156 $data = undef;
 157 open(MEM, '<', \$data) or die "Fail: $!\n";
 158 my $x = join '', <MEM>;
 159 is($x, '');
 160
 161 {
 162     # [perl #35929] verify that works with $/ (i.e. test PerlIOScalar_unread)
 163     my $s = <<'EOF';
 164 line A
 165 line B
 166 a third line
 167 EOF
 168     open(F, '<', \$s) or die "Could not open string as a file";
 169     local $/ = "";
 170     my $ln = <F>;
 171     close F;
 172     is($ln, $s, "[perl #35929]");
 173 }
 174
 175 # [perl #40267] PerlIO::scalar doesn't respect readonly-ness
 176 {
 177     ok(!(defined open(F, '>', \undef)), "[perl #40267] - $!");
 178     close F;
 179
 180     my $ro = \43;
 181     ok(!(defined open(F, '>', $ro)), $!);
 182     close F;
 183     # but we can read from it
 184     ok(open(F, '<', $ro), $!);
 185     is(<F>, 43);
 186     close F;
 187 }
 188
 189 {
 190     # Check that we zero fill when needed when seeking,
 191     # and that seeking negative off the string does not do bad things.
 192
 193     my $foo;
 194
 195     ok(open(F, '>', \$foo));
 196
 197     # Seeking forward should zero fill.
 198
 199     ok(seek(F, 50, SEEK_SET));
 200     print F "x";
 201     is(length($foo), 51);
 202     like($foo, qr/^\0{50}x$/);
 203
 204     is(tell(F), 51);
 205     ok(seek(F, 0, SEEK_SET));
 206     is(length($foo), 51);
 207
 208     # Seeking forward again should zero fill but only the new bytes.
 209
 210     ok(seek(F, 100, SEEK_SET));
 211     print F "y";
 212     is(length($foo), 101);
 213     like($foo, qr/^\0{50}x\0{49}y$/);
 214     is(tell(F), 101);
 215
 216     # Seeking back and writing should not zero fill.
 217
 218     ok(seek(F, 75, SEEK_SET));
 219     print F "z";
 220     is(length($foo), 101);
 221     like($foo, qr/^\0{50}x\0{24}z\0{24}y$/);
 222     is(tell(F), 76);
 223
 224     # Seeking negative should not do funny business.
 225
 226     ok(!seek(F,  -50, SEEK_SET), $!);
 227     ok(seek(F, 0, SEEK_SET));
 228     ok(!seek(F,  -50, SEEK_CUR), $!);
 229     ok(!seek(F, -150, SEEK_END), $!);
 230 }
 231