go/src/sort/sort_test.go

var ints …

var float64s …

var stringsData …

func TestSortIntSlice(t *testing.T) { … }

func TestSortFloat64Slice(t *testing.T) { … }

// Compare Sort with slices.Sort sorting a float64 slice containing NaNs.
func TestSortFloat64sCompareSlicesSort(t *testing.T) { … }

func TestSortStringSlice(t *testing.T) { … }

func TestInts(t *testing.T) { … }

func TestFloat64s(t *testing.T) { … }

func TestStrings(t *testing.T) { … }

func TestSlice(t *testing.T) { … }

func TestSortLarge_Random(t *testing.T) { … }

func TestReverseSortIntSlice(t *testing.T) { … }

func TestBreakPatterns(t *testing.T) { … }

func TestReverseRange(t *testing.T) { … }

type nonDeterministicTestingData …

func (t *nonDeterministicTestingData) Len() int { … }

func (t *nonDeterministicTestingData) Less(i, j int) bool { … }

func (t *nonDeterministicTestingData) Swap(i, j int) { … }

func TestNonDeterministicComparison(t *testing.T) { … }

func BenchmarkSortString1K(b *testing.B) { … }

func BenchmarkSortString1K_Slice(b *testing.B) { … }

func BenchmarkStableString1K(b *testing.B) { … }

func BenchmarkSortInt1K(b *testing.B) { … }

func BenchmarkSortInt1K_Sorted(b *testing.B) { … }

func BenchmarkSortInt1K_Reversed(b *testing.B) { … }

func BenchmarkSortInt1K_Mod8(b *testing.B) { … }

func BenchmarkStableInt1K(b *testing.B) { … }

func BenchmarkStableInt1K_Slice(b *testing.B) { … }

func BenchmarkSortInt64K(b *testing.B) { … }

func BenchmarkSortInt64K_Slice(b *testing.B) { … }

func BenchmarkStableInt64K(b *testing.B) { … }

const _Sawtooth …

const _Rand …

const _Stagger …

const _Plateau …

const _Shuffle …

const _NDist …

const _Copy …

const _Reverse …

const _ReverseFirstHalf …

const _ReverseSecondHalf …

const _Sorted …

const _Dither …

const _NMode …

type testingData …

func (d *testingData) Len() int { … }

func (d *testingData) Less(i, j int) bool { … }

func (d *testingData) Swap(i, j int) { … }

func lg(n int) int { … }

func testBentleyMcIlroy(t *testing.T, sort func(Interface), maxswap func(int) int) { … }

func TestSortBM(t *testing.T) { … }

func TestHeapsortBM(t *testing.T) { … }

func TestStableBM(t *testing.T) { … }

type adversaryTestingData …

func (d *adversaryTestingData) Len() int { … }

func (d *adversaryTestingData) Less(i, j int) bool { … }

func (d *adversaryTestingData) Swap(i, j int) { … }

func newAdversaryTestingData(t *testing.T, size int, maxcmp int) *adversaryTestingData { … }

func TestAdversary(t *testing.T) { … }

func TestStableInts(t *testing.T) { … }

type intPairs …

// IntPairs compare on a only.
func (d intPairs) Len() int           { … }

func (d intPairs) Less(i, j int) bool { … }

func (d intPairs) Swap(i, j int)      { … }

// Record initial order in B.
func (d intPairs) initB() { … }

// InOrder checks if a-equal elements were not reordered.
func (d intPairs) inOrder() bool { … }

func TestStability(t *testing.T) { … }

var countOpsSizes …

func countOps(t *testing.T, algo func(Interface), name string) { … }

func TestCountStableOps(t *testing.T) { … }

func TestCountSortOps(t *testing.T)   { … }

func bench(b *testing.B, size int, algo func(Interface), name string) { … }

func BenchmarkSort1e2(b *testing.B)   { … }

func BenchmarkStable1e2(b *testing.B) { … }

func BenchmarkSort1e4(b *testing.B)   { … }

func BenchmarkStable1e4(b *testing.B) { … }

func BenchmarkSort1e6(b *testing.B)   { … }

func BenchmarkStable1e6(b *testing.B) { … }