Re: bugzilla.redhat bug #101767 (threads, threads::shared)

[p5sagit/p5-mst-13.2.git] / ext / threads / t / basic.t

diff --git a/ext/threads/t/basic.t b/ext/threads/t/basic.t
index 880497f..09a148d 100755 (executable)
--- a/ext/threads/t/basic.t
+++ b/ext/threads/t/basic.t
@@ -1,91 +1,140 @@
-# Before `make install' is performed this script should be runnable with
-# `make test'. After `make install' it should work as `perl test.pl'
 
+
+#
+# The reason this does not use a Test module is that
+# they mess up test numbers between threads
+#
+# And even when that will be fixed, this is a basic
+# test and should not rely on shared variables
+#
+# This will test the basic API, it will not use any coderefs
+# as they are more advanced
+#
 #########################
 
-# change 'tests => 1' to 'tests => last_test_to_print';
+
+BEGIN {
+    chdir 't' if -d 't';
+    push @INC, '../lib';
+    require Config; import Config;
+    unless ($Config{'useithreads'}) {
+       print "1..0 # Skip: no useithreads\n";
+       exit 0; 
+    }
+}
+
 use ExtUtils::testlib;
-use Test;
 use strict;
-BEGIN { plan tests => 16 };
+BEGIN { $| = 1; print "1..19\n" };
 use threads;
 
 
-ok(1); # If we made it this far, we're ok.
+
+print "ok 1\n";
+
 
 #########################
 
-# Insert your test code below, the Test module is use()ed here so read
-# its man page ( perldoc Test ) for help writing this test script.
-#my $bar;
 
-skip('The ignores are here to keep test numbers correct','The ignores are here to keep test numbers correct');
 
-#test passing of simple argument
-my $thread = threads->create(sub { ok('bar',$_[0]) },"bar");
-$thread->join();
-skip('Ignore','Ignore');
 
-#test passing of complex argument
+sub ok {       
+    my ($id, $ok, $name) = @_;
+
+    # You have to do it this way or VMS will get confused.
+    print $ok ? "ok $id - $name\n" : "not ok $id - $name\n";
+
+    printf "# Failed test at line %d\n", (caller)[2] unless $ok;
+
+    return $ok;
+}
+
+
+
+sub test1 {
+       ok(2,'bar' eq $_[0],"Test that argument passing works");
+}
+threads->create('test1','bar')->join();
+
+sub test2 {
+       ok(3,'bar' eq $_[0]->[0]->{foo},"Test that passing arguments as references work");
+}
 
-$thread = threads->create(sub { ok('bar',$_[0]->[0]->{foo})},[{foo => 'bar'}]);
+threads->create('test2',[{foo => 'bar'}])->join();
 
-$thread->join();
-skip('Ignore','Ignore');
 
 #test execuion of normal sub
-sub bar { ok(1,shift()) }
-threads->create(\&bar,1)->join();
-skip('Ignore','Ignore');
+sub test3 { ok(4,shift() == 1,"Test a normal sub") }
+threads->create('test3',1)->join();
+
 
 #check Config
-ok("1", "$Config::threads");
+ok(5, 1 == $threads::threads,"Check that threads::threads is true");
 
 #test trying to detach thread
 
-my $thread1 = threads->create(sub {ok(1);});
+sub test4 { ok(6,1,"Detach test") }
+
+my $thread1 = threads->create('test4');
 
 $thread1->detach();
-skip('Ignore','Ignore');
-sleep 1;
-ok(1);
-#create nested threads
-unless($^O eq 'MSWin32') {
-       my $thread3 = threads->create(sub { threads->create(sub {})})->join();
-       ok(1);
-} else {
-       skip('thread trees are unsafe under win32','thread trees are unsafe under win32');
+threads->yield; # help out non-preemptive thread implementations
+sleep 2;
+ok(7,1,"Detach test");
+
+
+
+sub test5 {
+       threads->create('test6')->join();
+       ok(9,1,"Nested thread test");
 }
-skip('Ignore','Ignore');
 
-my @threads;
-my $i;
-unless($^O eq 'MSWin32') {
-for(1..25) {   
-       push @threads, threads->create(sub { for(1..100000) { my $i  } threads->create(sub { sleep 2})->join() });
+sub test6 {
+       ok(8,1,"Nested thread test");
 }
-foreach my $thread (@threads) {
-       $thread->join();
+
+threads->create('test5')->join();
+
+sub test7 {
+       my $self = threads->self();
+       ok(10, $self->tid == 7, "Wanted 7, got ".$self->tid);
+       ok(11, threads->tid() == 7, "Wanted 7, got ".threads->tid());
 }
+
+threads->create('test7')->join;
+
+sub test8 {
+       my $self = threads->self();
+       ok(12, $self->tid == 8, "Wanted 8, got ".$self->tid);
+       ok(13, threads->tid() == 8, "Wanted 8, got ".threads->tid());
 }
-ok(1);
-threads->create(sub { 
-    my $self = threads->self();
-    ok($self->tid(),57);
-})->join();
-skip('Ignore','Ignore');
-threads->create(sub { 
-    my $self = threads->self();
-    ok($self->tid(),58);
-})->join();
-skip('Ignore','Ignore');
+
+threads->create('test8')->join;
+
 
 #check support for threads->self() in main thread
-ok(0,threads->self->tid());
-ok(0,threads->tid());
+ok(14, 0 == threads->self->tid(),"Check so that tid for threads work for main thread");
+ok(15, 0 == threads->tid(),"Check so that tid for threads work for main thread");
 
+{
+       no warnings;
+    local *CLONE = sub { ok(16, threads->tid() == 9, "Tid should be correct in the clone")};
+    threads->create(sub { ok(17, threads->tid() == 9, "And tid be 9 here too") })->join();
+}
+
+{ 
 
+    sub Foo::DESTROY { 
+       ok(19, threads->tid() == 10, "In destroy it should be correct too" )
+       }
+    my $foo;
+    threads->create(sub { ok(18, threads->tid() == 10, "And tid be 10 here");
+                         $foo = bless {}, 'Foo';                         
+                         return undef;
+                     })->join();
 
+}
+1;