The Grand Trek: move the *.t files from t/ to lib/ and ext/.

No doubt I made some mistakes like missed some files or
misnamed some files.  The naming rules were more or less:
(1) if the module is from CPAN, follows its ways, be it
    t/*.t or test.pl.
(2) otherwise if there are multiple tests for a module
    put them in a t/
(3) otherwise if there's only one test put it in Module.t
(4) helper files go to module/ (locale, strict, warnings)
(5) use longer filenames now that we can (but e.g. the
    compat-0.6.t and the Text::Balanced test files still
    were renamed to be more civil against the 8.3 people)
installperl was updated appropriately not to install the
*.t files or the help files from under lib.

TODO: some helper files still remain under t/ that could
follow their 'masters'.  UPDATE: On second thoughts, why
should they.  They can continue to live under t/lib, and
in fact the locale/strict/warnings helpers that were moved
could be moved back.  This way the amount of non-installable
stuff under lib/ stays smaller.

p4raw-id: //depot/perl@10676

1 files changed, 207 insertions, 0 deletions

diff --git a/ext/Thread/thr5005.t b/ext/Thread/thr5005.t
new file mode 100755
index 0000000000..6650683e16
--- /dev/null
+++ b/ext/Thread/thr5005.t
@@ -0,0 +1,207 @@
+#!./perl
+
+BEGIN {
+    chdir 't' if -d 't';
+    @INC = '../lib';
+    require Config; import Config;
+    if (! $Config{'use5005threads'}) {
+	print "1..0 # Skip: no use5005threads\n";
+	exit 0;
+    }
+
+    # XXX known trouble with global destruction
+    $ENV{PERL_DESTRUCT_LEVEL} = 0 unless $ENV{PERL_DESTRUCT_LEVEL} > 3;
+}
+$| = 1;
+print "1..74\n";
+use Thread 'yield';
+print "ok 1\n";
+
+sub content
+{
+ print shift;
+ return shift;
+}
+
+# create a thread passing args and immedaietly wait for it.
+my $t = new Thread \&content,("ok 2\n","ok 3\n", 1..1000);
+print $t->join;
+
+# check that lock works ...
+{lock $foo;
+ $t = new Thread sub { lock $foo; print "ok 5\n" };
+ print "ok 4\n";
+}
+$t->join;
+
+sub dorecurse
+{
+ my $val = shift;
+ my $ret;
+ print $val;
+ if (@_)
+  {
+   $ret = Thread->new(\&dorecurse, @_);
+   $ret->join;
+  }
+}
+
+$t = new Thread \&dorecurse, map { "ok $_\n" } 6..10;
+$t->join;
+
+# test that sleep lets other thread run
+$t = new Thread \&dorecurse,"ok 11\n";
+sleep 6;
+print "ok 12\n";
+$t->join;
+
+sub islocked : locked {
+ my $val = shift;
+ my $ret;
+ print $val;
+ if (@_)
+  {
+   $ret = Thread->new(\&islocked, shift);
+  }
+ $ret;
+}
+
+$t = Thread->new(\&islocked, "ok 13\n", "ok 14\n");
+$t->join->join;
+
+{
+    package Loch::Ness;
+    sub new { bless [], shift }
+    sub monster : locked : method {
+	my($s, $m) = @_;
+	print "ok $m\n";
+    }
+    sub gollum { &monster }
+}
+Loch::Ness->monster(15);
+Loch::Ness->new->monster(16);
+Loch::Ness->gollum(17);
+Loch::Ness->new->gollum(18);
+
+my $short = "This is a long string that goes on and on.";
+my $shorte = " a long string that goes on and on.";
+my $long  = "This is short.";
+my $longe  = " short.";
+my $thr1 = new Thread \&threaded, $short, $shorte, "19";
+my $thr2 = new Thread \&threaded, $long, $longe, "20";
+my $thr3 = new Thread \&testsprintf, "21";
+
+sub testsprintf {
+  my $testno = shift;
+  # this may coredump if thread vars are not properly initialised
+  my $same = sprintf "%.0f", $testno;
+  if ($testno eq $same) {
+    print "ok $testno\n";
+  } else {
+    print "not ok $testno\t# '$testno' ne '$same'\n";
+  }
+}
+
+sub threaded {
+  my ($string, $string_end, $testno) = @_;
+
+  # Do the match, saving the output in appropriate variables
+  $string =~ /(.*)(is)(.*)/;
+  # Yield control, allowing the other thread to fill in the match variables
+  yield();
+  # Examine the match variable contents; on broken perls this fails
+  if ($3 eq $string_end) {
+    print "ok $testno\n";
+  }
+  else {
+    warn <<EOT;
+
+#
+# This is a KNOWN FAILURE, and one of the reasons why threading
+# is still an experimental feature.  It is here to stop people
+# from deploying threads in production. ;-)
+#
+EOT
+    print "not ok $testno # other thread filled in match variables\n";
+  }
+}
+$thr1->join;
+$thr2->join;
+$thr3->join;
+print "ok 22\n";
+
+{
+    my $THRf_STATE_MASK = 7;
+    my $THRf_R_JOINABLE = 0;
+    my $THRf_R_JOINED = 1;
+    my $THRf_R_DETACHED = 2;
+    my $THRf_ZOMBIE = 3;
+    my $THRf_DEAD = 4;
+    my $THRf_DID_DIE = 8;
+    sub _test {
+	my($test, $t, $state, $die) = @_;
+	my $flags = $t->flags;
+	if (($flags & $THRf_STATE_MASK) == $state
+		&& !($flags & $THRf_DID_DIE) == !$die) {
+	    print "ok $test\n";
+	} else {
+	    print <<BAD;
+not ok $test\t# got flags $flags not @{[ $state + ($die ? $THRf_DID_DIE : 0) ]}
+BAD
+	}
+    }
+
+    my @t;
+    push @t, (
+	Thread->new(sub { sleep 4; die "thread die\n" }),
+	Thread->new(sub { die "thread die\n" }),
+	Thread->new(sub { sleep 4; 1 }),
+	Thread->new(sub { 1 }),
+    ) for 1, 2;
+    $_->detach for @t[grep $_ & 4, 0..$#t];
+
+    sleep 1;
+    my $test = 23;
+    for (0..7) {
+	my $t = $t[$_];
+	my $flags = ($_ & 1)
+	    ? ($_ & 4) ? $THRf_DEAD : $THRf_ZOMBIE
+	    : ($_ & 4) ? $THRf_R_DETACHED : $THRf_R_JOINABLE;
+	_test($test++, $t, $flags, (($_ & 3) != 1) ? 0 : $THRf_DID_DIE);
+	printf "%sok %s\n", !$t->done == !($_ & 1) ? "" : "not ", $test++;
+    }
+#   $test = 39;
+    for (grep $_ & 1, 0..$#t) {
+	next if $_ & 4;		# can't join detached threads
+	$t[$_]->eval;
+	my $die = ($_ & 2) ? "" : "thread die\n";
+	printf "%sok %s\n", $@ eq $die ? "" : "not ", $test++;
+    }
+#   $test = 41;
+    for (0..7) {
+	my $t = $t[$_];
+	my $flags = ($_ & 1)
+	    ? ($_ & 4) ? $THRf_DEAD : $THRf_DEAD
+	    : ($_ & 4) ? $THRf_R_DETACHED : $THRf_R_JOINABLE;
+	_test($test++, $t, $flags, (($_ & 3) != 1) ? 0 : $THRf_DID_DIE);
+	printf "%sok %s\n", !$t->done == !($_ & 1) ? "" : "not ", $test++;
+    }
+#   $test = 57;
+    for (grep !($_ & 1), 0..$#t) {
+	next if $_ & 4;		# can't join detached threads
+	$t[$_]->eval;
+	my $die = ($_ & 2) ? "" : "thread die\n";
+	printf "%sok %s\n", $@ eq $die ? "" : "not ", $test++;
+    }
+    sleep 1;	# make sure even the detached threads are done sleeping
+#   $test = 59;
+    for (0..7) {
+	my $t = $t[$_];
+	my $flags = ($_ & 1)
+	    ? ($_ & 4) ? $THRf_DEAD : $THRf_DEAD
+	    : ($_ & 4) ? $THRf_DEAD : $THRf_DEAD;
+	_test($test++, $t, $flags, ($_ & 2) ? 0 : $THRf_DID_DIE);
+	printf "%sok %s\n", $t->done ? "" : "not ", $test++;
+    }
+#   $test = 75;
+}