...
Run Format

Source file src/sort/search_test.go

     1	// Copyright 2010 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		"runtime"
     9		. "sort"
    10		"testing"
    11	)
    12	
    13	func f(a []int, x int) func(int) bool {
    14		return func(i int) bool {
    15			return a[i] >= x
    16		}
    17	}
    18	
    19	var data = []int{0: -10, 1: -5, 2: 0, 3: 1, 4: 2, 5: 3, 6: 5, 7: 7, 8: 11, 9: 100, 10: 100, 11: 100, 12: 1000, 13: 10000}
    20	
    21	var tests = []struct {
    22		name string
    23		n    int
    24		f    func(int) bool
    25		i    int
    26	}{
    27		{"empty", 0, nil, 0},
    28		{"1 1", 1, func(i int) bool { return i >= 1 }, 1},
    29		{"1 true", 1, func(i int) bool { return true }, 0},
    30		{"1 false", 1, func(i int) bool { return false }, 1},
    31		{"1e9 991", 1e9, func(i int) bool { return i >= 991 }, 991},
    32		{"1e9 true", 1e9, func(i int) bool { return true }, 0},
    33		{"1e9 false", 1e9, func(i int) bool { return false }, 1e9},
    34		{"data -20", len(data), f(data, -20), 0},
    35		{"data -10", len(data), f(data, -10), 0},
    36		{"data -9", len(data), f(data, -9), 1},
    37		{"data -6", len(data), f(data, -6), 1},
    38		{"data -5", len(data), f(data, -5), 1},
    39		{"data 3", len(data), f(data, 3), 5},
    40		{"data 11", len(data), f(data, 11), 8},
    41		{"data 99", len(data), f(data, 99), 9},
    42		{"data 100", len(data), f(data, 100), 9},
    43		{"data 101", len(data), f(data, 101), 12},
    44		{"data 10000", len(data), f(data, 10000), 13},
    45		{"data 10001", len(data), f(data, 10001), 14},
    46		{"descending a", 7, func(i int) bool { return []int{99, 99, 59, 42, 7, 0, -1, -1}[i] <= 7 }, 4},
    47		{"descending 7", 1e9, func(i int) bool { return 1e9-i <= 7 }, 1e9 - 7},
    48		{"overflow", 2e9, func(i int) bool { return false }, 2e9},
    49	}
    50	
    51	func TestSearch(t *testing.T) {
    52		for _, e := range tests {
    53			i := Search(e.n, e.f)
    54			if i != e.i {
    55				t.Errorf("%s: expected index %d; got %d", e.name, e.i, i)
    56			}
    57		}
    58	}
    59	
    60	// log2 computes the binary logarithm of x, rounded up to the next integer.
    61	// (log2(0) == 0, log2(1) == 0, log2(2) == 1, log2(3) == 2, etc.)
    62	//
    63	func log2(x int) int {
    64		n := 0
    65		for p := 1; p < x; p += p {
    66			// p == 2**n
    67			n++
    68		}
    69		// p/2 < x <= p == 2**n
    70		return n
    71	}
    72	
    73	func TestSearchEfficiency(t *testing.T) {
    74		n := 100
    75		step := 1
    76		for exp := 2; exp < 10; exp++ {
    77			// n == 10**exp
    78			// step == 10**(exp-2)
    79			max := log2(n)
    80			for x := 0; x < n; x += step {
    81				count := 0
    82				i := Search(n, func(i int) bool { count++; return i >= x })
    83				if i != x {
    84					t.Errorf("n = %d: expected index %d; got %d", n, x, i)
    85				}
    86				if count > max {
    87					t.Errorf("n = %d, x = %d: expected <= %d calls; got %d", n, x, max, count)
    88				}
    89			}
    90			n *= 10
    91			step *= 10
    92		}
    93	}
    94	
    95	// Smoke tests for convenience wrappers - not comprehensive.
    96	
    97	var fdata = []float64{0: -3.14, 1: 0, 2: 1, 3: 2, 4: 1000.7}
    98	var sdata = []string{0: "f", 1: "foo", 2: "foobar", 3: "x"}
    99	
   100	var wrappertests = []struct {
   101		name   string
   102		result int
   103		i      int
   104	}{
   105		{"SearchInts", SearchInts(data, 11), 8},
   106		{"SearchFloat64s", SearchFloat64s(fdata, 2.1), 4},
   107		{"SearchStrings", SearchStrings(sdata, ""), 0},
   108		{"IntSlice.Search", IntSlice(data).Search(0), 2},
   109		{"Float64Slice.Search", Float64Slice(fdata).Search(2.0), 3},
   110		{"StringSlice.Search", StringSlice(sdata).Search("x"), 3},
   111	}
   112	
   113	func TestSearchWrappers(t *testing.T) {
   114		for _, e := range wrappertests {
   115			if e.result != e.i {
   116				t.Errorf("%s: expected index %d; got %d", e.name, e.i, e.result)
   117			}
   118		}
   119	}
   120	
   121	func runSearchWrappers() {
   122		SearchInts(data, 11)
   123		SearchFloat64s(fdata, 2.1)
   124		SearchStrings(sdata, "")
   125		IntSlice(data).Search(0)
   126		Float64Slice(fdata).Search(2.0)
   127		StringSlice(sdata).Search("x")
   128	}
   129	
   130	func TestSearchWrappersDontAlloc(t *testing.T) {
   131		if testing.Short() {
   132			t.Skip("skipping malloc count in short mode")
   133		}
   134		if runtime.GOMAXPROCS(0) > 1 {
   135			t.Skip("skipping; GOMAXPROCS>1")
   136		}
   137		allocs := testing.AllocsPerRun(100, runSearchWrappers)
   138		if allocs != 0 {
   139			t.Errorf("expected no allocs for runSearchWrappers, got %v", allocs)
   140		}
   141	}
   142	
   143	func BenchmarkSearchWrappers(b *testing.B) {
   144		for i := 0; i < b.N; i++ {
   145			runSearchWrappers()
   146		}
   147	}
   148	
   149	// Abstract exhaustive test: all sizes up to 100,
   150	// all possible return values. If there are any small
   151	// corner cases, this test exercises them.
   152	func TestSearchExhaustive(t *testing.T) {
   153		for size := 0; size <= 100; size++ {
   154			for targ := 0; targ <= size; targ++ {
   155				i := Search(size, func(i int) bool { return i >= targ })
   156				if i != targ {
   157					t.Errorf("Search(%d, %d) = %d", size, targ, i)
   158				}
   159			}
   160		}
   161	}
   162	

View as plain text