my $bas_tests = 20;
# number of tests in section 3
-my $bug_tests = 4 + 3 * 3 * 5 * 2 * 3 + 2 + 1 + 1;
+my $bug_tests = 8 + 3 * 3 * 5 * 2 * 3 + 2 + 66 + 4 + 2 + 3 + 96 + 5;
# number of tests in section 4
my $hmb_tests = 35;
.
open(OUT, '>Op_write.tmp') || die "Can't create Op_write.tmp";
-END { 1 while unlink 'Op_write.tmp' }
+END { unlink_all 'Op_write.tmp' }
$fox = 'foxiness';
$good = 'good';
of huma...
now is the time for all good men to come to\n";
-is cat('Op_write.tmp'), $right and do { 1 while unlink 'Op_write.tmp'; };
+is cat('Op_write.tmp'), $right and unlink_all 'Op_write.tmp';
$fox = 'wolfishness';
my $fox = 'foxiness'; # Test a lexical variable.
necessary
now is the time for all good men to come to\n";
-is cat('Op_write.tmp'), $right and do { 1 while unlink 'Op_write.tmp'; };
+is cat('Op_write.tmp'), $right and unlink_all 'Op_write.tmp';
eval <<'EOFORMAT';
format OUT2 =
necessary
now is the time for all good men to come to\n";
-is cat('Op_write.tmp'), $right and do { 1 while unlink 'Op_write.tmp' };
+is cat('Op_write.tmp'), $right and unlink_all 'Op_write.tmp';
# formline tests
$right =
"fit\n";
-is cat('Op_write.tmp'), $right and do { 1 while unlink 'Op_write.tmp' };
+is cat('Op_write.tmp'), $right and unlink_all 'Op_write.tmp';
# test lexicals and globals
open OUT4, ">Op_write.tmp" or die "Can't create Op_write.tmp";
write (OUT4);
close OUT4 or die "Could not close: $!";
-is cat('Op_write.tmp'), "1\n" and do { 1 while unlink "Op_write.tmp" };
+is cat('Op_write.tmp'), "1\n" and unlink_all "Op_write.tmp";
eval <<'EOFORMAT';
format OUT10 =
close OUT10 or die "Could not close: $!";
$right = " 12.95 00012.95\n";
-is cat('Op_write.tmp'), $right and do { 1 while unlink 'Op_write.tmp' };
+is cat('Op_write.tmp'), $right and unlink_all 'Op_write.tmp';
eval <<'EOFORMAT';
format OUT11 =
"00012.95
1 0#
10 #\n";
-is cat('Op_write.tmp'), $right and do { 1 while unlink 'Op_write.tmp' };
+is cat('Op_write.tmp'), $right and unlink_all 'Op_write.tmp';
{
my $test = curr_test();
{
local $~ = '';
eval { write };
- like $@, qr/Not a format reference/, 'format reference';
+ like $@, qr/Undefined format ""/, 'format with 0-length name';
+
+ $~ = "\0foo";
+ eval { write };
+ like $@, qr/Undefined format "\0foo"/,
+ 'no such format beginning with null';
$~ = "NOSUCHFORMAT";
eval { write };
- like $@, qr/Undefined format/, 'no such format';
+ like $@, qr/Undefined format "NOSUCHFORMAT"/, 'no such format';
}
+select +(select(OUT21), do {
+ open(OUT21, '>Op_write.tmp') || die "Can't create Op_write.tmp";
+
+ format OUT21 =
+@<<
+$_
+.
+
+ local $^ = '';
+ local $= = 1;
+ $_ = "aataaaaaaaaaaaaaa"; eval { write(OUT21) };
+ like $@, qr/Undefined top format ""/, 'top format with 0-length name';
+
+ $^ = "\0foo";
+ # For some reason, we have to do this twice to get the error again.
+ $_ = "aataaaaaaaaaaaaaa"; eval { write(OUT21) };
+ $_ = "aataaaaaaaaaaaaaa"; eval { write(OUT21) };
+ like $@, qr/Undefined top format "\0foo"/,
+ 'no such top format beginning with null';
+
+ $^ = "NOSUCHFORMAT";
+ $_ = "aataaaaaaaaaaaaaa"; eval { write(OUT21) };
+ $_ = "aataaaaaaaaaaaaaa"; eval { write(OUT21) };
+ like $@, qr/Undefined top format "NOSUCHFORMAT"/, 'no such top format';
+
+ # reset things;
+ eval { write(OUT21) };
+ undef $^A;
+
+ close OUT21 or die "Could not close: $!";
+})[0];
+
{
package Count;
"$base\nMoo!\n",) {
foreach (['^*', qr/(.+)/], ['@*', qr/(.*?)$/s]) {
my ($format, $re) = @$_;
+ $format = "1^*2 3${format}4";
foreach my $class ('', 'Count') {
- my $name = "$first, $second $format $class";
+ my $name = qq{swrite("$format", "$first", "$second") class="$class"};
$name =~ s/\n/\\n/g;
+ $name =~ s{(.)}{
+ ord($1) > 126 ? sprintf("\\x{%x}",ord($1)) : $1
+ }ge;
$first =~ /(.+)/ or die $first;
my $expect = "1${1}2";
my $copy1 = $first;
my $copy2;
tie $copy2, $class, $second;
- is swrite("1^*2 3${format}4", $copy1, $copy2), $expect, $name;
+ is swrite("$format", $copy1, $copy2), $expect, $name;
my $obj = tied $copy2;
is $obj->[1], 1, 'value read exactly once';
} else {
my ($copy1, $copy2) = ($first, $second);
- is swrite("1^*2 3${format}4", $copy1, $copy2), $expect, $name;
+ is swrite("$format", $copy1, $copy2), $expect, $name;
}
}
}
.
-# [ID 20020227.005] format bug with undefined _TOP
+# RT #8698 format bug with undefined _TOP
open STDOUT_DUP, ">&STDOUT";
my $oldfh = select STDOUT_DUP;
local $~ = "Comment";
write;
curr_test($test + 1);
- {
- local $::TODO = '[ID 20020227.005] format bug with undefined _TOP';
- is $-, 9;
- }
+ is $-, 9;
is $^, "STDOUT_DUP_TOP";
}
select $oldfh;
*CmT = *{$::{Comment}}{FORMAT};
ok defined *{$::{CmT}}{FORMAT}, "glob assign";
+
+# RT #91032: Check that "non-real" strings like tie and overload work,
+# especially that they re-compile the pattern on each FETCH, and that
+# they don't overrun the buffer
+
+
+{
+ package RT91032;
+
+ sub TIESCALAR { bless [] }
+ my $i = 0;
+ sub FETCH { $i++; "A$i @> Z\n" }
+
+ use overload '""' => \&FETCH;
+
+ tie my $f, 'RT91032';
+
+ formline $f, "a";
+ formline $f, "bc";
+ ::is $^A, "A1 a Z\nA2 bc Z\n", "RT 91032: tied";
+ $^A = '';
+
+ my $g = bless []; # has overloaded stringify
+ formline $g, "de";
+ formline $g, "f";
+ ::is $^A, "A3 de Z\nA4 f Z\n", "RT 91032: overloaded";
+ $^A = '';
+
+ my $h = [];
+ formline $h, "junk1";
+ formline $h, "junk2";
+ ::is ref($h), 'ARRAY', "RT 91032: array ref still a ref";
+ ::like "$h", qr/^ARRAY\(0x[0-9a-f]+\)$/, "RT 91032: array stringifies ok";
+ ::is $^A, "$h$h","RT 91032: stringified array";
+ $^A = '';
+
+ # used to overwrite the ~~ in the *original SV with spaces. Naughty!
+
+ my $orig = my $format = "^<<<<< ~~\n";
+ my $abc = "abc";
+ formline $format, $abc;
+ $^A ='';
+ ::is $format, $orig, "RT91032: don't overwrite orig format string";
+
+ # check that ~ and ~~ are displayed correctly as whitespace,
+ # under the influence of various different types of border
+
+ for my $n (1,2) {
+ for my $lhs (' ', 'Y', '^<<<', '^|||', '^>>>') {
+ for my $rhs ('', ' ', 'Z', '^<<<', '^|||', '^>>>') {
+ my $fmt = "^<B$lhs" . ('~' x $n) . "$rhs\n";
+ my $sfmt = ($fmt =~ s/~/ /gr);
+ my ($a, $bc, $stop);
+ ($a, $bc, $stop) = ('a', 'bc', 's');
+ # $stop is to stop '~~' deleting the whole line
+ formline $sfmt, $stop, $a, $bc;
+ my $exp = $^A;
+ $^A = '';
+ ($a, $bc, $stop) = ('a', 'bc', 's');
+ formline $fmt, $stop, $a, $bc;
+ my $got = $^A;
+ $^A = '';
+ $fmt =~ s/\n/\\n/;
+ ::is($got, $exp, "chop munging: [$fmt]");
+ }
+ }
+ }
+}
+
+# check that '~ (delete current line if empty) works when
+# the target gets upgraded to uft8 (and re-allocated) midstream.
+
+{
+ my $format = "\x{100}@~\n"; # format is utf8
+ # this target is not utf8, but will expand (and get reallocated)
+ # when upgraded to utf8.
+ my $orig = "\x80\x81\x82";
+ local $^A = $orig;
+ my $empty = "";
+ formline $format, $empty;
+ is $^A , $orig, "~ and realloc";
+
+ # check similarly that trailing blank removal works ok
+
+ $format = "@<\n\x{100}"; # format is utf8
+ chop $format;
+ $orig = " ";
+ $^A = $orig;
+ formline $format, " ";
+ is $^A, "$orig\n", "end-of-line blanks and realloc";
+
+ # and check this doesn't overflow the buffer
+
+ local $^A = '';
+ $format = "@* @####\n";
+ $orig = "x" x 100 . "\n";
+ formline $format, $orig, 12345;
+ is $^A, ("x" x 100) . " 12345\n", "\@* doesn't overflow";
+
+ # make sure it can cope with formats > 64k
+
+ $format = 'x' x 65537;
+ $^A = '';
+ formline $format;
+ # don't use 'is' here, as the diag output will be too long!
+ ok $^A eq $format, ">64K";
+}
+
+
+SKIP: {
+ skip_if_miniperl('miniperl does not support scalario');
+ my $buf = "";
+ open my $fh, ">", \$buf;
+ my $old_fh = select $fh;
+ local $~ = "CmT";
+ write;
+ select $old_fh;
+ close $fh;
+ is $buf, "ok $test\n", "write to duplicated format";
+}
+
+format caret_A_test_TOP =
+T
+.
+
+format caret_A_test =
+L1
+L2
+L3
+L4
+.
+
+SKIP: {
+ skip_if_miniperl('miniperl does not support scalario');
+ my $buf = "";
+ open my $fh, ">", \$buf;
+ my $old_fh = select $fh;
+ local $^ = "caret_A_test_TOP";
+ local $~ = "caret_A_test";
+ local $= = 3;
+ local $^A = "A1\nA2\nA3\nA4\n";
+ write;
+ select $old_fh;
+ close $fh;
+ is $buf, "T\nA1\nA2\n\fT\nA3\nA4\n\fT\nL1\nL2\n\fT\nL3\nL4\n",
+ "assign to ^A sets FmLINES";
+}
+
fresh_perl_like(<<'EOP', qr/^Format STDOUT redefined at/, {stderr => 1}, '#64562 - Segmentation fault with redefined formats and warnings');
#!./perl
write;
EOP
+fresh_perl_is(<<'EOP', ">ARRAY<\ncrunch_eth\n", {stderr => 1}, '#79532 - formline coerces its arguments');
+use strict;
+use warnings;
+my $zamm = ['crunch_eth'];
+formline $zamm;
+printf ">%s<\n", ref $zamm;
+print "$zamm->[0]\n";
+EOP
+
+# [perl #73690]
+
+select +(select(RT73690), do {
+ open(RT73690, '>Op_write.tmp') || die "Can't create Op_write.tmp";
+ format RT73690 =
+@<< @<<
+11, 22
+.
+
+ my @ret;
+
+ @ret = write;
+ is(scalar(@ret), 1);
+ ok($ret[0]);
+ @ret = scalar(write);
+ is(scalar(@ret), 1);
+ ok($ret[0]);
+ @ret = write(RT73690);
+ is(scalar(@ret), 1);
+ ok($ret[0]);
+ @ret = scalar(write(RT73690));
+ is(scalar(@ret), 1);
+ ok($ret[0]);
+
+ @ret = ('a', write, 'z');
+ is(scalar(@ret), 3);
+ is($ret[0], 'a');
+ ok($ret[1]);
+ is($ret[2], 'z');
+ @ret = ('b', scalar(write), 'y');
+ is(scalar(@ret), 3);
+ is($ret[0], 'b');
+ ok($ret[1]);
+ is($ret[2], 'y');
+ @ret = ('c', write(RT73690), 'x');
+ is(scalar(@ret), 3);
+ is($ret[0], 'c');
+ ok($ret[1]);
+ is($ret[2], 'x');
+ @ret = ('d', scalar(write(RT73690)), 'w');
+ is(scalar(@ret), 3);
+ is($ret[0], 'd');
+ ok($ret[1]);
+ is($ret[2], 'w');
+
+ @ret = do { write; 'foo' };
+ is(scalar(@ret), 1);
+ is($ret[0], 'foo');
+ @ret = do { scalar(write); 'bar' };
+ is(scalar(@ret), 1);
+ is($ret[0], 'bar');
+ @ret = do { write(RT73690); 'baz' };
+ is(scalar(@ret), 1);
+ is($ret[0], 'baz');
+ @ret = do { scalar(write(RT73690)); 'quux' };
+ is(scalar(@ret), 1);
+ is($ret[0], 'quux');
+
+ @ret = ('a', do { write; 'foo' }, 'z');
+ is(scalar(@ret), 3);
+ is($ret[0], 'a');
+ is($ret[1], 'foo');
+ is($ret[2], 'z');
+ @ret = ('b', do { scalar(write); 'bar' }, 'y');
+ is(scalar(@ret), 3);
+ is($ret[0], 'b');
+ is($ret[1], 'bar');
+ is($ret[2], 'y');
+ @ret = ('c', do { write(RT73690); 'baz' }, 'x');
+ is(scalar(@ret), 3);
+ is($ret[0], 'c');
+ is($ret[1], 'baz');
+ is($ret[2], 'x');
+ @ret = ('d', do { scalar(write(RT73690)); 'quux' }, 'w');
+ is(scalar(@ret), 3);
+ is($ret[0], 'd');
+ is($ret[1], 'quux');
+ is($ret[2], 'w');
+
+ close RT73690 or die "Could not close: $!";
+})[0];
+
+select +(select(RT73690_2), do {
+ open(RT73690_2, '>Op_write.tmp') || die "Can't create Op_write.tmp";
+ format RT73690_2 =
+@<< @<<
+return
+.
+
+ my @ret;
+
+ @ret = write;
+ is(scalar(@ret), 1);
+ ok(!$ret[0]);
+ @ret = scalar(write);
+ is(scalar(@ret), 1);
+ ok(!$ret[0]);
+ @ret = write(RT73690_2);
+ is(scalar(@ret), 1);
+ ok(!$ret[0]);
+ @ret = scalar(write(RT73690_2));
+ is(scalar(@ret), 1);
+ ok(!$ret[0]);
+
+ @ret = ('a', write, 'z');
+ is(scalar(@ret), 3);
+ is($ret[0], 'a');
+ ok(!$ret[1]);
+ is($ret[2], 'z');
+ @ret = ('b', scalar(write), 'y');
+ is(scalar(@ret), 3);
+ is($ret[0], 'b');
+ ok(!$ret[1]);
+ is($ret[2], 'y');
+ @ret = ('c', write(RT73690_2), 'x');
+ is(scalar(@ret), 3);
+ is($ret[0], 'c');
+ ok(!$ret[1]);
+ is($ret[2], 'x');
+ @ret = ('d', scalar(write(RT73690_2)), 'w');
+ is(scalar(@ret), 3);
+ is($ret[0], 'd');
+ ok(!$ret[1]);
+ is($ret[2], 'w');
+
+ @ret = do { write; 'foo' };
+ is(scalar(@ret), 1);
+ is($ret[0], 'foo');
+ @ret = do { scalar(write); 'bar' };
+ is(scalar(@ret), 1);
+ is($ret[0], 'bar');
+ @ret = do { write(RT73690_2); 'baz' };
+ is(scalar(@ret), 1);
+ is($ret[0], 'baz');
+ @ret = do { scalar(write(RT73690_2)); 'quux' };
+ is(scalar(@ret), 1);
+ is($ret[0], 'quux');
+
+ @ret = ('a', do { write; 'foo' }, 'z');
+ is(scalar(@ret), 3);
+ is($ret[0], 'a');
+ is($ret[1], 'foo');
+ is($ret[2], 'z');
+ @ret = ('b', do { scalar(write); 'bar' }, 'y');
+ is(scalar(@ret), 3);
+ is($ret[0], 'b');
+ is($ret[1], 'bar');
+ is($ret[2], 'y');
+ @ret = ('c', do { write(RT73690_2); 'baz' }, 'x');
+ is(scalar(@ret), 3);
+ is($ret[0], 'c');
+ is($ret[1], 'baz');
+ is($ret[2], 'x');
+ @ret = ('d', do { scalar(write(RT73690_2)); 'quux' }, 'w');
+ is(scalar(@ret), 3);
+ is($ret[0], 'd');
+ is($ret[1], 'quux');
+ is($ret[2], 'w');
+
+ close RT73690_2 or die "Could not close: $!";
+})[0];
+
+open(UNDEF, '>Op_write.tmp') || die "Can't create Op_write.tmp";
+select +(select(UNDEF), $~ = "UNDEFFORMAT")[0];
+format UNDEFFORMAT =
+@
+undef *UNDEFFORMAT
+.
+write UNDEF;
+pass "active format cannot be freed";
+
+select +(select(UNDEF), $~ = "UNDEFFORMAT2")[0];
+format UNDEFFORMAT2 =
+@
+close UNDEF or die "Could not close: $!"; undef *UNDEF
+.
+write UNDEF;
+pass "freeing current handle in format";
+undef $^A;
+
+ok !eval q|
+format foo {
+@<<<
+$a
+}
+;1
+|, 'format foo { ... } is not allowed';
+
+ok !eval q|
+format =
+@<<<
+}
+;1
+|, 'format = ... } is not allowed';
+
+open(NEST, '>Op_write.tmp') || die "Can't create Op_write.tmp";
+format NEST =
+@<<<
+{
+ my $birds = "birds";
+ local *NEST = *BIRDS{FORMAT};
+ write NEST;
+ format BIRDS =
+@<<<<<
+$birds;
+.
+ "nest"
+}
+.
+write NEST;
+close NEST or die "Could not close: $!";
+is cat('Op_write.tmp'), "birds\nnest\n", 'nested formats';
+
+
#############################
## Section 4
## Add new tests *above* here
# Just a complete test for format, including top-, left- and bottom marging
# and format detection through glob entries
-if ($^O eq 'VMS' || $^O eq 'MSWin32' || $^O eq 'dos' || $^O eq 'MacOS' ||
+if ($^O eq 'VMS' || $^O eq 'MSWin32' || $^O eq 'dos' ||
($^O eq 'os2' and not eval '$OS2::can_fork')) {
$test = curr_test();
SKIP: {
https://perl5.git.perl.org / perl5.git / blobdiff