sort_test.go

Documentation: sort

		 1  // Copyright 2009 The Go Authors. All rights reserved.
		 2  // Use of this source code is governed by a BSD-style
		 3  // license that can be found in the LICENSE file.
		 4  
		 5  package sort_test
		 6  
		 7  import (
		 8  	"fmt"
		 9  	"internal/testenv"
		10  	"math"
		11  	"math/rand"
		12  	. "sort"
		13  	"strconv"
		14  	stringspkg "strings"
		15  	"testing"
		16  )
		17  
		18  var ints = [...]int{74, 59, 238, -784, 9845, 959, 905, 0, 0, 42, 7586, -5467984, 7586}
		19  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}
		20  var strings = [...]string{"", "Hello", "foo", "bar", "foo", "f00", "%*&^*&^&", "***"}
		21  
		22  func TestSortIntSlice(t *testing.T) {
		23  	data := ints
		24  	a := IntSlice(data[0:])
		25  	Sort(a)
		26  	if !IsSorted(a) {
		27  		t.Errorf("sorted %v", ints)
		28  		t.Errorf("	 got %v", data)
		29  	}
		30  }
		31  
		32  func TestSortFloat64Slice(t *testing.T) {
		33  	data := float64s
		34  	a := Float64Slice(data[0:])
		35  	Sort(a)
		36  	if !IsSorted(a) {
		37  		t.Errorf("sorted %v", float64s)
		38  		t.Errorf("	 got %v", data)
		39  	}
		40  }
		41  
		42  func TestSortStringSlice(t *testing.T) {
		43  	data := strings
		44  	a := StringSlice(data[0:])
		45  	Sort(a)
		46  	if !IsSorted(a) {
		47  		t.Errorf("sorted %v", strings)
		48  		t.Errorf("	 got %v", data)
		49  	}
		50  }
		51  
		52  func TestInts(t *testing.T) {
		53  	data := ints
		54  	Ints(data[0:])
		55  	if !IntsAreSorted(data[0:]) {
		56  		t.Errorf("sorted %v", ints)
		57  		t.Errorf("	 got %v", data)
		58  	}
		59  }
		60  
		61  func TestFloat64s(t *testing.T) {
		62  	data := float64s
		63  	Float64s(data[0:])
		64  	if !Float64sAreSorted(data[0:]) {
		65  		t.Errorf("sorted %v", float64s)
		66  		t.Errorf("	 got %v", data)
		67  	}
		68  }
		69  
		70  func TestStrings(t *testing.T) {
		71  	data := strings
		72  	Strings(data[0:])
		73  	if !StringsAreSorted(data[0:]) {
		74  		t.Errorf("sorted %v", strings)
		75  		t.Errorf("	 got %v", data)
		76  	}
		77  }
		78  
		79  func TestSlice(t *testing.T) {
		80  	data := strings
		81  	Slice(data[:], func(i, j int) bool {
		82  		return data[i] < data[j]
		83  	})
		84  	if !SliceIsSorted(data[:], func(i, j int) bool { return data[i] < data[j] }) {
		85  		t.Errorf("sorted %v", strings)
		86  		t.Errorf("	 got %v", data)
		87  	}
		88  }
		89  
		90  func TestSortLarge_Random(t *testing.T) {
		91  	n := 1000000
		92  	if testing.Short() {
		93  		n /= 100
		94  	}
		95  	data := make([]int, n)
		96  	for i := 0; i < len(data); i++ {
		97  		data[i] = rand.Intn(100)
		98  	}
		99  	if IntsAreSorted(data) {
	 100  		t.Fatalf("terrible rand.rand")
	 101  	}
	 102  	Ints(data)
	 103  	if !IntsAreSorted(data) {
	 104  		t.Errorf("sort didn't sort - 1M ints")
	 105  	}
	 106  }
	 107  
	 108  func TestReverseSortIntSlice(t *testing.T) {
	 109  	data := ints
	 110  	data1 := ints
	 111  	a := IntSlice(data[0:])
	 112  	Sort(a)
	 113  	r := IntSlice(data1[0:])
	 114  	Sort(Reverse(r))
	 115  	for i := 0; i < len(data); i++ {
	 116  		if a[i] != r[len(data)-1-i] {
	 117  			t.Errorf("reverse sort didn't sort")
	 118  		}
	 119  		if i > len(data)/2 {
	 120  			break
	 121  		}
	 122  	}
	 123  }
	 124  
	 125  type nonDeterministicTestingData struct {
	 126  	r *rand.Rand
	 127  }
	 128  
	 129  func (t *nonDeterministicTestingData) Len() int {
	 130  	return 500
	 131  }
	 132  func (t *nonDeterministicTestingData) Less(i, j int) bool {
	 133  	if i < 0 || j < 0 || i >= t.Len() || j >= t.Len() {
	 134  		panic("nondeterministic comparison out of bounds")
	 135  	}
	 136  	return t.r.Float32() < 0.5
	 137  }
	 138  func (t *nonDeterministicTestingData) Swap(i, j int) {
	 139  	if i < 0 || j < 0 || i >= t.Len() || j >= t.Len() {
	 140  		panic("nondeterministic comparison out of bounds")
	 141  	}
	 142  }
	 143  
	 144  func TestNonDeterministicComparison(t *testing.T) {
	 145  	// Ensure that sort.Sort does not panic when Less returns inconsistent results.
	 146  	// See https://golang.org/issue/14377.
	 147  	defer func() {
	 148  		if r := recover(); r != nil {
	 149  			t.Error(r)
	 150  		}
	 151  	}()
	 152  
	 153  	td := &nonDeterministicTestingData{
	 154  		r: rand.New(rand.NewSource(0)),
	 155  	}
	 156  
	 157  	for i := 0; i < 10; i++ {
	 158  		Sort(td)
	 159  	}
	 160  }
	 161  
	 162  func BenchmarkSortString1K(b *testing.B) {
	 163  	b.StopTimer()
	 164  	unsorted := make([]string, 1<<10)
	 165  	for i := range unsorted {
	 166  		unsorted[i] = strconv.Itoa(i ^ 0x2cc)
	 167  	}
	 168  	data := make([]string, len(unsorted))
	 169  
	 170  	for i := 0; i < b.N; i++ {
	 171  		copy(data, unsorted)
	 172  		b.StartTimer()
	 173  		Strings(data)
	 174  		b.StopTimer()
	 175  	}
	 176  }
	 177  
	 178  func BenchmarkSortString1K_Slice(b *testing.B) {
	 179  	b.StopTimer()
	 180  	unsorted := make([]string, 1<<10)
	 181  	for i := range unsorted {
	 182  		unsorted[i] = strconv.Itoa(i ^ 0x2cc)
	 183  	}
	 184  	data := make([]string, len(unsorted))
	 185  
	 186  	for i := 0; i < b.N; i++ {
	 187  		copy(data, unsorted)
	 188  		b.StartTimer()
	 189  		Slice(data, func(i, j int) bool { return data[i] < data[j] })
	 190  		b.StopTimer()
	 191  	}
	 192  }
	 193  
	 194  func BenchmarkStableString1K(b *testing.B) {
	 195  	b.StopTimer()
	 196  	unsorted := make([]string, 1<<10)
	 197  	for i := range unsorted {
	 198  		unsorted[i] = strconv.Itoa(i ^ 0x2cc)
	 199  	}
	 200  	data := make([]string, len(unsorted))
	 201  
	 202  	for i := 0; i < b.N; i++ {
	 203  		copy(data, unsorted)
	 204  		b.StartTimer()
	 205  		Stable(StringSlice(data))
	 206  		b.StopTimer()
	 207  	}
	 208  }
	 209  
	 210  func BenchmarkSortInt1K(b *testing.B) {
	 211  	b.StopTimer()
	 212  	for i := 0; i < b.N; i++ {
	 213  		data := make([]int, 1<<10)
	 214  		for i := 0; i < len(data); i++ {
	 215  			data[i] = i ^ 0x2cc
	 216  		}
	 217  		b.StartTimer()
	 218  		Ints(data)
	 219  		b.StopTimer()
	 220  	}
	 221  }
	 222  
	 223  func BenchmarkStableInt1K(b *testing.B) {
	 224  	b.StopTimer()
	 225  	unsorted := make([]int, 1<<10)
	 226  	for i := range unsorted {
	 227  		unsorted[i] = i ^ 0x2cc
	 228  	}
	 229  	data := make([]int, len(unsorted))
	 230  	for i := 0; i < b.N; i++ {
	 231  		copy(data, unsorted)
	 232  		b.StartTimer()
	 233  		Stable(IntSlice(data))
	 234  		b.StopTimer()
	 235  	}
	 236  }
	 237  
	 238  func BenchmarkStableInt1K_Slice(b *testing.B) {
	 239  	b.StopTimer()
	 240  	unsorted := make([]int, 1<<10)
	 241  	for i := range unsorted {
	 242  		unsorted[i] = i ^ 0x2cc
	 243  	}
	 244  	data := make([]int, len(unsorted))
	 245  	for i := 0; i < b.N; i++ {
	 246  		copy(data, unsorted)
	 247  		b.StartTimer()
	 248  		SliceStable(data, func(i, j int) bool { return data[i] < data[j] })
	 249  		b.StopTimer()
	 250  	}
	 251  }
	 252  
	 253  func BenchmarkSortInt64K(b *testing.B) {
	 254  	b.StopTimer()
	 255  	for i := 0; i < b.N; i++ {
	 256  		data := make([]int, 1<<16)
	 257  		for i := 0; i < len(data); i++ {
	 258  			data[i] = i ^ 0xcccc
	 259  		}
	 260  		b.StartTimer()
	 261  		Ints(data)
	 262  		b.StopTimer()
	 263  	}
	 264  }
	 265  
	 266  func BenchmarkSortInt64K_Slice(b *testing.B) {
	 267  	b.StopTimer()
	 268  	for i := 0; i < b.N; i++ {
	 269  		data := make([]int, 1<<16)
	 270  		for i := 0; i < len(data); i++ {
	 271  			data[i] = i ^ 0xcccc
	 272  		}
	 273  		b.StartTimer()
	 274  		Slice(data, func(i, j int) bool { return data[i] < data[j] })
	 275  		b.StopTimer()
	 276  	}
	 277  }
	 278  
	 279  func BenchmarkStableInt64K(b *testing.B) {
	 280  	b.StopTimer()
	 281  	for i := 0; i < b.N; i++ {
	 282  		data := make([]int, 1<<16)
	 283  		for i := 0; i < len(data); i++ {
	 284  			data[i] = i ^ 0xcccc
	 285  		}
	 286  		b.StartTimer()
	 287  		Stable(IntSlice(data))
	 288  		b.StopTimer()
	 289  	}
	 290  }
	 291  
	 292  const (
	 293  	_Sawtooth = iota
	 294  	_Rand
	 295  	_Stagger
	 296  	_Plateau
	 297  	_Shuffle
	 298  	_NDist
	 299  )
	 300  
	 301  const (
	 302  	_Copy = iota
	 303  	_Reverse
	 304  	_ReverseFirstHalf
	 305  	_ReverseSecondHalf
	 306  	_Sorted
	 307  	_Dither
	 308  	_NMode
	 309  )
	 310  
	 311  type testingData struct {
	 312  	desc				string
	 313  	t					 *testing.T
	 314  	data				[]int
	 315  	maxswap		 int // number of swaps allowed
	 316  	ncmp, nswap int
	 317  }
	 318  
	 319  func (d *testingData) Len() int { return len(d.data) }
	 320  func (d *testingData) Less(i, j int) bool {
	 321  	d.ncmp++
	 322  	return d.data[i] < d.data[j]
	 323  }
	 324  func (d *testingData) Swap(i, j int) {
	 325  	if d.nswap >= d.maxswap {
	 326  		d.t.Fatalf("%s: used %d swaps sorting slice of %d", d.desc, d.nswap, len(d.data))
	 327  	}
	 328  	d.nswap++
	 329  	d.data[i], d.data[j] = d.data[j], d.data[i]
	 330  }
	 331  
	 332  func min(a, b int) int {
	 333  	if a < b {
	 334  		return a
	 335  	}
	 336  	return b
	 337  }
	 338  
	 339  func lg(n int) int {
	 340  	i := 0
	 341  	for 1<<uint(i) < n {
	 342  		i++
	 343  	}
	 344  	return i
	 345  }
	 346  
	 347  func testBentleyMcIlroy(t *testing.T, sort func(Interface), maxswap func(int) int) {
	 348  	sizes := []int{100, 1023, 1024, 1025}
	 349  	if testing.Short() {
	 350  		sizes = []int{100, 127, 128, 129}
	 351  	}
	 352  	dists := []string{"sawtooth", "rand", "stagger", "plateau", "shuffle"}
	 353  	modes := []string{"copy", "reverse", "reverse1", "reverse2", "sort", "dither"}
	 354  	var tmp1, tmp2 [1025]int
	 355  	for _, n := range sizes {
	 356  		for m := 1; m < 2*n; m *= 2 {
	 357  			for dist := 0; dist < _NDist; dist++ {
	 358  				j := 0
	 359  				k := 1
	 360  				data := tmp1[0:n]
	 361  				for i := 0; i < n; i++ {
	 362  					switch dist {
	 363  					case _Sawtooth:
	 364  						data[i] = i % m
	 365  					case _Rand:
	 366  						data[i] = rand.Intn(m)
	 367  					case _Stagger:
	 368  						data[i] = (i*m + i) % n
	 369  					case _Plateau:
	 370  						data[i] = min(i, m)
	 371  					case _Shuffle:
	 372  						if rand.Intn(m) != 0 {
	 373  							j += 2
	 374  							data[i] = j
	 375  						} else {
	 376  							k += 2
	 377  							data[i] = k
	 378  						}
	 379  					}
	 380  				}
	 381  
	 382  				mdata := tmp2[0:n]
	 383  				for mode := 0; mode < _NMode; mode++ {
	 384  					switch mode {
	 385  					case _Copy:
	 386  						for i := 0; i < n; i++ {
	 387  							mdata[i] = data[i]
	 388  						}
	 389  					case _Reverse:
	 390  						for i := 0; i < n; i++ {
	 391  							mdata[i] = data[n-i-1]
	 392  						}
	 393  					case _ReverseFirstHalf:
	 394  						for i := 0; i < n/2; i++ {
	 395  							mdata[i] = data[n/2-i-1]
	 396  						}
	 397  						for i := n / 2; i < n; i++ {
	 398  							mdata[i] = data[i]
	 399  						}
	 400  					case _ReverseSecondHalf:
	 401  						for i := 0; i < n/2; i++ {
	 402  							mdata[i] = data[i]
	 403  						}
	 404  						for i := n / 2; i < n; i++ {
	 405  							mdata[i] = data[n-(i-n/2)-1]
	 406  						}
	 407  					case _Sorted:
	 408  						for i := 0; i < n; i++ {
	 409  							mdata[i] = data[i]
	 410  						}
	 411  						// Ints is known to be correct
	 412  						// because mode Sort runs after mode _Copy.
	 413  						Ints(mdata)
	 414  					case _Dither:
	 415  						for i := 0; i < n; i++ {
	 416  							mdata[i] = data[i] + i%5
	 417  						}
	 418  					}
	 419  
	 420  					desc := fmt.Sprintf("n=%d m=%d dist=%s mode=%s", n, m, dists[dist], modes[mode])
	 421  					d := &testingData{desc: desc, t: t, data: mdata[0:n], maxswap: maxswap(n)}
	 422  					sort(d)
	 423  					// Uncomment if you are trying to improve the number of compares/swaps.
	 424  					//t.Logf("%s: ncmp=%d, nswp=%d", desc, d.ncmp, d.nswap)
	 425  
	 426  					// If we were testing C qsort, we'd have to make a copy
	 427  					// of the slice and sort it ourselves and then compare
	 428  					// x against it, to ensure that qsort was only permuting
	 429  					// the data, not (for example) overwriting it with zeros.
	 430  					//
	 431  					// In go, we don't have to be so paranoid: since the only
	 432  					// mutating method Sort can call is TestingData.swap,
	 433  					// it suffices here just to check that the final slice is sorted.
	 434  					if !IntsAreSorted(mdata) {
	 435  						t.Fatalf("%s: ints not sorted\n\t%v", desc, mdata)
	 436  					}
	 437  				}
	 438  			}
	 439  		}
	 440  	}
	 441  }
	 442  
	 443  func TestSortBM(t *testing.T) {
	 444  	testBentleyMcIlroy(t, Sort, func(n int) int { return n * lg(n) * 12 / 10 })
	 445  }
	 446  
	 447  func TestHeapsortBM(t *testing.T) {
	 448  	testBentleyMcIlroy(t, Heapsort, func(n int) int { return n * lg(n) * 12 / 10 })
	 449  }
	 450  
	 451  func TestStableBM(t *testing.T) {
	 452  	testBentleyMcIlroy(t, Stable, func(n int) int { return n * lg(n) * lg(n) / 3 })
	 453  }
	 454  
	 455  // This is based on the "antiquicksort" implementation by M. Douglas McIlroy.
	 456  // See https://www.cs.dartmouth.edu/~doug/mdmspe.pdf for more info.
	 457  type adversaryTestingData struct {
	 458  	t				 *testing.T
	 459  	data			[]int // item values, initialized to special gas value and changed by Less
	 460  	maxcmp		int	 // number of comparisons allowed
	 461  	ncmp			int	 // number of comparisons (calls to Less)
	 462  	nsolid		int	 // number of elements that have been set to non-gas values
	 463  	candidate int	 // guess at current pivot
	 464  	gas			 int	 // special value for unset elements, higher than everything else
	 465  }
	 466  
	 467  func (d *adversaryTestingData) Len() int { return len(d.data) }
	 468  
	 469  func (d *adversaryTestingData) Less(i, j int) bool {
	 470  	if d.ncmp >= d.maxcmp {
	 471  		d.t.Fatalf("used %d comparisons sorting adversary data with size %d", d.ncmp, len(d.data))
	 472  	}
	 473  	d.ncmp++
	 474  
	 475  	if d.data[i] == d.gas && d.data[j] == d.gas {
	 476  		if i == d.candidate {
	 477  			// freeze i
	 478  			d.data[i] = d.nsolid
	 479  			d.nsolid++
	 480  		} else {
	 481  			// freeze j
	 482  			d.data[j] = d.nsolid
	 483  			d.nsolid++
	 484  		}
	 485  	}
	 486  
	 487  	if d.data[i] == d.gas {
	 488  		d.candidate = i
	 489  	} else if d.data[j] == d.gas {
	 490  		d.candidate = j
	 491  	}
	 492  
	 493  	return d.data[i] < d.data[j]
	 494  }
	 495  
	 496  func (d *adversaryTestingData) Swap(i, j int) {
	 497  	d.data[i], d.data[j] = d.data[j], d.data[i]
	 498  }
	 499  
	 500  func newAdversaryTestingData(t *testing.T, size int, maxcmp int) *adversaryTestingData {
	 501  	gas := size - 1
	 502  	data := make([]int, size)
	 503  	for i := 0; i < size; i++ {
	 504  		data[i] = gas
	 505  	}
	 506  	return &adversaryTestingData{t: t, data: data, maxcmp: maxcmp, gas: gas}
	 507  }
	 508  
	 509  func TestAdversary(t *testing.T) {
	 510  	const size = 10000						// large enough to distinguish between O(n^2) and O(n*log(n))
	 511  	maxcmp := size * lg(size) * 4 // the factor 4 was found by trial and error
	 512  	d := newAdversaryTestingData(t, size, maxcmp)
	 513  	Sort(d) // This should degenerate to heapsort.
	 514  	// Check data is fully populated and sorted.
	 515  	for i, v := range d.data {
	 516  		if v != i {
	 517  			t.Fatalf("adversary data not fully sorted")
	 518  		}
	 519  	}
	 520  }
	 521  
	 522  func TestStableInts(t *testing.T) {
	 523  	data := ints
	 524  	Stable(IntSlice(data[0:]))
	 525  	if !IntsAreSorted(data[0:]) {
	 526  		t.Errorf("nsorted %v\n	 got %v", ints, data)
	 527  	}
	 528  }
	 529  
	 530  type intPairs []struct {
	 531  	a, b int
	 532  }
	 533  
	 534  // IntPairs compare on a only.
	 535  func (d intPairs) Len() int					 { return len(d) }
	 536  func (d intPairs) Less(i, j int) bool { return d[i].a < d[j].a }
	 537  func (d intPairs) Swap(i, j int)			{ d[i], d[j] = d[j], d[i] }
	 538  
	 539  // Record initial order in B.
	 540  func (d intPairs) initB() {
	 541  	for i := range d {
	 542  		d[i].b = i
	 543  	}
	 544  }
	 545  
	 546  // InOrder checks if a-equal elements were not reordered.
	 547  func (d intPairs) inOrder() bool {
	 548  	lastA, lastB := -1, 0
	 549  	for i := 0; i < len(d); i++ {
	 550  		if lastA != d[i].a {
	 551  			lastA = d[i].a
	 552  			lastB = d[i].b
	 553  			continue
	 554  		}
	 555  		if d[i].b <= lastB {
	 556  			return false
	 557  		}
	 558  		lastB = d[i].b
	 559  	}
	 560  	return true
	 561  }
	 562  
	 563  func TestStability(t *testing.T) {
	 564  	n, m := 100000, 1000
	 565  	if testing.Short() {
	 566  		n, m = 1000, 100
	 567  	}
	 568  	data := make(intPairs, n)
	 569  
	 570  	// random distribution
	 571  	for i := 0; i < len(data); i++ {
	 572  		data[i].a = rand.Intn(m)
	 573  	}
	 574  	if IsSorted(data) {
	 575  		t.Fatalf("terrible rand.rand")
	 576  	}
	 577  	data.initB()
	 578  	Stable(data)
	 579  	if !IsSorted(data) {
	 580  		t.Errorf("Stable didn't sort %d ints", n)
	 581  	}
	 582  	if !data.inOrder() {
	 583  		t.Errorf("Stable wasn't stable on %d ints", n)
	 584  	}
	 585  
	 586  	// already sorted
	 587  	data.initB()
	 588  	Stable(data)
	 589  	if !IsSorted(data) {
	 590  		t.Errorf("Stable shuffled sorted %d ints (order)", n)
	 591  	}
	 592  	if !data.inOrder() {
	 593  		t.Errorf("Stable shuffled sorted %d ints (stability)", n)
	 594  	}
	 595  
	 596  	// sorted reversed
	 597  	for i := 0; i < len(data); i++ {
	 598  		data[i].a = len(data) - i
	 599  	}
	 600  	data.initB()
	 601  	Stable(data)
	 602  	if !IsSorted(data) {
	 603  		t.Errorf("Stable didn't sort %d ints", n)
	 604  	}
	 605  	if !data.inOrder() {
	 606  		t.Errorf("Stable wasn't stable on %d ints", n)
	 607  	}
	 608  }
	 609  
	 610  var countOpsSizes = []int{1e2, 3e2, 1e3, 3e3, 1e4, 3e4, 1e5, 3e5, 1e6}
	 611  
	 612  func countOps(t *testing.T, algo func(Interface), name string) {
	 613  	sizes := countOpsSizes
	 614  	if testing.Short() {
	 615  		sizes = sizes[:5]
	 616  	}
	 617  	if !testing.Verbose() {
	 618  		t.Skip("Counting skipped as non-verbose mode.")
	 619  	}
	 620  	for _, n := range sizes {
	 621  		td := testingData{
	 622  			desc:		name,
	 623  			t:			 t,
	 624  			data:		make([]int, n),
	 625  			maxswap: 1<<31 - 1,
	 626  		}
	 627  		for i := 0; i < n; i++ {
	 628  			td.data[i] = rand.Intn(n / 5)
	 629  		}
	 630  		algo(&td)
	 631  		t.Logf("%s %8d elements: %11d Swap, %10d Less", name, n, td.nswap, td.ncmp)
	 632  	}
	 633  }
	 634  
	 635  func TestCountStableOps(t *testing.T) { countOps(t, Stable, "Stable") }
	 636  func TestCountSortOps(t *testing.T)	 { countOps(t, Sort, "Sort	") }
	 637  
	 638  func bench(b *testing.B, size int, algo func(Interface), name string) {
	 639  	if stringspkg.HasSuffix(testenv.Builder(), "-race") && size > 1e4 {
	 640  		b.Skip("skipping slow benchmark on race builder")
	 641  	}
	 642  	b.StopTimer()
	 643  	data := make(intPairs, size)
	 644  	x := ^uint32(0)
	 645  	for i := 0; i < b.N; i++ {
	 646  		for n := size - 3; n <= size+3; n++ {
	 647  			for i := 0; i < len(data); i++ {
	 648  				x += x
	 649  				x ^= 1
	 650  				if int32(x) < 0 {
	 651  					x ^= 0x88888eef
	 652  				}
	 653  				data[i].a = int(x % uint32(n/5))
	 654  			}
	 655  			data.initB()
	 656  			b.StartTimer()
	 657  			algo(data)
	 658  			b.StopTimer()
	 659  			if !IsSorted(data) {
	 660  				b.Errorf("%s did not sort %d ints", name, n)
	 661  			}
	 662  			if name == "Stable" && !data.inOrder() {
	 663  				b.Errorf("%s unstable on %d ints", name, n)
	 664  			}
	 665  		}
	 666  	}
	 667  }
	 668  
	 669  func BenchmarkSort1e2(b *testing.B)	 { bench(b, 1e2, Sort, "Sort") }
	 670  func BenchmarkStable1e2(b *testing.B) { bench(b, 1e2, Stable, "Stable") }
	 671  func BenchmarkSort1e4(b *testing.B)	 { bench(b, 1e4, Sort, "Sort") }
	 672  func BenchmarkStable1e4(b *testing.B) { bench(b, 1e4, Stable, "Stable") }
	 673  func BenchmarkSort1e6(b *testing.B)	 { bench(b, 1e6, Sort, "Sort") }
	 674  func BenchmarkStable1e6(b *testing.B) { bench(b, 1e6, Stable, "Stable") }
	 675
View as plain text