* gcc-interface/decl.c (warn_on_field_placement): Issue the warning

[official-gcc.git] / libgo / go / sort / sort_test.go

// 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_test

import (
        "fmt"
        "internal/testenv"
        "math"
        "math/rand"
        . "sort"
        "strconv"
        stringspkg "strings"
        "testing"
)

var ints = [...]int{74, 59, 238, -784, 9845, 959, 905, 0, 0, 42, 7586, -5467984, 7586}
var float64s = [...]float64{74.3, 59.0, math.Inf(1), 238.2, -784.0, 2.3, math.NaN(), math.NaN(), math.Inf(-1), 9845.768, -959.7485, 905, 7.8, 7.8}
var strings = [...]string{"", "Hello", "foo", "bar", "foo", "f00", "%*&^*&^&", "***"}

func TestSortIntSlice(t *testing.T) {
        data := ints
        a := IntSlice(data[0:])
        Sort(a)
        if !IsSorted(a) {
                t.Errorf("sorted %v", ints)
                t.Errorf("   got %v", data)
        }
}

func TestSortFloat64Slice(t *testing.T) {
        data := float64s
        a := Float64Slice(data[0:])
        Sort(a)
        if !IsSorted(a) {
                t.Errorf("sorted %v", float64s)
                t.Errorf("   got %v", data)
        }
}

func TestSortStringSlice(t *testing.T) {
        data := strings
        a := StringSlice(data[0:])
        Sort(a)
        if !IsSorted(a) {
                t.Errorf("sorted %v", strings)
                t.Errorf("   got %v", data)
        }
}

func TestInts(t *testing.T) {
        data := ints
        Ints(data[0:])
        if !IntsAreSorted(data[0:]) {
                t.Errorf("sorted %v", ints)
                t.Errorf("   got %v", data)
        }
}

func TestFloat64s(t *testing.T) {
        data := float64s
        Float64s(data[0:])
        if !Float64sAreSorted(data[0:]) {
                t.Errorf("sorted %v", float64s)
                t.Errorf("   got %v", data)
        }
}

func TestStrings(t *testing.T) {
        data := strings
        Strings(data[0:])
        if !StringsAreSorted(data[0:]) {
                t.Errorf("sorted %v", strings)
                t.Errorf("   got %v", data)
        }
}

func TestSlice(t *testing.T) {
        data := strings
        Slice(data[:], func(i, j int) bool {
                return data[i] < data[j]
        })
        if !SliceIsSorted(data[:], func(i, j int) bool { return data[i] < data[j] }) {
                t.Errorf("sorted %v", strings)
                t.Errorf("   got %v", data)
        }
}

func TestSortLarge_Random(t *testing.T) {
        n := 1000000
        if testing.Short() {
                n /= 100
        }
        data := make([]int, n)
        for i := 0; i < len(data); i++ {
                data[i] = rand.Intn(100)
        }
        if IntsAreSorted(data) {
                t.Fatalf("terrible rand.rand")
        }
        Ints(data)
        if !IntsAreSorted(data) {
                t.Errorf("sort didn't sort - 1M ints")
        }
}

func TestReverseSortIntSlice(t *testing.T) {
        data := ints
        data1 := ints
        a := IntSlice(data[0:])
        Sort(a)
        r := IntSlice(data1[0:])
        Sort(Reverse(r))
        for i := 0; i < len(data); i++ {
                if a[i] != r[len(data)-1-i] {
                        t.Errorf("reverse sort didn't sort")
                }
                if i > len(data)/2 {
                        break
                }
        }
}

type nonDeterministicTestingData struct {
        r *rand.Rand
}

func (t *nonDeterministicTestingData) Len() int {
        return 500
}
func (t *nonDeterministicTestingData) Less(i, j int) bool {
        if i < 0 || j < 0 || i >= t.Len() || j >= t.Len() {
                panic("nondeterministic comparison out of bounds")
        }
        return t.r.Float32() < 0.5
}
func (t *nonDeterministicTestingData) Swap(i, j int) {
        if i < 0 || j < 0 || i >= t.Len() || j >= t.Len() {
                panic("nondeterministic comparison out of bounds")
        }
}

func TestNonDeterministicComparison(t *testing.T) {
        // Ensure that sort.Sort does not panic when Less returns inconsistent results.
        // See https://golang.org/issue/14377.
        defer func() {
                if r := recover(); r != nil {
                        t.Error(r)
                }
        }()

        td := &nonDeterministicTestingData{
                r: rand.New(rand.NewSource(0)),
        }

        for i := 0; i < 10; i++ {
                Sort(td)
        }
}

func BenchmarkSortString1K(b *testing.B) {
        b.StopTimer()
        unsorted := make([]string, 1<<10)
        for i := range unsorted {
                unsorted[i] = strconv.Itoa(i ^ 0x2cc)
        }
        data := make([]string, len(unsorted))

        for i := 0; i < b.N; i++ {
                copy(data, unsorted)
                b.StartTimer()
                Strings(data)
                b.StopTimer()
        }
}

func BenchmarkSortString1K_Slice(b *testing.B) {
        b.StopTimer()
        unsorted := make([]string, 1<<10)
        for i := range unsorted {
                unsorted[i] = strconv.Itoa(i ^ 0x2cc)
        }
        data := make([]string, len(unsorted))

        for i := 0; i < b.N; i++ {
                copy(data, unsorted)
                b.StartTimer()
                Slice(data, func(i, j int) bool { return data[i] < data[j] })
                b.StopTimer()
        }
}

func BenchmarkStableString1K(b *testing.B) {
        b.StopTimer()
        unsorted := make([]string, 1<<10)
        for i := 0; i < len(data); i++ {
                unsorted[i] = strconv.Itoa(i ^ 0x2cc)
        }
        data := make([]string, len(unsorted))

        for i := 0; i < b.N; i++ {
                copy(data, unsorted)
                b.StartTimer()
                Stable(StringSlice(data))
                b.StopTimer()
        }
}

func BenchmarkSortInt1K(b *testing.B) {
        b.StopTimer()
        for i := 0; i < b.N; i++ {
                data := make([]int, 1<<10)
                for i := 0; i < len(data); i++ {
                        data[i] = i ^ 0x2cc
                }
                b.StartTimer()
                Ints(data)
                b.StopTimer()
        }
}

func BenchmarkStableInt1K(b *testing.B) {
        b.StopTimer()
        unsorted := make([]int, 1<<10)
        for i := range unsorted {
                unsorted[i] = i ^ 0x2cc
        }
        data := make([]int, len(unsorted))
        for i := 0; i < b.N; i++ {
                copy(data, unsorted)
                b.StartTimer()
                Stable(IntSlice(data))
                b.StopTimer()
        }
}

func BenchmarkStableInt1K_Slice(b *testing.B) {
        b.StopTimer()
        unsorted := make([]int, 1<<10)
        for i := range unsorted {
                unsorted[i] = i ^ 0x2cc
        }
        data := make([]int, len(unsorted))
        for i := 0; i < b.N; i++ {
                copy(data, unsorted)
                b.StartTimer()
                SliceStable(data, func(i, j int) bool { return data[i] < data[j] })
                b.StopTimer()
        }
}

func BenchmarkSortInt64K(b *testing.B) {
        b.StopTimer()
        for i := 0; i < b.N; i++ {
                data := make([]int, 1<<16)
                for i := 0; i < len(data); i++ {
                        data[i] = i ^ 0xcccc
                }
                b.StartTimer()
                Ints(data)
                b.StopTimer()
        }
}

func BenchmarkSortInt64K_Slice(b *testing.B) {
        b.StopTimer()
        for i := 0; i < b.N; i++ {
                data := make([]int, 1<<16)
                for i := 0; i < len(data); i++ {
                        data[i] = i ^ 0xcccc
                }
                b.StartTimer()
                Slice(data, func(i, j int) bool { return data[i] < data[j] })
                b.StopTimer()
        }
}

func BenchmarkStableInt64K(b *testing.B) {
        b.StopTimer()
        for i := 0; i < b.N; i++ {
                data := make([]int, 1<<16)
                for i := 0; i < len(data); i++ {
                        data[i] = i ^ 0xcccc
                }
                b.StartTimer()
                Stable(IntSlice(data))
                b.StopTimer()
        }
}

const (
        _Sawtooth = iota
        _Rand
        _Stagger
        _Plateau
        _Shuffle
        _NDist
)

const (
        _Copy = iota
        _Reverse
        _ReverseFirstHalf
        _ReverseSecondHalf
        _Sorted
        _Dither
        _NMode
)

type testingData struct {
        desc        string
        t           *testing.T
        data        []int
        maxswap     int // number of swaps allowed
        ncmp, nswap int
}

func (d *testingData) Len() int { return len(d.data) }
func (d *testingData) Less(i, j int) bool {
        d.ncmp++
        return d.data[i] < d.data[j]
}
func (d *testingData) Swap(i, j int) {
        if d.nswap >= d.maxswap {
                d.t.Errorf("%s: used %d swaps sorting slice 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]
}

func min(a, b int) int {
        if a < b {
                return a
        }
        return b
}

func lg(n int) int {
        i := 0
        for 1<<uint(i) < n {
                i++
        }
        return i
}

func testBentleyMcIlroy(t *testing.T, sort func(Interface), maxswap func(int) int) {
        sizes := []int{100, 1023, 1024, 1025}
        if testing.Short() {
                sizes = []int{100, 127, 128, 129}
        }
        dists := []string{"sawtooth", "rand", "stagger", "plateau", "shuffle"}
        modes := []string{"copy", "reverse", "reverse1", "reverse2", "sort", "dither"}
        var tmp1, tmp2 [1025]int
        for _, n := range sizes {
                for m := 1; m < 2*n; m *= 2 {
                        for dist := 0; dist < _NDist; dist++ {
                                j := 0
                                k := 1
                                data := tmp1[0:n]
                                for i := 0; i < n; i++ {
                                        switch dist {
                                        case _Sawtooth:
                                                data[i] = i % m
                                        case _Rand:
                                                data[i] = rand.Intn(m)
                                        case _Stagger:
                                                data[i] = (i*m + i) % n
                                        case _Plateau:
                                                data[i] = min(i, m)
                                        case _Shuffle:
                                                if rand.Intn(m) != 0 {
                                                        j += 2
                                                        data[i] = j
                                                } else {
                                                        k += 2
                                                        data[i] = k
                                                }
                                        }
                                }

                                mdata := tmp2[0:n]
                                for mode := 0; mode < _NMode; mode++ {
                                        switch mode {
                                        case _Copy:
                                                for i := 0; i < n; i++ {
                                                        mdata[i] = data[i]
                                                }
                                        case _Reverse:
                                                for i := 0; i < n; i++ {
                                                        mdata[i] = data[n-i-1]
                                                }
                                        case _ReverseFirstHalf:
                                                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]
                                                }
                                        case _ReverseSecondHalf:
                                                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]
                                                }
                                        case _Sorted:
                                                for i := 0; i < n; i++ {
                                                        mdata[i] = data[i]
                                                }
                                                // Ints is known to be correct
                                                // because mode Sort runs after mode _Copy.
                                                Ints(mdata)
                                        case _Dither:
                                                for i := 0; i < n; i++ {
                                                        mdata[i] = data[i] + i%5
                                                }
                                        }

                                        desc := fmt.Sprintf("n=%d m=%d dist=%s mode=%s", n, m, dists[dist], modes[mode])
                                        d := &testingData{desc: desc, t: t, data: mdata[0:n], maxswap: maxswap(n)}
                                        sort(d)
                                        // Uncomment if you are trying to improve the number of compares/swaps.
                                        //t.Logf("%s: ncmp=%d, nswp=%d", desc, d.ncmp, d.nswap)

                                        // If we were testing C qsort, we'd have to make a copy
                                        // of the slice 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 can call is TestingData.swap,
                                        // it suffices here just to check that the final slice is sorted.
                                        if !IntsAreSorted(mdata) {
                                                t.Errorf("%s: ints not sorted", desc)
                                                t.Errorf("\t%v", mdata)
                                                t.FailNow()
                                        }
                                }
                        }
                }
        }
}

func TestSortBM(t *testing.T) {
        testBentleyMcIlroy(t, Sort, func(n int) int { return n * lg(n) * 12 / 10 })
}

func TestHeapsortBM(t *testing.T) {
        testBentleyMcIlroy(t, Heapsort, func(n int) int { return n * lg(n) * 12 / 10 })
}

func TestStableBM(t *testing.T) {
        testBentleyMcIlroy(t, Stable, func(n int) int { return n * lg(n) * lg(n) / 3 })
}

// This is based on the "antiquicksort" implementation by M. Douglas McIlroy.
// See http://www.cs.dartmouth.edu/~doug/mdmspe.pdf for more info.
type adversaryTestingData struct {
        data      []int
        keys      map[int]int
        candidate int
}

func (d *adversaryTestingData) Len() int { return len(d.data) }

func (d *adversaryTestingData) Less(i, j int) bool {
        if _, present := d.keys[i]; !present {
                if _, present := d.keys[j]; !present {
                        if i == d.candidate {
                                d.keys[i] = len(d.keys)
                        } else {
                                d.keys[j] = len(d.keys)
                        }
                }
        }

        if _, present := d.keys[i]; !present {
                d.candidate = i
                return false
        }
        if _, present := d.keys[j]; !present {
                d.candidate = j
                return true
        }

        return d.keys[i] >= d.keys[j]
}

func (d *adversaryTestingData) Swap(i, j int) {
        d.data[i], d.data[j] = d.data[j], d.data[i]
}

func TestAdversary(t *testing.T) {
        const size = 100
        data := make([]int, size)
        for i := 0; i < size; i++ {
                data[i] = i
        }

        d := &adversaryTestingData{data, make(map[int]int), 0}
        Sort(d) // This should degenerate to heapsort.
}

func TestStableInts(t *testing.T) {
        data := ints
        Stable(IntSlice(data[0:]))
        if !IntsAreSorted(data[0:]) {
                t.Errorf("nsorted %v\n   got %v", ints, data)
        }
}

type intPairs []struct {
        a, b int
}

// IntPairs compare on a only.
func (d intPairs) Len() int           { return len(d) }
func (d intPairs) Less(i, j int) bool { return d[i].a < d[j].a }
func (d intPairs) Swap(i, j int)      { d[i], d[j] = d[j], d[i] }

// Record initial order in B.
func (d intPairs) initB() {
        for i := range d {
                d[i].b = i
        }
}

// InOrder checks if a-equal elements were not reordered.
func (d intPairs) inOrder() bool {
        lastA, lastB := -1, 0
        for i := 0; i < len(d); i++ {
                if lastA != d[i].a {
                        lastA = d[i].a
                        lastB = d[i].b
                        continue
                }
                if d[i].b <= lastB {
                        return false
                }
                lastB = d[i].b
        }
        return true
}

func TestStability(t *testing.T) {
        n, m := 100000, 1000
        if testing.Short() {
                n, m = 1000, 100
        }
        data := make(intPairs, n)

        // random distribution
        for i := 0; i < len(data); i++ {
                data[i].a = rand.Intn(m)
        }
        if IsSorted(data) {
                t.Fatalf("terrible rand.rand")
        }
        data.initB()
        Stable(data)
        if !IsSorted(data) {
                t.Errorf("Stable didn't sort %d ints", n)
        }
        if !data.inOrder() {
                t.Errorf("Stable wasn't stable on %d ints", n)
        }

        // already sorted
        data.initB()
        Stable(data)
        if !IsSorted(data) {
                t.Errorf("Stable shuffled sorted %d ints (order)", n)
        }
        if !data.inOrder() {
                t.Errorf("Stable shuffled sorted %d ints (stability)", n)
        }

        // sorted reversed
        for i := 0; i < len(data); i++ {
                data[i].a = len(data) - i
        }
        data.initB()
        Stable(data)
        if !IsSorted(data) {
                t.Errorf("Stable didn't sort %d ints", n)
        }
        if !data.inOrder() {
                t.Errorf("Stable wasn't stable on %d ints", n)
        }
}

var countOpsSizes = []int{1e2, 3e2, 1e3, 3e3, 1e4, 3e4, 1e5, 3e5, 1e6}

func countOps(t *testing.T, algo func(Interface), name string) {
        sizes := countOpsSizes
        if testing.Short() {
                sizes = sizes[:5]
        }
        if !testing.Verbose() {
                t.Skip("Counting skipped as non-verbose mode.")
        }
        for _, n := range sizes {
                td := testingData{
                        desc:    name,
                        t:       t,
                        data:    make([]int, n),
                        maxswap: 1<<31 - 1,
                }
                for i := 0; i < n; i++ {
                        td.data[i] = rand.Intn(n / 5)
                }
                algo(&td)
                t.Logf("%s %8d elements: %11d Swap, %10d Less", name, n, td.nswap, td.ncmp)
        }
}

func TestCountStableOps(t *testing.T) { countOps(t, Stable, "Stable") }
func TestCountSortOps(t *testing.T)   { countOps(t, Sort, "Sort  ") }

func bench(b *testing.B, size int, algo func(Interface), name string) {
        if stringspkg.HasSuffix(testenv.Builder(), "-race") && size > 1e4 {
                b.Skip("skipping slow benchmark on race builder")
        }
        b.StopTimer()
        data := make(intPairs, size)
        x := ^uint32(0)
        for i := 0; i < b.N; i++ {
                for n := size - 3; n <= size+3; n++ {
                        for i := 0; i < len(data); i++ {
                                x += x
                                x ^= 1
                                if int32(x) < 0 {
                                        x ^= 0x88888eef
                                }
                                data[i].a = int(x % uint32(n/5))
                        }
                        data.initB()
                        b.StartTimer()
                        algo(data)
                        b.StopTimer()
                        if !IsSorted(data) {
                                b.Errorf("%s did not sort %d ints", name, n)
                        }
                        if name == "Stable" && !data.inOrder() {
                                b.Errorf("%s unstable on %d ints", name, n)
                        }
                }
        }
}

func BenchmarkSort1e2(b *testing.B)   { bench(b, 1e2, Sort, "Sort") }
func BenchmarkStable1e2(b *testing.B) { bench(b, 1e2, Stable, "Stable") }
func BenchmarkSort1e4(b *testing.B)   { bench(b, 1e4, Sort, "Sort") }
func BenchmarkStable1e4(b *testing.B) { bench(b, 1e4, Stable, "Stable") }
func BenchmarkSort1e6(b *testing.B)   { bench(b, 1e6, Sort, "Sort") }
func BenchmarkStable1e6(b *testing.B) { bench(b, 1e6, Stable, "Stable") }