use warnings;
use strict;

use Test::More 'no_plan';
use Test::NoWarnings;


use constant TEST_1 => (
  # all sorts are numeric-ascending.
  'degenerate and boundary test sets',
  [ [], [] ],  [ [0], [0] ],  [ [1], [1] ],  [ [-1], [-1] ],
  'test sets spanning zero',
  [ [ -11, -13, -9    ], [ -13, -11, -9     ] ],  # all < 0
  [ [ -11, -13, -9, 2 ], [ -13, -11, -9,  2 ] ],
  [ [ -11,   3, -9, 2 ], [ -11, -9,   2,  3 ] ],
  [ [  11,   3, -9, 2 ], [  -9,  2,   3, 11 ] ],
  [ [  11,   3,  9, 2 ], [   2,  3,   9, 11 ] ],  # all > 0
  'fancy test set from OP pm#1208073',
  [ [ -10, 30, 5, 0b1011, 7, 9 ,8, -01111, -10, 1, 3, 9, -30,
      5, -100, 0, -1, 0xFF, -3, 30, 0b1011, 3, 2, -300, -0xFF, 15 ],
    [ -585, -300, -255, -100, -30, -10, -10, -3, -1, 0, 1, 2, 3,
       3, 5, 5, 7, 8, 9, 9, 11, 11, 15, 30, 30, 255 ],
    ],
  );

note "\n all sorts are numeric-ascending \n\n";

FUNT:  # function under test
for my $func_name (
    qw(built_in_sort  sortie_1  sortie_2  comb_sort)
    ) {

  note qq{\n=== testing $func_name() ===\n\n};
  *test_sort = do { no strict 'refs';  *$func_name; };

  VECTOR:  # test vector
  for my $ar_vector (TEST_1) {

    if (not ref $ar_vector) {
      note $ar_vector;
      next VECTOR;
      }

    my ($ar_unsorted, $ar_sorted) = @$ar_vector;

    is_deeply [ test_sort(@$ar_unsorted) ], $ar_sorted;

    }  # end for VECTOR

  }  # end for FUNT

done_testing;


# functions under test #############################################

# all sorts are numeric-ascending.

sub built_in_sort { return sort { $a <=> $b } @_; }


sub sortie_1 {

  my @sorted;
  my @sortit = @_;
  my @biglist;

  my $biggest_so_far  = 0;
  my $smallest_so_far = 0;
  foreach my $num(@sortit) {
    if ($num > $biggest_so_far) {
      $biggest_so_far = $num;
      }
    if ($num < $smallest_so_far) {
      $smallest_so_far = $num;
      }
    }

  @biglist = ($smallest_so_far..$biggest_so_far);

  foreach my $bignum (@biglist) {
    foreach my $sortnum (@sortit) {
      if ($bignum == $sortnum) {
        push @sorted, $bignum;
        }
      }

  }

  return @sorted;

  }


sub sortie_2 {

  my ($biggest, $smallest) = (0, 0);
  for my $n (@_) {
    $biggest  = $n if $biggest  < $n;
    $smallest = $n if $smallest > $n;
    }

  my %n_seen;
  ++$n_seen{$_} for @_;

  return
    map { $n_seen{$_} ? ($_) x $n_seen{$_} : () }
    $smallest .. $biggest
    ;

  }


sub comb_sort {  # from Laurent_R pm#1208002

  my $ar = [ @_ ];

  my $max = @$ar;
  my $gap = $max;

  COMB_PASS:
  while (1) {

      my $swapped = 0;
      $gap = int ($gap / 1.3);
      $gap = 1 if $gap < 1;
      my $lmax = $max - $gap - 1;

      SWAP_TEST:
      foreach my $i (0..$lmax) {
        my $j = $i + $gap;
        next SWAP_TEST if $ar->[$i] <= $ar->[$j];  # no swap
        (@{ $ar }[$i, $j], $swapped) = (@{ $ar }[$j, $i], 1);
        }

    last COMB_PASS if $gap == 1 and $swapped == 0;

    }

  return @$ar;

  }
[download]