X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=t%2Fop%2Fsort.t;h=bdb48856b945c6bda48bfb028998bc53a1cfabd5;hb=bd7d4f4d586a396d1b104a293cce339c8d63ce5a;hp=5707ef9a2f9c588c066a45494b1d5c2fca452106;hpb=75dd5fa499dd672c3f86079e60a7657e149999a8;p=p5sagit%2Fp5-mst-13.2.git

diff --git a/t/op/sort.t b/t/op/sort.t
index 5707ef9..bdb4885 100755
--- a/t/op/sort.t
+++ b/t/op/sort.t
@@ -5,7 +5,7 @@ BEGIN {
     @INC = '../lib';
 }
 use warnings;
-print "1..105\n";
+print "1..129\n";
 
 # these shouldn't hang
 {
@@ -22,7 +22,7 @@ sub Backwards_stacked($$) { my($a,$b) = @_; $a lt $b ? 1 : $a gt $b ? -1 : 0 }
 my $upperfirst = 'A' lt 'a';
 
 # Beware: in future this may become hairier because of possible
-# collation complications: qw(A a B c) can be sorted at least as
+# collation complications: qw(A a B b) can be sorted at least as
 # any of the following
 #
 #	A a B b
@@ -469,7 +469,7 @@ ok join(" ", map {0+$_} @input), "8 7 6 5 4 3 2 1 0",
     'revesed stable $a cmp $b in place sort';
 
 @input = &generate;
-$output = reverse sort @input;
+$output = reverse sort {$a cmp $b} @input;
 ok $output, "CCCBBBAAA", 'Reversed stable $a cmp $b sort in scalar context';
 
 @input = &generate;
@@ -486,6 +486,68 @@ ok join(" ", map {0+$_} @input), "2 1 0 5 4 3 8 7 6",
 $output = reverse sort {$b cmp $a} @input;
 ok $output, "AAABBBCCC", 'Reversed stable $b cmp $a sort in scalar context';
 
+sub stuff {
+    # Something complex enough to defeat any constant folding optimiser
+    $$ - $$;
+}
+
+@input = &generate;
+@output = reverse sort {stuff || $a cmp $b} @input;
+ok join(" ", map {0+$_} @output), "8 7 6 5 4 3 2 1 0",
+    'reversed stable complex sort';
+
+@input = &generate;
+@input = reverse sort {stuff || $a cmp $b} @input;
+ok join(" ", map {0+$_} @input), "8 7 6 5 4 3 2 1 0",
+    'revesed stable complex in place sort';
+
+@input = &generate;
+$output = reverse sort {stuff || $a cmp $b } @input;
+ok $output, "CCCBBBAAA", 'Reversed stable complex sort in scalar context';
+
+sub sortr {
+    reverse sort @_;
+}
+
+@output = sortr &generate;
+ok join(" ", map {0+$_} @output), "8 7 6 5 4 3 2 1 0",
+    'reversed stable sort return list context';
+$output = sortr &generate;
+ok $output, "CCCBBBAAA",
+    'reversed stable sort return scalar context';
+
+sub sortcmpr {
+    reverse sort {$a cmp $b} @_;
+}
+
+@output = sortcmpr &generate;
+ok join(" ", map {0+$_} @output), "8 7 6 5 4 3 2 1 0",
+    'reversed stable $a cmp $b sort return list context';
+$output = sortcmpr &generate;
+ok $output, "CCCBBBAAA",
+    'reversed stable $a cmp $b sort return scalar context';
+
+sub sortcmprba {
+    reverse sort {$b cmp $a} @_;
+}
+
+@output = sortcmprba &generate;
+ok join(" ", map {0+$_} @output), "2 1 0 5 4 3 8 7 6",
+    'reversed stable $b cmp $a sort return list context';
+$output = sortcmprba &generate;
+ok $output, "AAABBBCCC",
+'reversed stable $b cmp $a sort return scalar context';
+
+sub sortcmprq {
+    reverse sort {stuff || $a cmp $b} @_;
+}
+
+@output = sortcmpr &generate;
+ok join(" ", map {0+$_} @output), "8 7 6 5 4 3 2 1 0",
+    'reversed stable complex sort return list context';
+$output = sortcmpr &generate;
+ok $output, "CCCBBBAAA",
+    'reversed stable complex sort return scalar context';
 
 # And now with numbers
 
@@ -515,6 +577,15 @@ ok "@output", "G H I D E F A B C", 'stable $b <=> $a sort';
 @input = sort {$b <=> $a} @input;
 ok "@input", "G H I D E F A B C", 'stable $b <=> $a in place sort';
 
+# test that optimized {$b cmp $a} and {$b <=> $a} remain stable
+# (new in 5.9) without overloading
+{ no warnings;
+@b = sort { $b <=> $a } @input = qw/5first 6first 5second 6second/;
+ok "@b" , "6first 6second 5first 5second", "optimized {$b <=> $a} without overloading" ;
+@input = sort {$b <=> $a} @input;
+ok "@input" , "6first 6second 5first 5second","inline optimized {$b <=> $a} without overloading" ;
+};
+
 # These two are actually doing string cmp on 0 1 and 2
 @input = &generate1;
 @output = reverse sort @input;
@@ -551,3 +622,51 @@ ok "@input", "C B A F E D I H G", 'revesed stable $b <=> $a in place sort';
 @input = &generate1;
 $output = reverse sort {$b <=> $a} @input;
 ok $output, "CBAFEDIHG", 'reversed stable $b <=> $a sort in scalar context';
+
+@input = &generate1;
+@output = reverse sort {stuff || $a <=> $b} @input;
+ok "@output", "I H G F E D C B A", 'reversed stable complex sort';
+
+@input = &generate1;
+@input = reverse sort {stuff || $a <=> $b} @input;
+ok "@input", "I H G F E D C B A", 'revesed stable complex in place sort';
+
+@input = &generate1;
+$output = reverse sort {stuff || $a <=> $b} @input;
+ok $output, "IHGFEDCBA", 'reversed stable complex sort in scalar context';
+
+sub sortnumr {
+    reverse sort {$a <=> $b} @_;
+}
+
+@output = sortnumr &generate1;
+ok "@output", "I H G F E D C B A",
+    'reversed stable $a <=> $b sort return list context';
+$output = sortnumr &generate1;
+ok $output, "IHGFEDCBA", 'reversed stable $a <=> $b sort return scalar context';
+
+sub sortnumrba {
+    reverse sort {$b <=> $a} @_;
+}
+
+@output = sortnumrba &generate1;
+ok "@output", "C B A F E D I H G",
+    'reversed stable $b <=> $a sort return list context';
+$output = sortnumrba &generate1;
+ok $output, "CBAFEDIHG", 'reversed stable $b <=> $a sort return scalar context';
+
+sub sortnumrq {
+    reverse sort {stuff || $a <=> $b} @_;
+}
+
+@output = sortnumrq &generate1;
+ok "@output", "I H G F E D C B A",
+    'reversed stable complex sort return list context';
+$output = sortnumrq &generate1;
+ok $output, "IHGFEDCBA", 'reversed stable complex sort return scalar context';
+
+@output = reverse (sort(qw(C A B)), 0);
+ok "@output", "0 C B A", 'reversed sort with trailing argument';
+
+@output = reverse (0, sort(qw(C A B)));
+ok "@output", "C B A 0", 'reversed sort with leading argument';