X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2Fsort.t;h=ca809b0ffae9e58991ed6a13b6b519172b18713c;hb=2e219d7e25b5babddbc1b539346e48e7b94da290;hp=dbbf82ed707d508befc2816452e90885257d34f2;hpb=be6228f7c2abd7aa10af57822ba74340e3f0e471;p=p5sagit%2Fp5-mst-13.2.git

diff --git a/lib/sort.t b/lib/sort.t
index dbbf82e..ca809b0 100644
--- a/lib/sort.t
+++ b/lib/sort.t
@@ -3,9 +3,6 @@
 # This tests the behavior of sort() under the different 'use sort' forms.
 # Algorithm by John P. Linderman.
 
-use strict;
-use warnings;
-
 my ($BigWidth, $BigEnough, $RootWidth, $ItemFormat, @TestSizes, $WellSoaked);
 
 BEGIN {
@@ -25,10 +22,14 @@ BEGIN {
     }
 }
 
+use strict;
+use warnings;
+
 use Test::More tests => @TestSizes * 2	# sort() tests
-			* 4		# number of pragmas to test
+			* 6		# number of pragmas to test
 			+ 1 		# extra test for qsort instability
-			+ 3;		# tests for sort::current
+			+ 3		# tests for sort::current
+			+ 3;		# tests for "defaults" and "no sort"
 
 # Generate array of specified size for testing sort.
 #
@@ -58,15 +59,18 @@ sub genarray {
 sub checkorder {
     my $aref = shift;
     my $status = '';			# so far, so good
-    my $i;
+    my ($i, $disorder);
 
     for ($i = 0; $i < $#$aref; ++$i) {
-	next if ($aref->[$i] lt $aref->[$i+1]);
-	$status = (substr($aref->[$i], 0, $RootWidth) eq
-		   substr($aref->[$i+1], 0, $RootWidth)) ?
-		  "Instability" : "Disorder";
-	$status .= " at element $i between $aref->[$i] and $aref->[$i+1]";
-	last;
+	# Equality shouldn't happen, but catch it in the contents check
+	next if ($aref->[$i] le $aref->[$i+1]);
+	$disorder = (substr($aref->[$i],   0, $RootWidth) eq
+		     substr($aref->[$i+1], 0, $RootWidth)) ?
+		     "Instability" : "Disorder";
+	# Keep checking if merely unstable... disorder is much worse.
+	$status =
+	    "$disorder at element $i between $aref->[$i] and $aref->[$i+1]";
+	last unless ($disorder eq "Instability");	
     }
     return $status;
 }
@@ -95,7 +99,7 @@ sub checkequal {
 # Test sort on arrays of various sizes (set up in @TestSizes)
 
 sub main {
-    my ($expect_unstable) = @_;
+    my ($dothesort, $expect_unstable) = @_;
     my ($ts, $unsorted, @sorted, $status);
     my $unstable_num = 0;
 
@@ -104,9 +108,9 @@ sub main {
 	# Sort only on item portion of each element.
 	# There will typically be many repeated items,
 	# and their order had better be preserved.
-	@sorted = sort { substr($a, 0, $RootWidth)
+	@sorted = $dothesort->(sub { substr($a, 0, $RootWidth)
 				    cmp
-	                 substr($b, 0, $RootWidth) } @$unsorted;
+	                 substr($b, 0, $RootWidth) }, $unsorted);
 	$status = checkorder(\@sorted);
 	# Put the items back into the original order.
 	# The contents of the arrays had better be identical.
@@ -115,44 +119,63 @@ sub main {
 	    ++$unstable_num;
 	}
 	is($status, '', "order ok for size $ts");
-	@sorted = sort { substr($a, $RootWidth)
+	@sorted = $dothesort->(sub { substr($a, $RootWidth)
 				    cmp
-	                 substr($b, $RootWidth) } @sorted;
+			    substr($b, $RootWidth) }, \@sorted);
 	$status = checkequal(\@sorted, $unsorted);
 	is($status, '', "contents ok for size $ts");
     }
+    # If the following test (#58) fails, see the comments in pp_sort.c
+    # for Perl_sortsv().
     if ($expect_unstable) {
 	ok($unstable_num > 0, 'Instability ok');
     }
 }
 
 # Test with no pragma still loaded -- stability expected (this is a mergesort)
-main(0);
-
-# XXX We're using this eval "..." trick to force recompilation,
-# to ensure that the correct pragma is enabled when main() is run.
-# Currently 'use sort' modifies $^H{SORT} at compile-time, but
-# pp_sort() fetches its value at run-time : thus the lexical scoping
-# of %^H is of no utility.
-# The order of those evals is important.
+main(sub { sort {&{$_[0]}} @{$_[1]} }, 0);
 
-eval q{
+{
     use sort qw(_qsort);
-    is(sort::current(), 'quicksort', 'sort::current for _qsort');
-    main(1);
-};
-die $@ if $@;
+    my $sort_current; BEGIN { $sort_current = sort::current(); }
+    is($sort_current, 'quicksort', 'sort::current for _qsort');
+    main(sub { sort {&{$_[0]}} @{$_[1]} }, 1);
+}
 
-eval q{
+{
     use sort qw(_mergesort);
-    is(sort::current(), 'mergesort', 'sort::current for _mergesort');
-    main(0);
-};
-die $@ if $@;
+    my $sort_current; BEGIN { $sort_current = sort::current(); }
+    is($sort_current, 'mergesort', 'sort::current for _mergesort');
+    main(sub { sort {&{$_[0]}} @{$_[1]} }, 0);
+}
 
-eval q{
+{
     use sort qw(_qsort stable);
-    is(sort::current(), 'quicksort stable', 'sort::current for _qsort stable');
-    main(0);
-};
-die $@ if $@;
+    my $sort_current; BEGIN { $sort_current = sort::current(); }
+    is($sort_current, 'quicksort stable', 'sort::current for _qsort stable');
+    main(sub { sort {&{$_[0]}} @{$_[1]} }, 0);
+}
+
+# Tests added to check "defaults" subpragma, and "no sort"
+
+{
+    use sort qw(_qsort stable);
+    no sort qw(_qsort);
+    my $sort_current; BEGIN { $sort_current = sort::current(); }
+    is($sort_current, 'stable', 'sort::current after no _qsort');
+    main(sub { sort {&{$_[0]}} @{$_[1]} }, 0);
+}
+
+{
+    use sort qw(defaults _qsort);
+    my $sort_current; BEGIN { $sort_current = sort::current(); }
+    is($sort_current, 'quicksort', 'sort::current after defaults _qsort');
+    # Not expected to be stable, so don't test for stability here
+}
+
+{
+    use sort qw(defaults stable);
+    my $sort_current; BEGIN { $sort_current = sort::current(); }
+    is($sort_current, 'stable', 'sort::current after defaults stable');
+    main(sub { sort {&{$_[0]}} @{$_[1]} }, 0);
+}