2008-11-24 16:17:47 -07:00
|
|
|
// Copyright 2009 The Go Authors. All rights reserved.
|
|
|
|
// Use of this source code is governed by a BSD-style
|
|
|
|
// license that can be found in the LICENSE file.
|
|
|
|
|
|
|
|
package sort
|
|
|
|
|
|
|
|
import (
|
|
|
|
"fmt";
|
|
|
|
"rand";
|
|
|
|
"sort";
|
|
|
|
"testing";
|
|
|
|
)
|
|
|
|
|
|
|
|
|
2009-03-03 09:39:12 -07:00
|
|
|
var ints = [...]int{74, 59, 238, -784, 9845, 959, 905, 0, 0, 42, 7586, -5467984, 7586}
|
|
|
|
var floats = [...]float{74.3, 59.0, 238.2, -784.0, 2.3, 9845.768, -959.7485, 905, 7.8, 7.8}
|
|
|
|
var strings = [...]string{"", "Hello", "foo", "bar", "foo", "f00", "%*&^*&^&", "***"}
|
2008-11-24 16:17:47 -07:00
|
|
|
|
2009-01-20 15:40:40 -07:00
|
|
|
func TestSortIntArray(t *testing.T) {
|
2008-11-24 16:17:47 -07:00
|
|
|
data := ints;
|
2009-01-08 16:12:00 -07:00
|
|
|
a := IntArray(data);
|
|
|
|
sort.Sort(a);
|
|
|
|
if !sort.IsSorted(a) {
|
2008-11-24 16:17:47 -07:00
|
|
|
t.Errorf("sorted %v", ints);
|
|
|
|
t.Errorf(" got %v", data);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-01-20 15:40:40 -07:00
|
|
|
func TestSortFloatArray(t *testing.T) {
|
2008-11-24 16:17:47 -07:00
|
|
|
data := floats;
|
2009-01-08 16:12:00 -07:00
|
|
|
a := FloatArray(data);
|
|
|
|
sort.Sort(a);
|
|
|
|
if !sort.IsSorted(a) {
|
2008-11-24 16:17:47 -07:00
|
|
|
t.Errorf("sorted %v", floats);
|
|
|
|
t.Errorf(" got %v", data);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-01-20 15:40:40 -07:00
|
|
|
func TestSortStringArray(t *testing.T) {
|
2008-11-24 16:17:47 -07:00
|
|
|
data := strings;
|
2009-01-08 16:12:00 -07:00
|
|
|
a := StringArray(data);
|
|
|
|
sort.Sort(a);
|
|
|
|
if !sort.IsSorted(a) {
|
2008-11-24 16:17:47 -07:00
|
|
|
t.Errorf("sorted %v", strings);
|
|
|
|
t.Errorf(" got %v", data);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-01-20 15:40:40 -07:00
|
|
|
func TestSortInts(t *testing.T) {
|
2008-11-24 16:17:47 -07:00
|
|
|
data := ints;
|
2008-12-18 23:37:22 -07:00
|
|
|
sort.SortInts(data);
|
|
|
|
if !sort.IntsAreSorted(data) {
|
2008-11-24 16:17:47 -07:00
|
|
|
t.Errorf("sorted %v", ints);
|
|
|
|
t.Errorf(" got %v", data);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-01-20 15:40:40 -07:00
|
|
|
func TestSortFloats(t *testing.T) {
|
2008-11-24 16:17:47 -07:00
|
|
|
data := floats;
|
2008-12-18 23:37:22 -07:00
|
|
|
sort.SortFloats(data);
|
|
|
|
if !sort.FloatsAreSorted(data) {
|
2008-11-24 16:17:47 -07:00
|
|
|
t.Errorf("sorted %v", floats);
|
|
|
|
t.Errorf(" got %v", data);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-01-20 15:40:40 -07:00
|
|
|
func TestSortStrings(t *testing.T) {
|
2008-11-24 16:17:47 -07:00
|
|
|
data := strings;
|
2008-12-18 23:37:22 -07:00
|
|
|
sort.SortStrings(data);
|
|
|
|
if !sort.StringsAreSorted(data) {
|
2008-11-24 16:17:47 -07:00
|
|
|
t.Errorf("sorted %v", strings);
|
|
|
|
t.Errorf(" got %v", data);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-01-20 15:40:40 -07:00
|
|
|
func TestSortLarge_Random(t *testing.T) {
|
2009-01-06 16:19:02 -07:00
|
|
|
data := make([]int, 1000000);
|
2008-11-24 16:17:47 -07:00
|
|
|
for i := 0; i < len(data); i++ {
|
2009-01-16 13:47:24 -07:00
|
|
|
data[i] = rand.Intn(100);
|
2008-11-24 16:17:47 -07:00
|
|
|
}
|
|
|
|
if sort.IntsAreSorted(data) {
|
|
|
|
t.Fatalf("terrible rand.rand");
|
|
|
|
}
|
|
|
|
sort.SortInts(data);
|
|
|
|
if !sort.IntsAreSorted(data) {
|
|
|
|
t.Errorf("sort didn't sort - 1M ints");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
const (
|
2009-01-16 11:34:21 -07:00
|
|
|
_Sawtooth = iota;
|
|
|
|
_Rand;
|
|
|
|
_Stagger;
|
|
|
|
_Plateau;
|
|
|
|
_Shuffle;
|
|
|
|
_NDist;
|
2008-11-24 16:17:47 -07:00
|
|
|
)
|
|
|
|
|
|
|
|
const (
|
2009-01-16 11:34:21 -07:00
|
|
|
_Copy = iota;
|
|
|
|
_Reverse;
|
|
|
|
_ReverseFirstHalf;
|
|
|
|
_ReverseSecondHalf;
|
|
|
|
_Sorted;
|
|
|
|
_Dither;
|
|
|
|
_NMode;
|
|
|
|
)
|
|
|
|
|
|
|
|
type testingData struct {
|
2008-11-24 16:17:47 -07:00
|
|
|
desc string;
|
|
|
|
t *testing.T;
|
2008-12-18 23:37:22 -07:00
|
|
|
data []int;
|
2008-11-24 16:17:47 -07:00
|
|
|
maxswap int; // number of swaps allowed
|
|
|
|
nswap int;
|
|
|
|
}
|
|
|
|
|
2009-01-16 11:34:21 -07:00
|
|
|
func (d *testingData) Len() int { return len(d.data); }
|
|
|
|
func (d *testingData) Less(i, j int) bool { return d.data[i] < d.data[j]; }
|
|
|
|
func (d *testingData) Swap(i, j int) {
|
2008-11-24 16:17:47 -07:00
|
|
|
if d.nswap >= d.maxswap {
|
|
|
|
d.t.Errorf("%s: used %d swaps sorting array of %d", d.desc, d.nswap, len(d.data));
|
|
|
|
d.t.FailNow();
|
|
|
|
}
|
|
|
|
d.nswap++;
|
|
|
|
d.data[i], d.data[j] = d.data[j], d.data[i];
|
|
|
|
}
|
|
|
|
|
2009-01-16 11:34:21 -07:00
|
|
|
func lg(n int) int {
|
2008-11-24 16:17:47 -07:00
|
|
|
i := 0;
|
|
|
|
for 1<<uint(i) < n {
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
return i;
|
|
|
|
}
|
|
|
|
|
2009-01-20 15:40:40 -07:00
|
|
|
func TestBentleyMcIlroy(t *testing.T) {
|
2009-03-03 09:39:12 -07:00
|
|
|
sizes := []int{100, 1023, 1024, 1025};
|
|
|
|
dists := []string{"sawtooth", "rand", "stagger", "plateau", "shuffle"};
|
|
|
|
modes := []string{"copy", "reverse", "reverse1", "reverse2", "sort", "dither"};
|
2008-11-24 16:17:47 -07:00
|
|
|
var tmp1, tmp2 [1025]int;
|
|
|
|
for ni := 0; ni < len(sizes); ni++ {
|
|
|
|
n := sizes[ni];
|
|
|
|
for m := 1; m < 2*n; m *= 2 {
|
2009-01-16 11:34:21 -07:00
|
|
|
for dist := 0; dist < _NDist; dist++ {
|
2008-11-24 16:17:47 -07:00
|
|
|
j := 0;
|
|
|
|
k := 1;
|
2008-12-18 23:37:22 -07:00
|
|
|
data := tmp1[0:n];
|
2008-11-24 16:17:47 -07:00
|
|
|
for i := 0; i < n; i++ {
|
|
|
|
switch dist {
|
2009-01-16 11:34:21 -07:00
|
|
|
case _Sawtooth:
|
2008-11-24 16:17:47 -07:00
|
|
|
data[i] = i % m;
|
2009-01-16 11:34:21 -07:00
|
|
|
case _Rand:
|
2009-01-16 13:47:24 -07:00
|
|
|
data[i] = rand.Intn(m);
|
2009-01-16 11:34:21 -07:00
|
|
|
case _Stagger:
|
2008-11-24 16:17:47 -07:00
|
|
|
data[i] = (i*m + i) % n;
|
2009-01-16 11:34:21 -07:00
|
|
|
case _Plateau:
|
|
|
|
data[i] = min(i, m);
|
|
|
|
case _Shuffle:
|
2009-01-16 13:47:24 -07:00
|
|
|
if rand.Intn(m) != 0 {
|
2008-11-24 16:17:47 -07:00
|
|
|
j += 2;
|
|
|
|
data[i] = j;
|
|
|
|
} else {
|
|
|
|
k += 2;
|
|
|
|
data[i] = k;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-12-18 23:37:22 -07:00
|
|
|
mdata := tmp2[0:n];
|
2009-01-16 11:34:21 -07:00
|
|
|
for mode := 0; mode < _NMode; mode++ {
|
2008-11-24 16:17:47 -07:00
|
|
|
switch mode {
|
2009-01-16 11:34:21 -07:00
|
|
|
case _Copy:
|
2008-11-24 16:17:47 -07:00
|
|
|
for i := 0; i < n; i++ {
|
|
|
|
mdata[i] = data[i];
|
|
|
|
}
|
2009-01-16 11:34:21 -07:00
|
|
|
case _Reverse:
|
2008-11-24 16:17:47 -07:00
|
|
|
for i := 0; i < n; i++ {
|
|
|
|
mdata[i] = data[n-i-1];
|
|
|
|
}
|
2009-01-16 11:34:21 -07:00
|
|
|
case _ReverseFirstHalf:
|
2008-11-24 16:17:47 -07:00
|
|
|
for i := 0; i < n/2; i++ {
|
|
|
|
mdata[i] = data[n/2-i-1];
|
|
|
|
}
|
|
|
|
for i := n/2; i < n; i++ {
|
|
|
|
mdata[i] = data[i];
|
|
|
|
}
|
2009-01-16 11:34:21 -07:00
|
|
|
case _ReverseSecondHalf:
|
2008-11-24 16:17:47 -07:00
|
|
|
for i := 0; i < n/2; i++ {
|
|
|
|
mdata[i] = data[i];
|
|
|
|
}
|
|
|
|
for i := n/2; i < n; i++ {
|
|
|
|
mdata[i] = data[n-(i-n/2)-1];
|
|
|
|
}
|
2009-01-16 11:34:21 -07:00
|
|
|
case _Sorted:
|
2008-11-24 16:17:47 -07:00
|
|
|
for i := 0; i < n; i++ {
|
|
|
|
mdata[i] = data[i];
|
|
|
|
}
|
|
|
|
// sort.SortInts is known to be correct
|
2009-01-16 11:34:21 -07:00
|
|
|
// because mode Sort runs after mode _Copy.
|
2008-11-24 16:17:47 -07:00
|
|
|
sort.SortInts(mdata);
|
2009-01-16 11:34:21 -07:00
|
|
|
case _Dither:
|
2008-11-24 16:17:47 -07:00
|
|
|
for i := 0; i < n; i++ {
|
|
|
|
mdata[i] = data[i] + i%5;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-01-15 14:48:11 -07:00
|
|
|
desc := fmt.Sprintf("n=%d m=%d dist=%s mode=%s", n, m, dists[dist], modes[mode]);
|
2009-03-03 09:39:12 -07:00
|
|
|
d := &testingData{desc, t, mdata[0:n], n*lg(n)*12/10, 0};
|
2008-11-24 16:17:47 -07:00
|
|
|
sort.Sort(d);
|
|
|
|
|
|
|
|
// If we were testing C qsort, we'd have to make a copy
|
|
|
|
// of the array and sort it ourselves and then compare
|
|
|
|
// x against it, to ensure that qsort was only permuting
|
|
|
|
// the data, not (for example) overwriting it with zeros.
|
|
|
|
//
|
|
|
|
// In go, we don't have to be so paranoid: since the only
|
|
|
|
// mutating method sort.Sort can call is TestingData.swap,
|
|
|
|
// it suffices here just to check that the final array is sorted.
|
|
|
|
if !sort.IntsAreSorted(mdata) {
|
|
|
|
t.Errorf("%s: ints not sorted", desc);
|
|
|
|
t.Errorf("\t%v", mdata);
|
|
|
|
t.FailNow();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|