github.com/x04/go/src@v0.0.0-20200202162449-3d481ceb3525/sort/sort_test.go (about) 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 "github.com/x04/go/src/fmt" 9 "github.com/x04/go/src/internal/testenv" 10 "github.com/x04/go/src/math" 11 "github.com/x04/go/src/math/rand" 12 . "github.com/x04/go/src/sort" 13 "github.com/x04/go/src/strconv" 14 stringspkg "github.com/x04/go/src/strings" 15 "github.com/x04/go/src/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") }